- added alphaFS as 3rd party library

- PrintVulnLeakedHandlers wrapped in try/catch
- removed commented out code in SearchHelper.cs
- added check for empty config in YamlConfigHelper

build_lists/regexes.yaml

@@ -1,2 +1,2 @@
-This is a placeholder.
-To fill this yaml execute one of the scripts download_regexes.py or download_regexes.ps1
+# This is a placeholder.
+# To fill this yaml execute one of the scripts download_regexes.py or download_regexes.ps1

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/ChangeErrorMode.cs

@@ -0,0 +1,56 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   internal static partial class NativeMethods
+   {
+      /// <summary>Controls whether the system will handle the specified types of serious errors or whether the process will handle them.</summary>
+      /// <remarks>Minimum supported client: Windows 2000 Professional</remarks>
+      /// <remarks>Minimum supported server: Windows 2000 Server</remarks>      
+      public sealed class ChangeErrorMode : IDisposable
+      {
+         private readonly ErrorMode _oldMode;
+
+         /// <summary>ChangeErrorMode is for the Win32 SetThreadErrorMode() method, used to suppress possible pop-ups.</summary>
+         /// <param name="mode">One of the <see cref="ErrorMode"/> values.</param>
+         public ChangeErrorMode(ErrorMode mode)
+         {
+            if (IsAtLeastWindows7)
+               SetThreadErrorMode(mode, out _oldMode);
+            else
+               _oldMode = SetErrorMode(mode);
+         }
+
+         void IDisposable.Dispose()
+         {
+            ErrorMode oldMode;
+
+            if (IsAtLeastWindows7)
+               SetThreadErrorMode(_oldMode, out oldMode);
+            else
+               SetErrorMode(_oldMode);
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Device.cs

@@ -0,0 +1,522 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using Microsoft.Win32.SafeHandles;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Security.AccessControl;
+using System.Text;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   /// <summary>Provides static methods to retrieve device resource information from a local or remote host.</summary>
+   public static class Device
+   {
+      #region Enumerate Devices
+
+      /// <summary>[AlphaFS] Enumerates all available devices on the local host.</summary>
+      /// <returns><see cref="IEnumerable{DeviceInfo}"/> instances of type <see cref="DeviceGuid"/> from the local host.</returns>
+      /// <param name="deviceGuid">One of the <see cref="DeviceGuid"/> devices.</param>
+      //[SecurityCritical]
+      //public static IEnumerable<DeviceInfo> EnumerateDevices(DeviceGuid deviceGuid)
+      //{
+      //   return EnumerateDevicesCore(null, deviceGuid, true);
+      //}
+
+
+      ///// <summary>[AlphaFS] Enumerates all available devices of type <see cref="DeviceGuid"/> on the local or remote host.</summary>
+      ///// <returns><see cref="IEnumerable{DeviceInfo}"/> instances of type <see cref="DeviceGuid"/> for the specified <paramref name="hostName"/>.</returns>
+      ///// <param name="hostName">The name of the local or remote host on which the device resides. <c>null</c> refers to the local host.</param>
+      ///// <param name="deviceGuid">One of the <see cref="DeviceGuid"/> devices.</param>
+      //[SecurityCritical]
+      //public static IEnumerable<DeviceInfo> EnumerateDevices(string hostName, DeviceGuid deviceGuid)
+      //{
+      //   return EnumerateDevicesCore(hostName, deviceGuid, true);
+      //}
+
+
+
+
+      /// <summary>[AlphaFS] Enumerates all available devices on the local or remote host.</summary>
+      //[SecurityCritical]
+      //internal static IEnumerable<DeviceInfo> EnumerateDevicesCore(string hostName, DeviceGuid deviceGuid, bool getAllProperties)
+      //{
+      //   if (Utils.IsNullOrWhiteSpace(hostName))
+      //      hostName = Environment.MachineName;
+
+
+      //   // CM_Connect_Machine()
+      //   // MSDN Note: 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. 
+      //   // http://msdn.microsoft.com/en-us/library/windows/hardware/ff537948%28v=vs.85%29.aspx
+
+
+      //   SafeCmConnectMachineHandle safeMachineHandle;
+
+      //   var lastError = NativeMethods.CM_Connect_Machine(Host.GetUncName(hostName), out safeMachineHandle);
+
+      //   NativeMethods.IsValidHandle(safeMachineHandle, lastError);
+
+
+      //   var classGuid = new Guid(Utils.GetEnumDescription(deviceGuid));
+
+
+      //   // Start at the "Root" of the device tree of the specified machine.
+
+      //   using (safeMachineHandle)
+      //   using (var safeHandle = NativeMethods.SetupDiGetClassDevsEx(ref classGuid, IntPtr.Zero, IntPtr.Zero, NativeMethods.SetupDiGetClassDevsExFlags.Present | NativeMethods.SetupDiGetClassDevsExFlags.DeviceInterface, IntPtr.Zero, hostName, IntPtr.Zero))
+      //   {
+      //      NativeMethods.IsValidHandle(safeHandle, Marshal.GetLastWin32Error());
+
+      //      uint memberInterfaceIndex = 0;
+      //      var interfaceStructSize = (uint)Marshal.SizeOf(typeof(NativeMethods.SP_DEVICE_INTERFACE_DATA));
+      //      var dataStructSize = (uint)Marshal.SizeOf(typeof(NativeMethods.SP_DEVINFO_DATA));
+
+
+      //      // Start enumerating device interfaces.
+
+      //      while (true)
+      //      {
+      //         var interfaceData = new NativeMethods.SP_DEVICE_INTERFACE_DATA { cbSize = interfaceStructSize };
+
+      //         var success = NativeMethods.SetupDiEnumDeviceInterfaces(safeHandle, IntPtr.Zero, ref classGuid, memberInterfaceIndex++, ref interfaceData);
+
+      //         lastError = Marshal.GetLastWin32Error();
+
+      //         if (!success)
+      //         {
+      //            if (lastError != Win32Errors.NO_ERROR && lastError != Win32Errors.ERROR_NO_MORE_ITEMS)
+      //               NativeError.ThrowException(lastError, hostName);
+
+      //            break;
+      //         }
+
+
+      //         // Create DeviceInfo instance.
+
+      //         var diData = new NativeMethods.SP_DEVINFO_DATA {cbSize = dataStructSize};
+
+      //         var deviceInfo = new DeviceInfo(hostName) {DevicePath = GetDeviceInterfaceDetail(safeHandle, ref interfaceData, ref diData).DevicePath};
+
+
+      //         if (getAllProperties)
+      //         {
+      //            deviceInfo.InstanceId = GetDeviceInstanceId(safeMachineHandle, hostName, diData);
+
+      //            SetDeviceProperties(safeHandle, deviceInfo, diData);
+      //         }
+
+      //         else
+      //            SetMinimalDeviceProperties(safeHandle, deviceInfo, diData);
+
+
+      //         yield return deviceInfo;
+      //      }
+      //   }
+      //}
+
+
+      #region Private Helpers
+
+      [SecurityCritical]
+      private static string GetDeviceInstanceId(SafeCmConnectMachineHandle safeMachineHandle, string hostName, NativeMethods.SP_DEVINFO_DATA diData)
+      {
+         uint ptrPrevious;
+
+         var lastError = NativeMethods.CM_Get_Parent_Ex(out ptrPrevious, diData.DevInst, 0, safeMachineHandle);
+
+         if (lastError != Win32Errors.CR_SUCCESS)
+            NativeError.ThrowException(lastError, hostName);
+
+
+         using (var safeBuffer = new SafeGlobalMemoryBufferHandle(NativeMethods.DefaultFileBufferSize / 8)) // 512
+         {
+            lastError = NativeMethods.CM_Get_Device_ID_Ex(diData.DevInst, safeBuffer, (uint) safeBuffer.Capacity, 0, safeMachineHandle);
+
+            if (lastError != Win32Errors.CR_SUCCESS)
+               NativeError.ThrowException(lastError, hostName);
+
+
+            // Device InstanceID, such as: "USB\VID_8087&PID_0A2B\5&2EDA7E1E&0&7", "SCSI\DISK&VEN_SANDISK&PROD_X400\4&288ED25&0&000200", ...
+
+            return safeBuffer.PtrToStringUni();
+         }
+      }
+
+
+      /// <summary>Builds a Device Interface Detail Data structure.</summary>
+      /// <returns>An initialized NativeMethods.SP_DEVICE_INTERFACE_DETAIL_DATA instance.</returns>
+      [SecurityCritical]
+      private static NativeMethods.SP_DEVICE_INTERFACE_DETAIL_DATA GetDeviceInterfaceDetail(SafeHandle safeHandle, ref NativeMethods.SP_DEVICE_INTERFACE_DATA interfaceData, ref NativeMethods.SP_DEVINFO_DATA infoData)
+      {
+         var didd = new NativeMethods.SP_DEVICE_INTERFACE_DETAIL_DATA {cbSize = (uint) (IntPtr.Size == 4 ? 6 : 8)};
+
+         var success = NativeMethods.SetupDiGetDeviceInterfaceDetail(safeHandle, ref interfaceData, ref didd, (uint) Marshal.SizeOf(didd), IntPtr.Zero, ref infoData);
+
+         var lastError = Marshal.GetLastWin32Error();
+
+         if (!success)
+            NativeError.ThrowException(lastError);
+
+         return didd;
+      }
+
+
+      [SecurityCritical]
+      private static string GetDeviceRegistryProperty(SafeHandle safeHandle, NativeMethods.SP_DEVINFO_DATA infoData, NativeMethods.SetupDiGetDeviceRegistryPropertyEnum property)
+      {
+         var bufferSize = NativeMethods.DefaultFileBufferSize / 8; // 512
+
+         while (true)
+            using (var safeBuffer = new SafeGlobalMemoryBufferHandle(bufferSize))
+            {
+               var success = NativeMethods.SetupDiGetDeviceRegistryProperty(safeHandle, ref infoData, property, IntPtr.Zero, safeBuffer, (uint) safeBuffer.Capacity, IntPtr.Zero);
+
+               var lastError = Marshal.GetLastWin32Error();
+
+               if (success)
+               {
+                  var value = safeBuffer.PtrToStringUni();
+
+                  return !Utils.IsNullOrWhiteSpace(value) ? value.Trim() : null;
+               }
+
+
+               // MSDN: SetupDiGetDeviceRegistryProperty returns ERROR_INVALID_DATA error code if
+               // the requested property does not exist for a device or if the property data is not valid.
+
+               if (lastError == Win32Errors.ERROR_INVALID_DATA)
+                  return null;
+
+
+               bufferSize = GetDoubledBufferSizeOrThrowException(lastError, safeBuffer, bufferSize, property.ToString());
+            }
+      }
+
+
+
+      [SecurityCritical]
+      private static void SetDeviceProperties(SafeHandle safeHandle, DeviceInfo deviceInfo, NativeMethods.SP_DEVINFO_DATA infoData)
+      {
+         SetMinimalDeviceProperties(safeHandle, deviceInfo, infoData);
+
+
+         deviceInfo.CompatibleIds = GetDeviceRegistryProperty(safeHandle, infoData, NativeMethods.SetupDiGetDeviceRegistryPropertyEnum.CompatibleIds);
+
+         deviceInfo.Driver = GetDeviceRegistryProperty(safeHandle, infoData, NativeMethods.SetupDiGetDeviceRegistryPropertyEnum.Driver);
+
+         deviceInfo.EnumeratorName = GetDeviceRegistryProperty(safeHandle, infoData, NativeMethods.SetupDiGetDeviceRegistryPropertyEnum.EnumeratorName);
+
+         deviceInfo.HardwareId = GetDeviceRegistryProperty(safeHandle, infoData, NativeMethods.SetupDiGetDeviceRegistryPropertyEnum.HardwareId);
+
+         deviceInfo.LocationInformation = GetDeviceRegistryProperty(safeHandle, infoData, NativeMethods.SetupDiGetDeviceRegistryPropertyEnum.LocationInformation);
+
+         deviceInfo.LocationPaths = GetDeviceRegistryProperty(safeHandle, infoData, NativeMethods.SetupDiGetDeviceRegistryPropertyEnum.LocationPaths);
+
+         deviceInfo.Manufacturer = GetDeviceRegistryProperty(safeHandle, infoData, NativeMethods.SetupDiGetDeviceRegistryPropertyEnum.Manufacturer);
+
+         deviceInfo.Service = GetDeviceRegistryProperty(safeHandle, infoData, NativeMethods.SetupDiGetDeviceRegistryPropertyEnum.Service);
+      }
+
+
+      [SecurityCritical]
+      private static void SetMinimalDeviceProperties(SafeHandle safeHandle, DeviceInfo deviceInfo, NativeMethods.SP_DEVINFO_DATA infoData)
+      {
+         deviceInfo.BaseContainerId = new Guid(GetDeviceRegistryProperty(safeHandle, infoData, NativeMethods.SetupDiGetDeviceRegistryPropertyEnum.BaseContainerId));
+
+         deviceInfo.ClassGuid = new Guid(GetDeviceRegistryProperty(safeHandle, infoData, NativeMethods.SetupDiGetDeviceRegistryPropertyEnum.ClassGuid));
+
+         deviceInfo.DeviceClass = GetDeviceRegistryProperty(safeHandle, infoData, NativeMethods.SetupDiGetDeviceRegistryPropertyEnum.Class);
+
+         deviceInfo.DeviceDescription = GetDeviceRegistryProperty(safeHandle, infoData, NativeMethods.SetupDiGetDeviceRegistryPropertyEnum.DeviceDescription);
+
+         deviceInfo.FriendlyName = GetDeviceRegistryProperty(safeHandle, infoData, NativeMethods.SetupDiGetDeviceRegistryPropertyEnum.FriendlyName);
+
+         deviceInfo.PhysicalDeviceObjectName = GetDeviceRegistryProperty(safeHandle, infoData, NativeMethods.SetupDiGetDeviceRegistryPropertyEnum.PhysicalDeviceObjectName);
+      }
+
+
+      [SecurityCritical]
+      internal static int GetDoubledBufferSizeOrThrowException(int lastError, SafeHandle safeBuffer, int bufferSize, string pathForException)
+      {
+         if (null != safeBuffer && !safeBuffer.IsClosed)
+            safeBuffer.Close();
+
+
+         switch ((uint) lastError)
+         {
+            case Win32Errors.ERROR_MORE_DATA:
+            case Win32Errors.ERROR_INSUFFICIENT_BUFFER:
+               bufferSize *= 2;
+               break;
+
+
+            default:
+               NativeMethods.IsValidHandle(safeBuffer, lastError, string.Format(CultureInfo.InvariantCulture, "Buffer size: {0}. Path: {1}", bufferSize.ToString(CultureInfo.InvariantCulture), pathForException));
+               break;
+         }
+
+
+         return bufferSize;
+      }
+      
+
+      /// <summary>Repeatedly invokes InvokeIoControl with the specified input until enough memory has been allocated.</summary>
+      [SecurityCritical]
+      private static void InvokeIoControlUnknownSize<T>(SafeFileHandle handle, uint controlCode, T input, uint increment = 128)
+      {
+         var inputSize = (uint) Marshal.SizeOf(input);
+         var outputLength = increment;
+
+         do
+         {
+            var output = new byte[outputLength];
+            uint bytesReturned;
+
+            var success = NativeMethods.DeviceIoControlUnknownSize(handle, controlCode, input, inputSize, output, outputLength, out bytesReturned, IntPtr.Zero);
+
+            var lastError = Marshal.GetLastWin32Error();
+            if (!success)
+            {
+               switch ((uint) lastError)
+               {
+                  case Win32Errors.ERROR_MORE_DATA:
+                  case Win32Errors.ERROR_INSUFFICIENT_BUFFER:
+                     outputLength += increment;
+                     break;
+
+                  default:
+                     if (lastError != Win32Errors.ERROR_SUCCESS)
+                        NativeError.ThrowException(lastError);
+                     break;
+               }
+            }
+
+            else
+               break;
+
+         } while (true);
+      }
+
+      #endregion // Private Helpers
+
+
+      #endregion // Enumerate Devices
+
+
+      #region Compression
+
+      /// <summary>[AlphaFS] Sets the NTFS compression state of a file or directory on a volume whose file system supports per-file and per-directory compression.</summary>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="isFolder">Specifies that <paramref name="path"/> is a file or directory.</param>
+      /// <param name="path">A path that describes a folder or file to compress or decompress.</param>
+      /// <param name="compress"><c>true</c> = compress, <c>false</c> = decompress</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static void ToggleCompressionCore(KernelTransaction transaction, bool isFolder, string path, bool compress, PathFormat pathFormat)
+      {
+         using (var handle = File.CreateFileCore(transaction, isFolder, path, ExtendedFileAttributes.BackupSemantics, null, FileMode.Open, FileSystemRights.Modify, FileShare.None, true, false, pathFormat))
+
+            InvokeIoControlUnknownSize(handle, NativeMethods.FSCTL_SET_COMPRESSION, compress ? 1 : 0);
+      }
+
+      #endregion // Compression
+
+
+      #region Link
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J").</summary>
+      internal static void CreateDirectoryJunction(SafeFileHandle safeHandle, string directoryPath)
+      {
+         var targetDirBytes = Encoding.Unicode.GetBytes(Path.NonInterpretedPathPrefix + Path.GetRegularPathCore(directoryPath, GetFullPathOptions.AddTrailingDirectorySeparator, false));
+
+         var header = new NativeMethods.ReparseDataBufferHeader
+         {
+            ReparseTag = ReparsePointTag.MountPoint,
+            ReparseDataLength = (ushort) (targetDirBytes.Length + 12)
+         };
+
+         var mountPoint = new NativeMethods.MountPointReparseBuffer
+         {
+            SubstituteNameOffset = 0,
+            SubstituteNameLength = (ushort) targetDirBytes.Length,
+            PrintNameOffset = (ushort) (targetDirBytes.Length + UnicodeEncoding.CharSize),
+            PrintNameLength = 0
+         };
+
+         var reparseDataBuffer = new NativeMethods.REPARSE_DATA_BUFFER
+         {
+            ReparseTag = header.ReparseTag,
+            ReparseDataLength = header.ReparseDataLength,
+
+            SubstituteNameOffset = mountPoint.SubstituteNameOffset,
+            SubstituteNameLength = mountPoint.SubstituteNameLength,
+            PrintNameOffset = mountPoint.PrintNameOffset,
+            PrintNameLength = mountPoint.PrintNameLength,
+
+            PathBuffer = new byte[NativeMethods.MAXIMUM_REPARSE_DATA_BUFFER_SIZE - 16] // 16368
+         };
+
+         targetDirBytes.CopyTo(reparseDataBuffer.PathBuffer, 0);
+
+
+         using (var safeBuffer = new SafeGlobalMemoryBufferHandle(Marshal.SizeOf(reparseDataBuffer)))
+         {
+            safeBuffer.StructureToPtr(reparseDataBuffer, false);
+
+            uint bytesReturned;
+            var succes = NativeMethods.DeviceIoControl2(safeHandle, NativeMethods.FSCTL_SET_REPARSE_POINT, safeBuffer, (uint) (targetDirBytes.Length + 20), IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero);
+
+            var lastError = Marshal.GetLastWin32Error();
+            if (!succes)
+               NativeError.ThrowException(lastError, directoryPath);
+         }
+      }
+
+
+      /// <summary>[AlphaFS] Deletes an NTFS directory junction.</summary>
+      internal static void DeleteDirectoryJunction(SafeFileHandle safeHandle)
+      {
+         var reparseDataBuffer = new NativeMethods.REPARSE_DATA_BUFFER
+         {
+            ReparseTag = ReparsePointTag.MountPoint,
+            ReparseDataLength = 0,
+            PathBuffer = new byte[NativeMethods.MAXIMUM_REPARSE_DATA_BUFFER_SIZE - 16] // 16368
+         };
+
+
+         using (var safeBuffer = new SafeGlobalMemoryBufferHandle(Marshal.SizeOf(reparseDataBuffer)))
+         {
+            safeBuffer.StructureToPtr(reparseDataBuffer, false);
+
+            uint bytesReturned;
+            var success = NativeMethods.DeviceIoControl2(safeHandle, NativeMethods.FSCTL_DELETE_REPARSE_POINT, safeBuffer, NativeMethods.REPARSE_DATA_BUFFER_HEADER_SIZE, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero);
+
+            var lastError = Marshal.GetLastWin32Error();
+            if (!success)
+               NativeError.ThrowException(lastError);
+         }
+      }
+
+
+      /// <summary>[AlphaFS] Get information about the target of a mount point or symbolic link on an NTFS file system.</summary>
+      /// <exception cref="NotAReparsePointException"/>
+      /// <exception cref="UnrecognizedReparsePointException"/>
+      [SecurityCritical]
+      internal static LinkTargetInfo GetLinkTargetInfo(SafeFileHandle safeHandle, string reparsePath)
+      {
+         using (var safeBuffer = GetLinkTargetData(safeHandle, reparsePath))
+         {
+            var header = safeBuffer.PtrToStructure<NativeMethods.ReparseDataBufferHeader>(0);
+
+            var marshalReparseBuffer = (int) Marshal.OffsetOf(typeof(NativeMethods.ReparseDataBufferHeader), "data");
+
+            var dataOffset = (int) (marshalReparseBuffer + (header.ReparseTag == ReparsePointTag.MountPoint
+               ? Marshal.OffsetOf(typeof(NativeMethods.MountPointReparseBuffer), "data")
+               : Marshal.OffsetOf(typeof(NativeMethods.SymbolicLinkReparseBuffer), "data")).ToInt64());
+
+            var dataBuffer = new byte[NativeMethods.MAXIMUM_REPARSE_DATA_BUFFER_SIZE - dataOffset];
+
+
+            switch (header.ReparseTag)
+            {
+               // MountPoint can be a junction or mounted drive (mounted drive starts with "\??\Volume").
+
+               case ReparsePointTag.MountPoint:
+                  var mountPoint = safeBuffer.PtrToStructure<NativeMethods.MountPointReparseBuffer>(marshalReparseBuffer);
+
+                  safeBuffer.CopyTo(dataOffset, dataBuffer);
+
+                  return new LinkTargetInfo(
+                     Encoding.Unicode.GetString(dataBuffer, mountPoint.SubstituteNameOffset, mountPoint.SubstituteNameLength),
+                     Encoding.Unicode.GetString(dataBuffer, mountPoint.PrintNameOffset, mountPoint.PrintNameLength));
+
+
+               case ReparsePointTag.SymLink:
+                  var symLink = safeBuffer.PtrToStructure<NativeMethods.SymbolicLinkReparseBuffer>(marshalReparseBuffer);
+
+                  safeBuffer.CopyTo(dataOffset, dataBuffer);
+
+                  return new SymbolicLinkTargetInfo(
+                     Encoding.Unicode.GetString(dataBuffer, symLink.SubstituteNameOffset, symLink.SubstituteNameLength),
+                     Encoding.Unicode.GetString(dataBuffer, symLink.PrintNameOffset, symLink.PrintNameLength), symLink.Flags);
+
+
+               default:
+                  throw new UnrecognizedReparsePointException(reparsePath);
+            }
+         }
+      }
+
+
+      /// <summary>[AlphaFS] Get information about the target of a mount point or symbolic link on an NTFS file system.</summary>
+      /// <exception cref="NotAReparsePointException"/>
+      /// <exception cref="UnrecognizedReparsePointException"/>
+      [SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times")]
+      [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Disposing is controlled.")]
+      [SecurityCritical]
+      private static SafeGlobalMemoryBufferHandle GetLinkTargetData(SafeFileHandle safeHandle, string reparsePath)
+      {
+         var safeBuffer = new SafeGlobalMemoryBufferHandle(NativeMethods.MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
+
+         while (true)
+         {
+            uint bytesReturned;
+            var success = NativeMethods.DeviceIoControl(safeHandle, NativeMethods.FSCTL_GET_REPARSE_POINT, IntPtr.Zero, 0, safeBuffer, (uint) safeBuffer.Capacity, out bytesReturned, IntPtr.Zero);
+
+            var lastError = Marshal.GetLastWin32Error();
+            if (!success)
+            {
+               switch ((uint) lastError)
+               {
+                  case Win32Errors.ERROR_MORE_DATA:
+                  case Win32Errors.ERROR_INSUFFICIENT_BUFFER:
+
+                     // Should not happen since we already use the maximum size.
+
+                     if (safeBuffer.Capacity < bytesReturned)
+                        safeBuffer.Close();
+                     break;
+
+
+                  default:
+                     if (lastError != Win32Errors.ERROR_SUCCESS)
+                        NativeError.ThrowException(lastError, reparsePath);
+                     break;
+               }
+            }
+
+            else
+               break;
+         }
+
+
+         return safeBuffer;
+      }
+
+      #endregion // Link
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/DeviceInfo.cs

@@ -0,0 +1,141 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+
+using System;
+using System.Collections.Generic;
+using System.Security;
+using System.Security.Permissions;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   /// <summary>Provides access to information of a device, on a local or remote host.</summary>
+   [SecurityPermission(SecurityAction.InheritanceDemand, UnmanagedCode = true)]
+   [Serializable]
+   [SecurityCritical]
+   public sealed class DeviceInfo
+   {
+      #region Constructors
+      
+      /// <summary>Initializes a DeviceInfo class.</summary>
+      //[SecurityCritical]
+      //public DeviceInfo()
+      //{
+      //   HostName = Host.GetUncName();
+      //}
+
+      /// <summary>Initializes a DeviceInfo class.</summary>
+      /// <param name="host">The DNS or NetBIOS name of the remote server. <c>null</c> refers to the local host.</param>
+      //[SecurityCritical]
+      //public DeviceInfo(string host)
+      //{
+      //   HostName = Host.GetUncName(host).Replace(Path.UncPrefix, string.Empty);
+      //}
+
+      #endregion // Constructors
+
+
+      #region Methods
+
+      /// <summary>Enumerates all available devices on the local host.</summary>
+      /// <param name="deviceGuid">One of the <see cref="Filesystem.DeviceGuid"/> devices.</param>
+      /// <returns><see cref="IEnumerable{DeviceInfo}"/> instances of type <see cref="Filesystem.DeviceGuid"/> from the local host.</returns>
+      //[SecurityCritical]
+      //public IEnumerable<DeviceInfo> EnumerateDevices(DeviceGuid deviceGuid)
+      //{
+      //   return Device.EnumerateDevicesCore(HostName, deviceGuid, true);
+      //}
+      
+      #endregion // Methods
+
+
+      #region Properties
+
+      /// <summary>Represents the <see cref="Guid"/> value of the base container identifier (ID) .The Windows Plug and Play (PnP) manager assigns this value to the device node (devnode).</summary>
+      public Guid BaseContainerId { get; internal set; }
+
+
+      /// <summary>Represents the name of the device setup class that a device instance belongs to.</summary>
+      public string DeviceClass { get; internal set; }
+
+
+      /// <summary>Represents the <see cref="Guid"/> of the device setup class that a device instance belongs to.</summary>
+      public Guid ClassGuid { get; internal set; }
+
+
+      /// <summary>Represents the list of compatible identifiers for a device instance.</summary>
+      public string CompatibleIds { get; internal set; }
+
+
+      /// <summary>Represents a description of a device instance.</summary>
+      public string DeviceDescription { get; internal set; }
+
+
+      /// <summary>The device interface path.</summary>
+      public string DevicePath { get; internal set; }
+
+
+      /// <summary>Represents the registry entry name of the driver key for a device instance.</summary>
+      public string Driver { get; internal set; }
+
+
+      /// <summary>Represents the name of the enumerator for a device instance.</summary>
+      public string EnumeratorName { get; internal set; }
+
+
+      /// <summary>Represents the friendly name of a device instance.</summary>
+      public string FriendlyName { get; internal set; }
+
+
+      /// <summary>Represents the list of hardware identifiers for a device instance.</summary>
+      public string HardwareId { get; internal set; }
+
+
+      /// <summary>The host name that was passed to the class constructor.</summary>
+      public string HostName { get; internal set; }
+
+
+      /// <summary>Gets the instance Id of the device.</summary>
+      public string InstanceId { get; internal set; }
+
+
+      /// <summary>Represents the bus-specific physical location of a device instance.</summary>
+      public string LocationInformation { get; internal set; }
+
+
+      /// <summary>Represents the location of a device instance in the device tree.</summary>
+      public string LocationPaths { get; internal set; }
+
+
+      /// <summary>Represents the name of the manufacturer of a device instance.</summary>
+      public string Manufacturer { get; internal set; }
+
+
+      /// <summary>Encapsulates the physical device location information provided by a device's firmware to Windows.</summary>
+      public string PhysicalDeviceObjectName { get; internal set; }
+
+
+      /// <summary>Represents the name of the service that is installed for a device instance.</summary>
+      public string Service { get; internal set; }
+
+      #endregion // Properties
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/DiskSpaceInfo.cs

@@ -0,0 +1,272 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using System.Security;
+using winPEAS._3rdParty.AlphaFS;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   /// <summary>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.
+   /// <para>This class cannot be inherited.</para>
+   /// </summary>
+   [Serializable]
+   [SecurityCritical]
+   public sealed class DiskSpaceInfo
+   {
+      [NonSerialized] private readonly bool _initGetClusterInfo = true;
+      [NonSerialized] private readonly bool _initGetSpaceInfo = true;
+      [NonSerialized] private readonly CultureInfo _cultureInfo = CultureInfo.CurrentCulture;
+      [NonSerialized] private readonly bool _continueOnAccessError;
+
+
+      /// <summary>Initializes a DiskSpaceInfo instance.</summary>
+      /// <param name="drivePath">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</param>
+      /// <Remark>This is a Lazyloading object; call <see cref="Refresh()"/> to populate all properties first before accessing.</Remark>
+      [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Utils.IsNullOrWhiteSpace validates arguments.")]
+      [SecurityCritical]
+      public DiskSpaceInfo(string drivePath)
+      {
+         if (Utils.IsNullOrWhiteSpace(drivePath))
+            throw new ArgumentNullException("drivePath");
+
+
+         drivePath = drivePath.Length == 1 ? drivePath + Path.VolumeSeparatorChar : Path.GetPathRoot(drivePath, false);
+
+         if (Utils.IsNullOrWhiteSpace(drivePath))
+            throw new ArgumentException(Resources.InvalidDriveLetterArgument, "drivePath");
+
+
+         // MSDN:
+         // 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.
+         DriveName = Path.AddTrailingDirectorySeparator(drivePath, false);
+      }
+
+      
+      /// <summary>Initializes a DiskSpaceInfo instance.</summary>
+      /// <param name="drivePath">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</param>
+      /// <param name="spaceInfoType"><c>null</c> gets both size- and disk cluster information. <c>true</c> Get only disk cluster information, <c>false</c> Get only size information.</param>
+      /// <param name="refresh">Refreshes the state of the object.</param>
+      /// <param name="continueOnException"><c>true</c> suppress any Exception that might be thrown as a result from a failure, such as unavailable resources.</param>
+      [SecurityCritical]
+      public DiskSpaceInfo(string drivePath, bool? spaceInfoType, bool refresh, bool continueOnException) : this(drivePath)
+      {
+         if (spaceInfoType == null)
+         {
+            _initGetSpaceInfo = true;
+            _initGetClusterInfo = true;
+         }
+
+         else
+         {
+            _initGetSpaceInfo = (bool) !spaceInfoType;
+            _initGetClusterInfo = (bool) spaceInfoType;
+         }
+
+         _continueOnAccessError = continueOnException;
+
+         if (refresh)
+            Refresh();
+      }
+
+
+      /// <summary>Indicates the amount of available free space on a drive, formatted as percentage.</summary>
+      public string AvailableFreeSpacePercent
+      {
+         get
+         {
+            return PercentCalculate(TotalNumberOfBytes - (TotalNumberOfBytes - TotalNumberOfFreeBytes), 0, TotalNumberOfBytes).ToString("0.##", _cultureInfo) + "%";
+         }
+      }
+
+
+      /// <summary>Indicates the amount of available free space on a drive, formatted as a unit size.</summary>
+      public string AvailableFreeSpaceUnitSize
+      {
+         get { return Utils.UnitSizeToText(TotalNumberOfFreeBytes, _cultureInfo); }
+      }
+
+
+      /// <summary>Returns the Clusters size.</summary>
+      public long ClusterSize
+      {
+         get { return SectorsPerCluster * BytesPerSector; }
+      }
+
+
+      /// <summary>Gets the name of a drive.</summary>
+      /// <returns>The name of the drive.</returns>
+      /// <remarks>This property is the name assigned to the drive, such as C:\ or E:\</remarks>
+      public string DriveName { get; private set; }
+
+
+      /// <summary>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.</summary>
+      public string TotalSizeUnitSize
+      {
+         get { return Utils.UnitSizeToText(TotalNumberOfBytes, _cultureInfo); }
+      }
+
+
+      /// <summary>Indicates the amount of used space on a drive, formatted as percentage.</summary>
+      public string UsedSpacePercent
+      {
+         get
+         {
+            return PercentCalculate(TotalNumberOfBytes - FreeBytesAvailable, 0, TotalNumberOfBytes).ToString("0.##", _cultureInfo) + "%";
+         }
+      }
+
+
+      /// <summary>Indicates the amount of used space on a drive, formatted as a unit size.</summary>
+      public string UsedSpaceUnitSize
+      {
+         get { return Utils.UnitSizeToText(TotalNumberOfBytes - FreeBytesAvailable, _cultureInfo); }
+      }
+
+
+      /// <summary>The total number of free bytes on a disk that are available to the user who is associated with the calling thread.</summary>
+      public long FreeBytesAvailable { get; private set; }
+
+
+      /// <summary>The total number of bytes on a disk that are available to the user who is associated with the calling thread.</summary>
+      public long TotalNumberOfBytes { get; private set; }
+
+
+      /// <summary>The total number of free bytes on a disk.</summary>
+      public long TotalNumberOfFreeBytes { get; private set; }
+
+
+      /// <summary>The number of bytes per sector.</summary>
+      public int BytesPerSector { get; private set; }
+
+
+      /// <summary>The total number of free clusters on the disk that are available to the user who is associated with the calling thread.</summary>
+      public int NumberOfFreeClusters { get; private set; }
+
+
+      /// <summary>The number of sectors per cluster.</summary>
+      public int SectorsPerCluster { get; private set; }
+
+
+      /// <summary>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.
+      /// </summary>
+      public long TotalNumberOfClusters { get; private set; }
+
+
+
+
+      /// <summary>Refreshes the state of the object.</summary>
+      public void Refresh()
+      {
+         Reset();
+
+         using (new NativeMethods.ChangeErrorMode(NativeMethods.ErrorMode.FailCriticalErrors))
+         {
+            int lastError;
+
+
+            // Get size information.
+
+            if (_initGetSpaceInfo)
+            {
+               long freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes;
+
+               var success = NativeMethods.GetDiskFreeSpaceEx(DriveName, out freeBytesAvailable, out totalNumberOfBytes, out totalNumberOfFreeBytes);
+
+               lastError = Marshal.GetLastWin32Error();
+
+               if (!success && !_continueOnAccessError && lastError != Win32Errors.ERROR_NOT_READY)
+                  NativeError.ThrowException(lastError, DriveName);
+
+
+               FreeBytesAvailable = freeBytesAvailable;
+               TotalNumberOfBytes = totalNumberOfBytes;
+               TotalNumberOfFreeBytes = totalNumberOfFreeBytes;
+            }
+
+
+            // Get cluster information.
+
+            if (_initGetClusterInfo)
+            {
+               int sectorsPerCluster, bytesPerSector, numberOfFreeClusters;
+               uint totalNumberOfClusters;
+
+               var success = NativeMethods.GetDiskFreeSpace(DriveName, out sectorsPerCluster, out bytesPerSector, out numberOfFreeClusters, out totalNumberOfClusters);
+
+               lastError = Marshal.GetLastWin32Error();
+
+               if (!success && !_continueOnAccessError && lastError != Win32Errors.ERROR_NOT_READY)
+                  NativeError.ThrowException(lastError, DriveName);
+
+
+               BytesPerSector = bytesPerSector;
+               NumberOfFreeClusters = numberOfFreeClusters;
+               SectorsPerCluster = sectorsPerCluster;
+               TotalNumberOfClusters = totalNumberOfClusters;
+            }
+         }
+      }
+
+
+      /// <summary>Initializes all <see ref="Alphaleonis.Win32.Filesystem.DiskSpaceInfo"/> properties to 0.</summary>
+      private void Reset()
+      {
+         if (_initGetSpaceInfo)
+         {
+            FreeBytesAvailable = 0;
+            TotalNumberOfBytes = 0;
+            TotalNumberOfFreeBytes = 0;
+         }
+
+
+         if (_initGetClusterInfo)
+         {
+            BytesPerSector = 0;
+            NumberOfFreeClusters = 0;
+            SectorsPerCluster = 0;
+            TotalNumberOfClusters = 0;
+         }
+      }
+
+
+      /// <summary>Returns the drive name.</summary>
+      /// <returns>A string that represents this object.</returns>
+      public override string ToString()
+      {
+         return DriveName;
+      }
+
+
+      /// <summary>Calculates a percentage value.</summary>
+      private static double PercentCalculate(double currentValue, double minimumValue, double maximumValue)
+      {
+         return currentValue < 0 || maximumValue <= 0 ? 0 : currentValue * 100 / (maximumValue - minimumValue);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/DriveInfo.cs

@@ -0,0 +1,415 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using System.Security;
+using winPEAS._3rdParty.AlphaFS;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   /// <summary>Provides access to information on a local or remote drive.</summary>
+   /// <remarks>
+   /// 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.
+   /// </remarks>
+   [Serializable]
+   [SecurityCritical]
+   public sealed class DriveInfo
+   {
+      [NonSerialized] private readonly VolumeInfo _volumeInfo;
+      [NonSerialized] private readonly DiskSpaceInfo _dsi;
+      [NonSerialized] private bool _initDsie;
+      [NonSerialized] private DriveType? _driveType;
+      [NonSerialized] private string _dosDeviceName;
+      [NonSerialized] private DirectoryInfo _rootDirectory;
+      [NonSerialized] private readonly string _name;
+
+
+      #region Constructors
+
+      /// <summary>Provides access to information on the specified drive.</summary>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <param name="driveName">
+      ///   A valid drive path or drive letter.
+      ///   <para>This can be either uppercase or lowercase,</para>
+      ///   <para>'a' to 'z' or a network share in the format: \\server\share</para>
+      /// </param>
+      [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Utils.IsNullOrWhiteSpace validates arguments.")]
+      [SecurityCritical]
+      public DriveInfo(string driveName)
+      {
+         if (Utils.IsNullOrWhiteSpace(driveName))
+            throw new ArgumentNullException("driveName");
+
+
+         driveName = driveName.Length == 1 ? driveName + Path.VolumeSeparatorChar : Path.GetPathRoot(driveName, false);
+
+         if (Utils.IsNullOrWhiteSpace(driveName))
+            throw new ArgumentException(Resources.InvalidDriveLetterArgument, "driveName");
+
+
+         _name = Path.AddTrailingDirectorySeparator(driveName, false);
+
+         // Initiate VolumeInfo() lazyload instance.
+         _volumeInfo = new VolumeInfo(_name, false, true);
+
+         // Initiate DiskSpaceInfo() lazyload instance.
+         _dsi = new DiskSpaceInfo(_name, null, false, true);
+      }
+
+      #endregion // Constructors
+
+
+      #region Properties
+
+      /// <summary>Indicates the amount of available free space on a drive.</summary>
+      /// <returns>The amount of free space available on the drive, in bytes.</returns>
+      /// <remarks>This property indicates the amount of free space available on the drive. Note that this number may be different from the <see cref="TotalFreeSpace"/> number because this property takes into account disk quotas.</remarks>
+      public long AvailableFreeSpace
+      {
+         get
+         {
+            GetDeviceInfo(3, 0);
+            return null == _dsi ? 0 : _dsi.FreeBytesAvailable;
+         }
+      }
+
+      /// <summary>Gets the name of the file system, such as NTFS or FAT32.</summary>
+      /// <remarks>Use DriveFormat to determine what formatting a drive uses.</remarks>
+      public string DriveFormat
+      {
+         get { return (string) GetDeviceInfo(0, 1); }
+      }
+
+
+      /// <summary>Gets the drive type.</summary>
+      /// <returns>One of the <see cref="System.IO.DriveType"/> values.</returns>
+      /// <remarks>
+      /// The DriveType property indicates whether a drive is any of: CDRom, Fixed, Unknown, Network, NoRootDirectory,
+      /// Ram, Removable, or Unknown. Values are listed in the <see cref="System.IO.DriveType"/> enumeration.
+      /// </remarks>
+      public DriveType DriveType
+      {
+         get { return (DriveType) GetDeviceInfo(2, 0); }
+      }
+
+
+      /// <summary>Gets a value indicating whether a drive is ready.</summary>
+      /// <returns><c>true</c> if the drive is ready; otherwise, <c>false</c>.</returns>
+      /// <remarks>
+      /// 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.
+      /// </remarks>
+      public bool IsReady
+      {
+         get { return File.ExistsCore(null, true, Name, PathFormat.LongFullPath); }
+      }
+
+
+      /// <summary>Gets the name of the drive.</summary>
+      /// <returns>The name of the drive.</returns>
+      /// <remarks>This property is the name assigned to the drive, such as C:\ or E:\</remarks>
+      public string Name
+      {
+         get { return _name; }
+      }
+
+
+      /// <summary>Gets the root directory of a drive.</summary>
+      /// <returns>A DirectoryInfo object that contains the root directory of the drive.</returns>
+      public DirectoryInfo RootDirectory
+      {
+         get { return (DirectoryInfo) GetDeviceInfo(2, 1); }
+      }
+
+      /// <summary>Gets the total amount of free space available on a drive.</summary>
+      /// <returns>The total free space available on a drive, in bytes.</returns>
+      /// <remarks>This property indicates the total amount of free space available on the drive, not just what is available to the current user.</remarks>
+      public long TotalFreeSpace
+      {
+         get
+         {
+            GetDeviceInfo(3, 0);
+            return null == _dsi ? 0 : _dsi.TotalNumberOfFreeBytes;
+         }
+      }
+
+
+      /// <summary>Gets the total size of storage space on a drive.</summary>
+      /// <returns>The total size of the drive, in bytes.</returns>
+      /// <remarks>This property indicates the total size of the drive in bytes, not just what is available to the current user.</remarks>
+      public long TotalSize
+      {
+         get
+         {
+            GetDeviceInfo(3, 0);
+            return null == _dsi ? 0 : _dsi.TotalNumberOfBytes;
+         }
+      }
+
+
+      /// <summary>Gets or sets the volume label of a drive.</summary>
+      /// <returns>The volume label.</returns>
+      /// <remarks>
+      /// 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 <c>null</c> is a valid VolumeLabel.
+      /// </remarks>
+      public string VolumeLabel
+      {
+         get { return (string) GetDeviceInfo(0, 2); }
+         set { Volume.SetVolumeLabel(Name, value); }
+      }
+
+      /// <summary>[AlphaFS] Returns the <see ref="Alphaleonis.Win32.Filesystem.DiskSpaceInfo"/> instance.</summary>
+      public DiskSpaceInfo DiskSpaceInfo
+      {
+         get
+         {
+            GetDeviceInfo(3, 0);
+            return _dsi;
+         }
+      }
+
+
+      /// <summary>[AlphaFS] The MS-DOS device name.</summary>
+      public string DosDeviceName
+      {
+         get { return (string) GetDeviceInfo(1, 0); }
+      }
+
+
+      /// <summary>[AlphaFS] Indicates if this drive is a SUBST.EXE / DefineDosDevice drive mapping.</summary>
+      public bool IsDosDeviceSubstitute
+      {
+         get { return !Utils.IsNullOrWhiteSpace(DosDeviceName) && DosDeviceName.StartsWith(Path.NonInterpretedPathPrefix, StringComparison.OrdinalIgnoreCase); }
+      }
+
+
+      /// <summary>[AlphaFS] Indicates if this drive is a UNC path.</summary>
+      public bool IsUnc
+      {
+         get
+         {
+            return !IsDosDeviceSubstitute && DriveType == DriveType.Network ||
+               
+                   // Handle Host devices with file systems: FAT/FAT32, UDF (CDRom), ...
+                   Name.StartsWith(Path.UncPrefix, StringComparison.Ordinal) && DriveType == DriveType.NoRootDirectory && DriveFormat.Equals(DriveType.Unknown.ToString(), StringComparison.OrdinalIgnoreCase);
+         }
+      }
+
+
+      /// <summary>[AlphaFS] Determines whether the specified volume name is a defined volume on the current computer.</summary>
+      public bool IsVolume
+      {
+         get { return null != GetDeviceInfo(0, 0); }
+      }
+
+
+      /// <summary>[AlphaFS] Contains information about a file-system volume.</summary>
+      /// <returns>A VolumeInfo object that contains file-system volume information of the drive.</returns>
+      public VolumeInfo VolumeInfo
+      {
+         get { return (VolumeInfo) GetDeviceInfo(0, 0); }
+      }
+
+
+      #endregion // Properties
+
+
+      #region Methods
+
+      #region .NET
+
+      /// <summary>Retrieves the <see cref="DriveInfo"/> of all logical drives on the Computer.</summary>
+      /// <returns>An array of type <see cref="Alphaleonis.Win32.Filesystem.DriveInfo"/> that represents the logical drives on the Computer.</returns>
+      [SecurityCritical]
+      public static DriveInfo[] GetDrives()
+      {
+         return Directory.EnumerateLogicalDrivesCore(false, false).ToArray();
+      }
+
+
+      /// <summary>Returns a drive name as a string.</summary>
+      /// <returns>The name of the drive.</returns>
+      /// <remarks>This method returns the Name property.</remarks>
+      public override string ToString()
+      {
+         return _name;
+      }
+
+      #endregion // .NET
+
+
+      /// <summary>[AlphaFS] Enumerates the drive names of all logical drives on the Computer.</summary>
+      /// <param name="fromEnvironment">Retrieve logical drives as known by the Environment.</param>
+      /// <param name="isReady">Retrieve only when accessible (IsReady) logical drives.</param>
+      /// <returns>
+      ///   An IEnumerable of type <see cref="Alphaleonis.Win32.Filesystem.DriveInfo"/> that represents
+      ///   the logical drives on the Computer.
+      /// </returns>      
+      [SecurityCritical]
+      public static IEnumerable<DriveInfo> EnumerateDrives(bool fromEnvironment, bool isReady)
+      {
+         return Directory.EnumerateLogicalDrivesCore(fromEnvironment, isReady);
+      }
+
+
+      /// <summary>[AlphaFS] Gets the first available drive letter on the local system.</summary>
+      /// <returns>A drive letter as <see cref="char"/>. When no drive letters are available, an exception is thrown.</returns>
+      /// <remarks>The letters "A" and "B" are reserved for floppy drives and will never be returned by this function.</remarks>
+      public static char GetFreeDriveLetter()
+      {
+         return GetFreeDriveLetter(false);
+      }
+
+
+      /// <summary>Gets an available drive letter on the local system.</summary>
+      /// <param name="getLastAvailable">When <c>true</c> get the last available drive letter. When <c>false</c> gets the first available drive letter.</param>
+      /// <returns>A drive letter as <see cref="char"/>. When no drive letters are available, an exception is thrown.</returns>
+      /// <remarks>The letters "A" and "B" are reserved for floppy drives and will never be returned by this function.</remarks>
+      /// <exception cref="ArgumentOutOfRangeException">No drive letters available.</exception>
+      [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
+      public static char GetFreeDriveLetter(bool getLastAvailable)
+      {
+         var freeDriveLetters = "CDEFGHIJKLMNOPQRSTUVWXYZ".Except(Directory.EnumerateLogicalDrivesCore(false, false).Select(d => d.Name[0]));
+
+         try
+         {
+            return getLastAvailable ? freeDriveLetters.Last() : freeDriveLetters.First();
+         }
+         catch
+         {
+            throw new ArgumentOutOfRangeException(Resources.No_Drive_Letters_Available);
+         }
+      }
+
+      #endregion // Methods
+
+
+      #region Private Methods
+
+      /// <summary>Retrieves information about the file system and volume associated with the specified root file or directorystream.</summary>
+      [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]
+      [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
+      [SecurityCritical]
+      private object GetDeviceInfo(int type, int mode)
+      {
+         try
+         {
+            switch (type)
+            {
+               #region Volume
+
+               // VolumeInfo properties.
+               case 0:
+                  if (Utils.IsNullOrWhiteSpace(_volumeInfo.FullPath))
+                     _volumeInfo.Refresh();
+
+                  switch (mode)
+                  {
+                     case 0:
+                        // IsVolume, VolumeInfo
+                        return _volumeInfo;
+
+                     case 1:
+                        // DriveFormat
+                        return null == _volumeInfo ? DriveType.Unknown.ToString() : _volumeInfo.FileSystemName ?? DriveType.Unknown.ToString();
+
+                     case 2:
+                        // VolumeLabel
+                        return null == _volumeInfo ? string.Empty : _volumeInfo.Name ?? string.Empty;
+                  }
+
+                  break;
+
+
+               // Volume related.
+               case 1:
+                  switch (mode)
+                  {
+                     case 0:
+                        // DosDeviceName
+                        return _dosDeviceName ?? (_dosDeviceName = Volume.GetVolumeDeviceName(Name));
+                  }
+
+                  break;
+
+               #endregion // Volume
+
+
+               #region Drive
+
+               // Drive related.
+               case 2:
+                  switch (mode)
+                  {
+                     case 0:
+                        // DriveType
+                        return _driveType ?? (_driveType = Volume.GetDriveType(Name));
+
+                     case 1:
+                        // RootDirectory
+                        return _rootDirectory ?? (_rootDirectory = new DirectoryInfo(null, Name, PathFormat.RelativePath));
+                  }
+
+                  break;
+
+               // DiskSpaceInfo related.
+               case 3:
+                  switch (mode)
+                  {
+                     case 0:
+                        // AvailableFreeSpace, TotalFreeSpace, TotalSize, DiskSpaceInfo
+                        if (!_initDsie)
+                        {
+                           _dsi.Refresh();
+                           _initDsie = true;
+                        }
+
+                        break;
+                  }
+
+                  break;
+
+               #endregion // Drive
+            }
+         }
+         catch
+         {
+         }
+
+         return type == 0 && mode > 0 ? string.Empty : null;
+      }
+      
+      #endregion // Private
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.DefineDosDevice.cs

@@ -0,0 +1,119 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Defines, redefines, or deletes MS-DOS device names.</summary>
+      /// <param name="deviceName">An MS-DOS device name string specifying the device the function is defining, redefining, or deleting.</param>
+      /// <param name="targetPath">An MS-DOS path that will implement this device.</param>
+      [SecurityCritical]
+      public static void DefineDosDevice(string deviceName, string targetPath)
+      {
+         DefineDosDeviceCore(true, deviceName, targetPath, DosDeviceAttributes.None, false);
+      }
+
+      /// <summary>[AlphaFS] Defines, redefines, or deletes MS-DOS device names.</summary>
+      /// <param name="deviceName">
+      ///   An MS-DOS device name string specifying the device the function is defining, redefining, or deleting.
+      /// </param>
+      /// <param name="targetPath">
+      ///   &gt;An MS-DOS path that will implement this device. If <paramref name="deviceAttributes"/> parameter has the
+      ///   <see cref="DosDeviceAttributes.RawTargetPath"/> flag specified, <paramref name="targetPath"/> is used as-is.
+      /// </param>
+      /// <param name="deviceAttributes">
+      ///   The controllable aspects of the DefineDosDevice function, <see cref="DosDeviceAttributes"/> flags which will be combined with the
+      ///   default.
+      /// </param>      
+      [SecurityCritical]
+      public static void DefineDosDevice(string deviceName, string targetPath, DosDeviceAttributes deviceAttributes)
+      {
+         DefineDosDeviceCore(true, deviceName, targetPath, deviceAttributes, false);
+      }
+
+
+
+
+      /// <summary>Defines, redefines, or deletes MS-DOS device names.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <param name="isDefine">
+      ///   <c>true</c> defines a new MS-DOS device. <c>false</c> deletes a previously defined MS-DOS device.
+      /// </param>
+      /// <param name="deviceName">
+      ///   An MS-DOS device name string specifying the device the function is defining, redefining, or deleting.
+      /// </param>
+      /// <param name="targetPath">
+      ///   A pointer to a path string that will implement this device. The string is an MS-DOS path string unless the
+      ///   <see cref="DosDeviceAttributes.RawTargetPath"/> flag is specified, in which case this string is a path string.
+      /// </param>
+      /// <param name="deviceAttributes">
+      ///   The controllable aspects of the DefineDosDevice function, <see cref="DosDeviceAttributes"/> flags which will be combined with the
+      ///   default.
+      /// </param>
+      /// <param name="exactMatch">
+      ///   Only delete MS-DOS device on an exact name match. If <paramref name="exactMatch"/> is <c>true</c>,
+      ///   <paramref name="targetPath"/> must be the same path used to create the mapping.
+      /// </param>
+      [SecurityCritical]
+      internal static void DefineDosDeviceCore(bool isDefine, string deviceName, string targetPath, DosDeviceAttributes deviceAttributes, bool exactMatch)
+      {
+         if (Utils.IsNullOrWhiteSpace(deviceName))
+            throw new ArgumentNullException("deviceName");
+
+         if (isDefine)
+         {
+            // targetPath is allowed to be null.
+
+            // In no case is a trailing backslash ("\") allowed.
+            deviceName = Path.GetRegularPathCore(deviceName, GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.CheckInvalidPathChars, false);
+
+            using (new NativeMethods.ChangeErrorMode(NativeMethods.ErrorMode.FailCriticalErrors))
+            {
+               var success = NativeMethods.DefineDosDevice(deviceAttributes, deviceName, targetPath);
+
+               var lastError = Marshal.GetLastWin32Error();
+               if (!success)
+                  NativeError.ThrowException(lastError, deviceName, targetPath);
+            }
+         }
+
+         else
+         {
+            // A pointer to a path string that will implement this device.
+            // The string is an MS-DOS path string unless the DDD_RAW_TARGET_PATH flag is specified, in which case this string is a path string.
+
+            if (exactMatch && !Utils.IsNullOrWhiteSpace(targetPath))
+               deviceAttributes = deviceAttributes | DosDeviceAttributes.ExactMatchOnRemove | DosDeviceAttributes.RawTargetPath;
+
+            // Remove the MS-DOS device name. First, get the name of the Windows NT device
+            // from the symbolic link and then delete the symbolic link from the namespace.
+
+            DefineDosDevice(deviceName, targetPath, deviceAttributes);
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.DeleteDosDevice.cs

@@ -0,0 +1,86 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System.Diagnostics.CodeAnalysis;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Deletes an MS-DOS device name.</summary>
+      /// <param name="deviceName">An MS-DOS device name specifying the device to delete.</param>      
+      [SecurityCritical]
+      public static void DeleteDosDevice(string deviceName)
+      {
+         DefineDosDeviceCore(false, deviceName, null, DosDeviceAttributes.RemoveDefinition, false);
+      }
+
+      /// <summary>[AlphaFS] Deletes an MS-DOS device name.</summary>
+      /// <param name="deviceName">An MS-DOS device name string specifying the device to delete.</param>
+      /// <param name="targetPath">
+      ///   A pointer to a path string that will implement this device. The string is an MS-DOS path string unless the
+      ///   <see cref="DosDeviceAttributes.RawTargetPath"/> flag is specified, in which case this string is a path string.
+      /// </param>      
+      [SecurityCritical]
+      public static void DeleteDosDevice(string deviceName, string targetPath)
+      {
+         DefineDosDeviceCore(false, deviceName, targetPath, DosDeviceAttributes.RemoveDefinition, false);
+      }
+
+      /// <summary>[AlphaFS] Deletes an MS-DOS device name.</summary>
+      /// <param name="deviceName">An MS-DOS device name string specifying the device to delete.</param>
+      /// <param name="targetPath">
+      ///   A pointer to a path string that will implement this device. The string is an MS-DOS path string unless the
+      ///   <see cref="DosDeviceAttributes.RawTargetPath"/> flag is specified, in which case this string is a path string.
+      /// </param>
+      /// <param name="exactMatch">
+      ///   Only delete MS-DOS device on an exact name match. If <paramref name="exactMatch"/> is <c>true</c>,
+      ///   <paramref name="targetPath"/> must be the same path used to create the mapping.
+      /// </param>      
+      [SecurityCritical]
+      public static void DeleteDosDevice(string deviceName, string targetPath, bool exactMatch)
+      {
+         DefineDosDeviceCore(false, deviceName, targetPath, DosDeviceAttributes.RemoveDefinition, exactMatch);
+      }
+
+      /// <summary>[AlphaFS] Deletes an MS-DOS device name.</summary>
+      /// <param name="deviceName">An MS-DOS device name string specifying the device to delete.</param>
+      /// <param name="targetPath">
+      ///   A pointer to a path string that will implement this device. The string is an MS-DOS path string unless the
+      ///   <see cref="DosDeviceAttributes.RawTargetPath"/> flag is specified, in which case this string is a path string.
+      /// </param>
+      /// <param name="deviceAttributes">
+      ///   The controllable aspects of the DefineDosDevice function <see cref="DosDeviceAttributes"/> flags which will be combined with the
+      ///   default.
+      /// </param>
+      /// <param name="exactMatch">
+      ///   Only delete MS-DOS device on an exact name match. If <paramref name="exactMatch"/> is <c>true</c>,
+      ///   <paramref name="targetPath"/> must be the same path used to create the mapping.
+      /// </param>      
+      [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
+      [SecurityCritical]
+      public static void DeleteDosDevice(string deviceName, string targetPath, DosDeviceAttributes deviceAttributes, bool exactMatch)
+      {
+         DefineDosDeviceCore(false, deviceName, targetPath, deviceAttributes, exactMatch);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.DeleteVolumeMountPoint.cs

@@ -0,0 +1,95 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Deletes a Drive letter or mounted folder.</summary>
+      /// <remarks>Deleting a mounted folder does not cause the underlying directory to be deleted.</remarks>
+      /// <remarks>
+      ///   If the <paramref name="volumeMountPoint"/> parameter is a directory that is not a mounted folder, the function does nothing. The
+      ///   directory is not deleted.
+      /// </remarks>
+      /// <remarks>
+      ///   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.
+      /// </remarks>
+      /// <param name="volumeMountPoint">The Drive letter or mounted folder to be deleted. For example, X:\ or Y:\MountX\.</param>      
+      [SecurityCritical]
+      public static void DeleteVolumeMountPoint(string volumeMountPoint)
+      {
+         DeleteVolumeMountPointCore(null, volumeMountPoint, false, false, PathFormat.RelativePath);
+      }
+
+
+
+
+      /// <summary>Deletes a Drive letter or mounted folder.
+      /// <remarks>
+      ///   <para>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.</para>
+      ///   <para>Deleting a mounted folder does not cause the underlying directory to be deleted.</para>
+      /// </remarks>
+      /// </summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="volumeMountPoint">The Drive letter or mounted folder to be deleted. For example, X:\ or Y:\MountX\.</param>
+      /// <param name="continueOnException"><c>true</c> suppress any Exception that might be thrown as a result from a failure, such as unavailable resources.</param>
+      /// <param name="continueIfJunction"><c>true</c> suppress an exception due to this mount point being a Junction.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static void DeleteVolumeMountPointCore(KernelTransaction transaction, string volumeMountPoint, bool continueOnException, bool continueIfJunction, PathFormat pathFormat)
+      {
+         if (pathFormat != PathFormat.LongFullPath)
+            Path.CheckSupportedPathFormat(volumeMountPoint, true, true);
+
+         volumeMountPoint = Path.GetExtendedLengthPathCore(transaction, volumeMountPoint, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator);
+
+
+         using (new NativeMethods.ChangeErrorMode(NativeMethods.ErrorMode.FailCriticalErrors))
+         {
+            // DeleteVolumeMountPoint()
+            // 2013-01-13: MSDN does not confirm LongPath usage but a Unicode version of this function exists.
+
+            // A trailing backslash is required.
+            var success = NativeMethods.DeleteVolumeMountPoint(Path.AddTrailingDirectorySeparator(volumeMountPoint, false));
+
+            var lastError = Marshal.GetLastWin32Error();
+            if (!success && !continueOnException)
+            {
+               if (lastError == Win32Errors.ERROR_INVALID_PARAMETER && continueIfJunction)
+                  return;
+
+               if (lastError == Win32Errors.ERROR_FILE_NOT_FOUND)
+                  lastError = (int)Win32Errors.ERROR_PATH_NOT_FOUND;
+
+               NativeError.ThrowException(lastError, volumeMountPoint);
+            }
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.DiskFreeSpace.cs

@@ -0,0 +1,63 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] 
+      ///   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.
+      /// </summary>
+      /// <remarks>The calling application must have FILE_LIST_DIRECTORY access rights for this directory.</remarks>
+      /// <param name="drivePath">
+      ///   A path to a drive. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\".
+      /// </param>
+      /// <returns>A <see ref="Alphaleonis.Win32.Filesystem.DiskSpaceInfo"/> class instance.</returns>
+      [SecurityCritical]
+      public static DiskSpaceInfo GetDiskFreeSpace(string drivePath)
+      {
+         return new DiskSpaceInfo(drivePath, null, true, true);
+      }
+
+
+      /// <summary>[AlphaFS] 
+      ///   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.
+      /// </summary>
+      /// <remarks>The calling application must have FILE_LIST_DIRECTORY access rights for this directory.</remarks>
+      /// <param name="drivePath">
+      ///   A path to a drive. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\".
+      /// </param>
+      /// <param name="spaceInfoType">
+      ///   <c>null</c> gets both size- and disk cluster information. <c>true</c> Get only disk cluster information,
+      ///   <c>false</c> Get only size information.
+      /// </param>
+      /// <returns>A <see ref="Alphaleonis.Win32.Filesystem.DiskSpaceInfo"/> class instance.</returns>
+      [SecurityCritical]
+      public static DiskSpaceInfo GetDiskFreeSpace(string drivePath, bool? spaceInfoType)
+      {
+         return new DiskSpaceInfo(drivePath, spaceInfoType, true, true);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.DriveType.cs

@@ -0,0 +1,58 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Determines the disk <see cref="DriveType"/>, based on the root of the current directory.</summary>
+      /// <returns>A <see cref="DriveType"/> enum value.</returns>
+      [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
+      [SecurityCritical]
+      public static DriveType GetCurrentDriveType()
+      {
+         return GetDriveType(null);
+      }
+
+
+      /// <summary>[AlphaFS] Determines the disk <see cref="DriveType"/>.</summary>
+      /// <param name="drivePath">A path to a drive. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\"</param>
+      /// <returns>A <see cref="DriveType"/> enum value.</returns>
+      [SecurityCritical]
+      public static DriveType GetDriveType(string drivePath)
+      {
+         // drivePath is allowed to be == null.
+
+         drivePath = Path.AddTrailingDirectorySeparator(drivePath, false);
+
+
+         // ChangeErrorMode is for the Win32 SetThreadErrorMode() method, used to suppress possible pop-ups. 
+
+         using (new NativeMethods.ChangeErrorMode(NativeMethods.ErrorMode.FailCriticalErrors))
+
+            return NativeMethods.GetDriveType(drivePath);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.EnumerateVolumeMountPoints.cs

@@ -0,0 +1,91 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+using winPEAS._3rdParty.AlphaFS;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Returns an enumerable collection of <see cref="String"/> of all mounted folders (volume mount points) on the specified volume. </summary>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <param name="volumeGuid">A <see cref="string"/> containing the volume <see cref="Guid"/>.</param>
+      /// <returns>An enumerable collection of <see cref="String"/> of all volume mount points on the specified volume.</returns>
+      [SecurityCritical]
+      public static IEnumerable<string> EnumerateVolumeMountPoints(string volumeGuid)
+      {
+         if (Utils.IsNullOrWhiteSpace(volumeGuid))
+            throw new ArgumentNullException("volumeGuid");
+
+         if (!volumeGuid.StartsWith(Path.VolumePrefix + "{", StringComparison.OrdinalIgnoreCase))
+            throw new ArgumentException(Resources.Not_A_Valid_Guid, "volumeGuid");
+
+
+         // A trailing backslash is required.
+         volumeGuid = Path.AddTrailingDirectorySeparator(volumeGuid, false);
+
+
+         var buffer = new StringBuilder(NativeMethods.MaxPathUnicode);
+
+
+         using (new NativeMethods.ChangeErrorMode(NativeMethods.ErrorMode.FailCriticalErrors))
+         using (var handle = NativeMethods.FindFirstVolumeMountPoint(volumeGuid, buffer, (uint)buffer.Capacity))
+         {
+            var lastError = Marshal.GetLastWin32Error();
+
+            if (!NativeMethods.IsValidHandle(handle, false))
+            {
+               switch ((uint)lastError)
+               {
+                  case Win32Errors.ERROR_NO_MORE_FILES:
+                  case Win32Errors.ERROR_PATH_NOT_FOUND: // Observed with USB stick, FAT32 formatted.
+                     yield break;
+
+                  default:
+                     NativeError.ThrowException(lastError, volumeGuid);
+                     break;
+               }
+            }
+
+            yield return buffer.ToString();
+
+
+            while (NativeMethods.FindNextVolumeMountPoint(handle, buffer, (uint)buffer.Capacity))
+            {
+               lastError = Marshal.GetLastWin32Error();
+
+               var throwException = lastError != Win32Errors.ERROR_NO_MORE_FILES && lastError != Win32Errors.ERROR_PATH_NOT_FOUND && lastError != Win32Errors.ERROR_MORE_DATA;
+
+               if (!NativeMethods.IsValidHandle(handle, lastError, volumeGuid, throwException))
+                  yield break;
+
+               yield return buffer.ToString();
+            }
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.EnumerateVolumePathNames.cs

@@ -0,0 +1,90 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+using winPEAS._3rdParty.AlphaFS;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Returns an enumerable collection of <see cref="string"/> drive letters and mounted folder paths for the specified volume.</summary>
+      /// <returns>An enumerable collection of <see cref="string"/> containing the path names for the specified volume.</returns>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <param name="volumeGuid">A volume <see cref="Guid"/> path: \\?\Volume{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}\.</param>
+      [SecurityCritical]
+      public static IEnumerable<string> EnumerateVolumePathNames(string volumeGuid)
+      {
+         if (Utils.IsNullOrWhiteSpace(volumeGuid))
+            throw new ArgumentNullException("volumeGuid");
+
+         if (!volumeGuid.StartsWith(Path.VolumePrefix + "{", StringComparison.OrdinalIgnoreCase))
+            throw new ArgumentException(Resources.Not_A_Valid_Guid, "volumeGuid");
+
+
+         var volName = Path.AddTrailingDirectorySeparator(volumeGuid, false);
+
+
+         uint requiredLength = 10;
+         var cBuffer = new char[requiredLength];
+
+
+         using (new NativeMethods.ChangeErrorMode(NativeMethods.ErrorMode.FailCriticalErrors))
+            while (!NativeMethods.GetVolumePathNamesForVolumeName(volName, cBuffer, (uint)cBuffer.Length, out requiredLength))
+            {
+               var lastError = Marshal.GetLastWin32Error();
+
+               switch ((uint)lastError)
+               {
+                  case Win32Errors.ERROR_MORE_DATA:
+                  case Win32Errors.ERROR_INSUFFICIENT_BUFFER:
+                     cBuffer = new char[requiredLength];
+                     break;
+
+                  default:
+                     NativeError.ThrowException(lastError, volumeGuid);
+                     break;
+               }
+            }
+
+
+         var buffer = new StringBuilder(cBuffer.Length);
+         foreach (var c in cBuffer)
+         {
+            if (c != Path.StringTerminatorChar)
+               buffer.Append(c);
+            else
+            {
+               if (buffer.Length > 0)
+               {
+                  yield return buffer.ToString();
+                  buffer.Length = 0;
+               }
+            }
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.EnumerateVolumes.cs

@@ -0,0 +1,68 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Returns an enumerable collection of <see cref="String"/> volumes on the computer.</summary>
+      /// <returns>An enumerable collection of <see cref="String"/> volume names on the computer.</returns>
+      [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
+      [SecurityCritical]
+      public static IEnumerable<string> EnumerateVolumes()
+      {
+         var buffer = new StringBuilder(NativeMethods.MaxPathUnicode);
+
+         using (new NativeMethods.ChangeErrorMode(NativeMethods.ErrorMode.FailCriticalErrors))
+         using (var handle = NativeMethods.FindFirstVolume(buffer, (uint)buffer.Capacity))
+         {
+            var lastError = Marshal.GetLastWin32Error();
+
+            var throwException = lastError != Win32Errors.ERROR_NO_MORE_FILES && lastError != Win32Errors.ERROR_PATH_NOT_FOUND;
+
+            if (!NativeMethods.IsValidHandle(handle, lastError, String.Empty, throwException))
+               yield break;
+
+            yield return buffer.ToString();
+
+
+            while (NativeMethods.FindNextVolume(handle, buffer, (uint)buffer.Capacity))
+            {
+               lastError = Marshal.GetLastWin32Error();
+
+               throwException = lastError != Win32Errors.ERROR_NO_MORE_FILES && lastError != Win32Errors.ERROR_PATH_NOT_FOUND && lastError != Win32Errors.ERROR_MORE_DATA;
+
+               if (!NativeMethods.IsValidHandle(handle, lastError, String.Empty, throwException))
+                  yield break;
+
+               yield return buffer.ToString();
+            }
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.GetDriveFormat.cs

@@ -0,0 +1,44 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System.Diagnostics.CodeAnalysis;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Gets the name of the file system, such as NTFS or FAT32.</summary>
+      /// <remarks>Use DriveFormat to determine what formatting a drive uses.</remarks>
+      /// <param name="drivePath">
+      ///   A path to a drive. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\".
+      /// </param>
+      /// <returns>The name of the file system on the specified drive or <c>null</c>  on failure or if not available.</returns>
+      [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
+      [SecurityCritical]
+      public static string GetDriveFormat(string drivePath)
+      {
+         var fsName = new VolumeInfo(drivePath, true, true).FileSystemName;
+
+         return Utils.IsNullOrWhiteSpace(fsName) ? null : fsName;
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.GetDriveNameForNtDeviceName.cs

@@ -0,0 +1,44 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Gets the drive letter from an MS-DOS device name. For example: "\Device\HarddiskVolume2" returns "C:\".</summary>
+      /// <param name="deviceName">An MS-DOS device name.</param>
+      /// <returns>The drive letter from an MS-DOS device name.</returns>
+      [SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Nt")]
+      [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Nt")]
+      public static string GetDriveNameForNtDeviceName(string deviceName)
+      {
+         return (from drive in Directory.EnumerateLogicalDrivesCore(false, false)
+
+            where drive.DosDeviceName.Equals(deviceName, StringComparison.OrdinalIgnoreCase)
+
+            select drive.Name).FirstOrDefault();
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.GetUniqueVolumeNameForPath.cs

@@ -0,0 +1,58 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Get the unique volume name for the given path.</summary>
+      /// <exception cref="ArgumentNullException"/>
+      /// <param name="volumePathName">
+      ///   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.
+      /// </param>
+      /// <returns>
+      ///   <para>Returns the unique volume name in the form: "\\?\Volume{GUID}\",</para>
+      ///   <para>or <c>null</c> on error or if unavailable.</para>
+      /// </returns>
+      [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
+      [SecurityCritical]
+      public static string GetUniqueVolumeNameForPath(string volumePathName)
+      {
+         if (Utils.IsNullOrWhiteSpace(volumePathName))
+            throw new ArgumentNullException("volumePathName");
+
+         try
+         {
+            return GetVolumeGuid(GetVolumePathName(volumePathName));
+         }
+         catch
+         {
+            return null;
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.GetVolumeDeviceName.cs

@@ -0,0 +1,42 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Retrieves the Win32 Device name from the Volume name.</summary>
+      /// <returns>The Win32 Device name from the Volume name, for example: "\Device\HarddiskVolume2",  or <c>null</c> on error or if unavailable.</returns>
+      /// <remarks>This is the same method as <see cref="Volume.QueryDosDevice"/>.</remarks>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="FileNotFoundException"/>
+      /// <param name="volumeName">Name of the Volume.</param>
+      [SecurityCritical]
+      public static string GetVolumeDeviceName(string volumeName)
+      {
+         return QueryDosDevice(volumeName);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.GetVolumeDisplayName.cs

@@ -0,0 +1,56 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Gets the shortest display name for the specified <paramref name="volumeName"/>.</summary>
+      /// <remarks>This method basically returns the shortest string returned by <see cref="EnumerateVolumePathNames"/></remarks>
+      /// <param name="volumeName">A volume <see cref="Guid"/> path: \\?\Volume{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}\.</param>
+      /// <returns>
+      ///   The shortest display name for the specified volume found, or <c>null</c> if no display names were found.
+      /// </returns>
+      [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
+      [SecurityCritical]
+      public static string GetVolumeDisplayName(string volumeName)
+      {
+         string[] smallestMountPoint = { new string(Path.WildcardStarMatchAllChar, NativeMethods.MaxPathUnicode) };
+
+         try
+         {
+            foreach (var m in EnumerateVolumePathNames(volumeName).Where(m => !Utils.IsNullOrWhiteSpace(m) && m.Length < smallestMountPoint[0].Length))
+               smallestMountPoint[0] = m;
+         }
+         catch
+         {
+         }
+
+         var result = smallestMountPoint[0][0] == Path.WildcardStarMatchAllChar ? null : smallestMountPoint[0];
+         return Utils.IsNullOrWhiteSpace(result) ? null : result;
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.GetVolumeGuid.cs

@@ -0,0 +1,91 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] 
+      ///   Retrieves a volume <see cref="Guid"/> path for the volume that is associated with the specified volume mount point (drive letter,
+      ///   volume GUID path, or mounted folder).
+      /// </summary>
+      /// <exception cref="ArgumentNullException"/>
+      /// <param name="volumeMountPoint">
+      ///   The path of a mounted folder (for example, "Y:\MountX\") or a drive letter (for example, "X:\").
+      /// </param>
+      /// <returns>The unique volume name of the form: "\\?\Volume{GUID}\".</returns>
+      [SuppressMessage("Microsoft.Interoperability", "CA1404:CallGetLastErrorImmediatelyAfterPInvoke", Justification = "Marshal.GetLastWin32Error() is manipulated.")]
+      [SecurityCritical]
+      public static string GetVolumeGuid(string volumeMountPoint)
+      {
+         if (Utils.IsNullOrWhiteSpace(volumeMountPoint))
+            throw new ArgumentNullException("volumeMountPoint");
+
+         // The string must end with a trailing backslash ('\').
+         volumeMountPoint = Path.GetFullPathCore(null, false, volumeMountPoint, GetFullPathOptions.AsLongPath | GetFullPathOptions.AddTrailingDirectorySeparator | GetFullPathOptions.FullCheck);
+
+         var volumeGuid = new StringBuilder(100);
+         var uniqueName = new StringBuilder(100);
+
+         try
+         {
+            using (new NativeMethods.ChangeErrorMode(NativeMethods.ErrorMode.FailCriticalErrors))
+            {
+               // GetVolumeNameForVolumeMountPoint()
+               // 2013-07-18: MSDN does not confirm LongPath usage but a Unicode version of this function exists.
+
+               return NativeMethods.GetVolumeNameForVolumeMountPoint(volumeMountPoint, volumeGuid, (uint)volumeGuid.Capacity)
+
+                  // The string must end with a trailing backslash.
+                  ? NativeMethods.GetVolumeNameForVolumeMountPoint(Path.AddTrailingDirectorySeparator(volumeGuid.ToString(), false), uniqueName, (uint)uniqueName.Capacity)
+                     ? uniqueName.ToString()
+                     : null
+
+                  : null;
+            }
+         }
+         finally
+         {
+            var lastError = (uint) Marshal.GetLastWin32Error();
+
+            switch (lastError)
+            {
+               case Win32Errors.ERROR_MORE_DATA:
+                  // (1) When GetVolumeNameForVolumeMountPoint() succeeds, lastError is set to Win32Errors.ERROR_MORE_DATA.
+                  break;
+
+               default:
+                  // (2) When volumeMountPoint is a network drive mapping or UNC path, lastError is set to Win32Errors.ERROR_INVALID_PARAMETER.
+
+                  // Throw IOException.
+                  NativeError.ThrowException(lastError, volumeMountPoint);
+                  break;
+            }
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.GetVolumeGuidForNtDeviceName.cs

@@ -0,0 +1,47 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] 
+      ///   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".
+      /// </summary>
+      /// <param name="dosDevice">A DosDevicePath, for example: \Device\HarddiskVolumeX\path\filename.ext.</param>
+      /// <returns>A translated dos path.</returns>
+      [SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Nt")]
+      [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Nt")]
+      public static string GetVolumeGuidForNtDeviceName(string dosDevice)
+      {
+         return (from drive in Directory.EnumerateLogicalDrivesCore(false, false)
+
+            where drive.DosDeviceName.Equals(dosDevice, StringComparison.OrdinalIgnoreCase)
+
+            select drive.VolumeInfo.Guid).FirstOrDefault();
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.GetVolumeInfo.cs

@@ -0,0 +1,48 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System.Security;
+using Microsoft.Win32.SafeHandles;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Retrieves information about the file system and volume associated with the specified root file or directorystream.</summary>
+      /// <param name="volumePath">A path that contains the root directory.</param>
+      /// <returns>A <see cref="VolumeInfo"/> instance describing the volume associatied with the specified root directory.</returns>
+      [SecurityCritical]
+      public static VolumeInfo GetVolumeInfo(string volumePath)
+      {
+         return new VolumeInfo(volumePath, true, false);
+      }
+
+
+      /// <summary>[AlphaFS] Retrieves information about the file system and volume associated with the specified root file or directorystream.</summary>
+      /// <param name="volumeHandle">An instance to a <see cref="SafeFileHandle"/> handle.</param>
+      /// <returns>A <see cref="VolumeInfo"/> instance describing the volume associatied with the specified root directory.</returns>
+      [SecurityCritical]
+      public static VolumeInfo GetVolumeInfo(SafeFileHandle volumeHandle)
+      {
+         return new VolumeInfo(volumeHandle, true, true);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.GetVolumePathName.cs

@@ -0,0 +1,81 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Retrieves the volume mount point where the specified path is mounted.</summary>
+      /// <exception cref="ArgumentNullException"/>
+      /// <param name="path">The path to the volume, for example: "C:\Windows".</param>
+      /// <returns>
+      ///   <para>Returns the nearest volume root path for a given directory.</para>
+      ///   <para>The volume path name, for example: "C:\Windows" returns: "C:\".</para>
+      /// </returns>
+      [SecurityCritical]
+      public static string GetVolumePathName(string path)
+      {
+         if (Utils.IsNullOrWhiteSpace(path))
+            throw new ArgumentNullException("path");
+
+
+         using (new NativeMethods.ChangeErrorMode(NativeMethods.ErrorMode.FailCriticalErrors))
+         {
+            var volumeRootPath = new StringBuilder(NativeMethods.MaxPathUnicode / 32);
+            var pathLp = Path.GetFullPathCore(null, false, path, GetFullPathOptions.AsLongPath | GetFullPathOptions.FullCheck);
+
+
+            // GetVolumePathName()
+            // 2013-07-18: MSDN does not confirm LongPath usage but a Unicode version of this function exists.
+
+            var success = NativeMethods.GetVolumePathName(pathLp, volumeRootPath, (uint) volumeRootPath.Capacity);
+
+            var lastError = Marshal.GetLastWin32Error();
+
+            if (success)
+               return Path.GetRegularPathCore(volumeRootPath.ToString(), GetFullPathOptions.None, false);
+
+
+            switch ((uint) lastError)
+            {
+               // Don't throw exception on these errors.
+               case Win32Errors.ERROR_NO_MORE_FILES:
+               case Win32Errors.ERROR_INVALID_PARAMETER:
+               case Win32Errors.ERROR_INVALID_NAME:
+                  break;
+
+               default:
+                  NativeError.ThrowException(lastError, path);
+                  break;
+            }
+
+
+            // Return original path.
+            return path;
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.IsReady.cs

@@ -0,0 +1,39 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Gets a value indicating whether a drive is ready.</summary>
+      /// <param name="drivePath">
+      ///   A path to a drive. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\".
+      /// </param>
+      /// <returns><c>true</c> if <paramref name="drivePath"/> is ready; otherwise, <c>false</c>.</returns>
+      [SecurityCritical]
+      public static bool IsReady(string drivePath)
+      {
+         return File.ExistsCore(null, true, drivePath, PathFormat.FullPath);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.IsSameVolume.cs

@@ -0,0 +1,50 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Determines whether the volume of two file system objects is the same, by comparing their serial numbers.</summary>
+      /// <param name="path1">The first filesystem object with full path information.</param>
+      /// <param name="path2">The second file system object with full path information.</param>
+      /// <returns><c>true</c> if both filesytem objects reside on the same volume, <c>false</c> otherwise.</returns>
+      [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
+      [SecurityCritical]
+      public static bool IsSameVolume(string path1, string path2)
+      {
+         try
+         {
+            var volInfo1 = new VolumeInfo(GetVolumePathName(path1), true, true);
+            var volInfo2 = new VolumeInfo(GetVolumePathName(path2), true, true);
+
+            return volInfo1.SerialNumber.Equals(volInfo2.SerialNumber) || volInfo1.Guid.Equals(volInfo2.Guid, StringComparison.OrdinalIgnoreCase);
+         }
+         catch { }
+
+         return false;
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.IsVolume.cs

@@ -0,0 +1,39 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Determines whether the specified volume name is a defined volume on the current computer.</summary>
+      /// <param name="volumeMountPoint">
+      ///   A path to a volume. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\".
+      /// </param>
+      /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
+      [SecurityCritical]
+      public static bool IsVolume(string volumeMountPoint)
+      {
+         return !Utils.IsNullOrWhiteSpace(GetVolumeGuid(volumeMountPoint));
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.QueryDosDevice.cs

@@ -0,0 +1,164 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Retrieves a sorted list of all existing MS-DOS device names.</summary>
+      /// <returns>An <see cref="IEnumerable{String}"/> sorted list of all existing MS-DOS device names.</returns>
+      [SecurityCritical]
+      public static IEnumerable<string> QueryAllDosDevices()
+      {
+         return QueryDosDeviceCore(null, true);
+      }
+
+
+      /// <summary>[AlphaFS] Retrieves the current mapping for a particular MS-DOS device name.</summary>
+      /// <returns>The current mapping for a particular MS-DOS device name.</returns>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="FileNotFoundException"/>
+      /// <param name="deviceName">An MS-DOS device name string specifying the target of the query, such as: "C:", "D:" or "\\?\Volume{GUID}".</param>
+      [SecurityCritical]
+      public static string QueryDosDevice(string deviceName)
+      {
+         if (Utils.IsNullOrWhiteSpace(deviceName))
+            throw new ArgumentNullException("deviceName");
+
+
+         var devName = QueryDosDeviceCore(deviceName, false).ToArray()[0];
+
+         return !Utils.IsNullOrWhiteSpace(devName) ? devName : null;
+      }
+
+
+
+
+      /// <summary>[AlphaFS] Retrieves the current mapping for a particular MS-DOS device name. The function can also obtain a list of all existing MS-DOS device names.</summary>
+      /// <returns>An <see cref="IEnumerable{String}"/> sorted list of all existing MS-DOS device names or the .</returns>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="FileNotFoundException"/>
+      /// <param name="deviceName">An MS-DOS device name string specifying the target of the query, such as: "C:", "D:" or "\\?\Volume{GUID}".</param>
+      /// <param name="sort"><c>true</c> to sort the list with MS-DOS device names.</param>
+      [SecurityCritical]
+      internal static IEnumerable<string> QueryDosDeviceCore(string deviceName, bool sort)
+      {
+         // deviceName is allowed to be null: Retrieve a list of all existing MS-DOS device names.
+         // The deviceName cannot have a trailing backslash.
+
+         if (!Utils.IsNullOrWhiteSpace(deviceName))
+         {
+            if (deviceName.StartsWith(Path.GlobalRootPrefix, StringComparison.OrdinalIgnoreCase))
+            {
+               yield return deviceName.Substring(Path.GlobalRootPrefix.Length);
+
+               yield break;
+            }
+
+            
+            if (deviceName.StartsWith(Path.VolumePrefix, StringComparison.OrdinalIgnoreCase))
+
+               deviceName = deviceName.Substring(Path.LongPathPrefix.Length);
+
+
+            deviceName = Path.RemoveTrailingDirectorySeparator(deviceName);
+         }
+
+
+
+
+         uint returnedBufferSize = 0;
+
+         var bufferSize = (uint) (sort ? NativeMethods.DefaultFileBufferSize : 64);
+
+         var sortedList = new List<string>(sort ? 256 : 0);
+
+
+         using (new NativeMethods.ChangeErrorMode(NativeMethods.ErrorMode.FailCriticalErrors))
+            while (returnedBufferSize == 0)
+            {
+               var cBuffer = new char[bufferSize];
+
+               returnedBufferSize = NativeMethods.QueryDosDevice(deviceName, cBuffer, bufferSize);
+
+               var lastError = Marshal.GetLastWin32Error();
+
+               if (returnedBufferSize == 0)
+                  switch ((uint) lastError)
+                  {
+                     case Win32Errors.ERROR_MORE_DATA:
+                     case Win32Errors.ERROR_INSUFFICIENT_BUFFER:
+                        bufferSize *= 2;
+                        continue;
+
+                     default:
+                        NativeError.ThrowException(lastError, deviceName);
+                        break;
+                  }
+
+
+               var buffer = new StringBuilder((int) returnedBufferSize);
+
+
+               for (var i = 0; i < returnedBufferSize; i++)
+               {
+                  if (cBuffer[i] != Path.StringTerminatorChar)
+
+                     buffer.Append(cBuffer[i]);
+
+
+                  else if (buffer.Length > 0)
+                  {
+                     var assembledPath = buffer.ToString();
+
+                     assembledPath = !Utils.IsNullOrWhiteSpace(assembledPath) ? assembledPath : null;
+
+
+                     if (sort)
+                        sortedList.Add(assembledPath);
+
+                     else
+                        yield return assembledPath;
+
+
+                     buffer.Length = 0;
+                  }
+               }
+            }
+
+
+         if (sort)
+         {
+            foreach (var devName in sortedList.OrderBy(devName => devName))
+
+               yield return devName;
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.SetVolumeMountPoint.cs

@@ -0,0 +1,82 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using System.Security;
+using winPEAS._3rdParty.AlphaFS;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Associates a volume with a Drive letter or a directory on another volume.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <param name="volumeMountPoint">
+      ///   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\").
+      /// </param>
+      /// <param name="volumeGuid">A <see cref="string"/> containing the volume <see cref="Guid"/>.</param>      
+      [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "1", Justification = "Utils.IsNullOrWhiteSpace validates arguments.")]
+      [SecurityCritical]
+      public static void SetVolumeMountPoint(string volumeMountPoint, string volumeGuid)
+      {
+         if (Utils.IsNullOrWhiteSpace(volumeMountPoint))
+            throw new ArgumentNullException("volumeMountPoint");
+
+         if (Utils.IsNullOrWhiteSpace(volumeGuid))
+            throw new ArgumentNullException("volumeGuid");
+
+         if (!volumeGuid.StartsWith(Path.VolumePrefix + "{", StringComparison.OrdinalIgnoreCase))
+            throw new ArgumentException(Resources.Not_A_Valid_Guid, "volumeGuid");
+
+
+         volumeMountPoint = Path.GetFullPathCore(null, false, volumeMountPoint, GetFullPathOptions.AsLongPath | GetFullPathOptions.AddTrailingDirectorySeparator | GetFullPathOptions.FullCheck);
+
+
+         // This string must be of the form "\\?\Volume{GUID}\"
+         volumeGuid = Path.AddTrailingDirectorySeparator(volumeGuid, false);
+
+
+         // ChangeErrorMode is for the Win32 SetThreadErrorMode() method, used to suppress possible pop-ups.
+         using (new NativeMethods.ChangeErrorMode(NativeMethods.ErrorMode.FailCriticalErrors))
+         {
+            // SetVolumeMountPoint()
+            // 2014-01-29: MSDN does not confirm LongPath usage but a Unicode version of this function exists.
+
+            // The string must end with a trailing backslash.
+            var success = NativeMethods.SetVolumeMountPoint(volumeMountPoint, volumeGuid);
+
+            var lastError = Marshal.GetLastWin32Error();
+            if (!success)
+            {
+               // If the lpszVolumeMountPoint parameter contains a path to a mounted folder,
+               // GetLastError returns ERROR_DIR_NOT_EMPTY, even if the directory is empty.
+
+               if (lastError != Win32Errors.ERROR_DIR_NOT_EMPTY)
+                  NativeError.ThrowException(lastError, volumeGuid);
+            }
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.VolumeLabel.cs

@@ -0,0 +1,114 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Volume
+   {
+      /// <summary>[AlphaFS] Deletes the label of the file system volume that is the root of the current directory.</summary>
+      [SecurityCritical]
+      public static void DeleteCurrentVolumeLabel()
+      {
+         SetVolumeLabel(null, null);
+      }
+
+
+      /// <summary>[AlphaFS] Deletes the label of a file system volume.</summary>
+      /// <exception cref="ArgumentNullException"/>
+      /// <param name="rootPathName">The root directory of a file system volume. This is the volume the function will remove the label.</param>
+      [SecurityCritical]
+      public static void DeleteVolumeLabel(string rootPathName)
+      {
+         if (Utils.IsNullOrWhiteSpace(rootPathName))
+            throw new ArgumentNullException("rootPathName");
+
+
+         SetVolumeLabel(rootPathName, null);
+      }
+
+
+      /// <summary>[AlphaFS] Retrieve the label of a file system volume.</summary>
+      /// <param name="volumePath">
+      ///   A path to a volume. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\".
+      /// </param>
+      /// <returns>The the label of the file system volume. This function can return <c>string.Empty</c> since a volume label is generally not mandatory.</returns>
+      [SecurityCritical]
+      public static string GetVolumeLabel(string volumePath)
+      {
+         return new VolumeInfo(volumePath, true, true).Name;
+      }
+
+
+      /// <summary>[AlphaFS] Sets the label of the file system volume that is the root of the current directory.</summary>
+      /// <exception cref="ArgumentNullException"/>
+      /// <param name="volumeName">A name for the volume.</param>
+      [SecurityCritical]
+      public static void SetCurrentVolumeLabel(string volumeName)
+      {
+         if (Utils.IsNullOrWhiteSpace(volumeName))
+            throw new ArgumentNullException("volumeName");
+
+
+         var success = NativeMethods.SetVolumeLabel(null, volumeName);
+
+         var lastError = Marshal.GetLastWin32Error();
+         if (!success)
+            NativeError.ThrowException(lastError, volumeName);
+      }
+
+
+      /// <summary>[AlphaFS] Sets the label of a file system volume.</summary>
+      /// <param name="volumePath">
+      ///   <para>A path to a volume. For example: "C:\", "\\server\share", or "\\?\Volume{c0580d5e-2ad6-11dc-9924-806e6f6e6963}\"</para>
+      ///   <para>If this parameter is <c>null</c>, the function uses the current drive.</para>
+      /// </param>
+      /// <param name="volumeName">
+      ///   <para>A name for the volume.</para>
+      ///   <para>If this parameter is <c>null</c>, the function deletes any existing label</para>
+      ///   <para>from the specified volume and does not assign a new label.</para>
+      /// </param>
+      [SecurityCritical]
+      public static void SetVolumeLabel(string volumePath, string volumeName)
+      {
+         // rootPathName == null is allowed, means current drive.
+
+         // Setting volume label only applies to Logical Drives pointing to local resources.
+         //if (!Path.IsLocalPath(rootPathName))
+         //return false;
+
+         volumePath = Path.AddTrailingDirectorySeparator(volumePath, false);
+
+         // NTFS uses a limit of 32 characters for the volume label as of Windows Server 2003.
+         using (new NativeMethods.ChangeErrorMode(NativeMethods.ErrorMode.FailCriticalErrors))
+         {
+            var success = NativeMethods.SetVolumeLabel(volumePath, volumeName);
+
+            var lastError = Marshal.GetLastWin32Error();
+            if (!success)
+               NativeError.ThrowException(lastError, volumePath, volumeName);
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/Volume.cs

@@ -0,0 +1,28 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   /// <summary>[AlphaFS] Static class providing utility methods for working with Microsoft Windows devices and volumes.</summary>
+   public static partial class Volume
+   {
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Device/Volume/VolumeInfo.cs

@@ -0,0 +1,380 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using Microsoft.Win32.SafeHandles;
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+using winPEAS._3rdParty.AlphaFS;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   /// <summary>Contains information about a filesystem Volume.</summary>
+   [Serializable]
+   [SecurityCritical]
+   public sealed class VolumeInfo
+   {
+      [NonSerialized] private readonly bool _continueOnAccessError;
+      [NonSerialized] private readonly SafeFileHandle _volumeHandle;
+      [NonSerialized] private NativeMethods.VOLUME_INFO_FLAGS _volumeInfoAttributes;
+
+
+      /// <summary>Initializes a VolumeInfo instance.</summary>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <param name="volumeName">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.</param>
+      [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Utils.IsNullOrWhiteSpace validates arguments.")]
+      [SecurityCritical]
+      public VolumeInfo(string volumeName)
+      {
+         if (Utils.IsNullOrWhiteSpace(volumeName))
+            throw new ArgumentNullException("volumeName");
+
+
+         if (!volumeName.StartsWith(Path.LongPathPrefix, StringComparison.Ordinal))
+            volumeName = Path.IsUncPathCore(volumeName, false, false) ? Path.GetLongPathCore(volumeName, GetFullPathOptions.None) : Path.LongPathPrefix + volumeName;
+
+         else
+         {
+            volumeName = volumeName.Length == 1 ? volumeName + Path.VolumeSeparatorChar : Path.GetPathRoot(volumeName, false);
+
+            if (!volumeName.StartsWith(Path.GlobalRootPrefix, StringComparison.OrdinalIgnoreCase))
+               volumeName = Path.GetPathRoot(volumeName, false);
+         }
+
+
+         if (Utils.IsNullOrWhiteSpace(volumeName))
+            throw new ArgumentException(Resources.InvalidDriveLetterArgument, "volumeName");
+
+
+         Name = Path.AddTrailingDirectorySeparator(volumeName, false);
+
+         _volumeHandle = null;
+      }
+
+
+      /// <summary>Initializes a VolumeInfo instance.</summary>
+      /// <param name="driveName">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".</param>
+      /// <param name="refresh">Refreshes the state of the object.</param>
+      /// <param name="continueOnException"><c>true</c> suppress any Exception that might be thrown as a result from a failure, such as unavailable resources.</param>
+      [SecurityCritical]
+      public VolumeInfo(string driveName, bool refresh, bool continueOnException) : this(driveName)
+      {
+         _continueOnAccessError = continueOnException;
+
+         if (refresh)
+            Refresh();
+      }
+
+
+      /// <summary>Initializes a VolumeInfo instance.</summary>
+      /// <param name="volumeHandle">An instance to a <see cref="SafeFileHandle"/> handle.</param>
+      [SecurityCritical]
+      public VolumeInfo(SafeFileHandle volumeHandle)
+      {
+         _volumeHandle = volumeHandle;
+      }
+
+
+      /// <summary>Initializes a VolumeInfo instance.</summary>
+      /// <param name="volumeHandle">An instance to a <see cref="SafeFileHandle"/> handle.</param>
+      /// <param name="refresh">Refreshes the state of the object.</param>
+      /// <param name="continueOnException"><c>true</c> suppress any Exception that might be thrown as a result from a failure, such as unavailable resources.</param>
+      [SecurityCritical]
+      public VolumeInfo(SafeFileHandle volumeHandle, bool refresh, bool continueOnException) : this(volumeHandle)
+      {
+         _continueOnAccessError = continueOnException;
+
+         if (refresh)
+            Refresh();
+      }
+
+
+      
+
+      /// <summary>Refreshes the state of the object.</summary>
+      public void Refresh()
+      {
+         var volumeNameBuffer = new StringBuilder(NativeMethods.MaxPath + 1);
+         var fileSystemNameBuffer = new StringBuilder(NativeMethods.MaxPath + 1);
+         int maximumComponentLength;
+         uint serialNumber;
+
+         using (new NativeMethods.ChangeErrorMode(NativeMethods.ErrorMode.FailCriticalErrors))
+         {
+            // GetVolumeInformationXxx()
+            // 2013-07-18: MSDN does not confirm LongPath usage but a Unicode version of this function exists.
+
+            uint lastError;
+
+            do
+            {
+               var success = null != _volumeHandle && NativeMethods.IsAtLeastWindowsVista
+
+                  // GetVolumeInformationByHandle() / GetVolumeInformation()
+                  // 2013-07-18: MSDN does not confirm LongPath usage but a Unicode version of this function exists.
+
+                  ? NativeMethods.GetVolumeInformationByHandle(_volumeHandle, volumeNameBuffer, (uint) volumeNameBuffer.Capacity, out serialNumber, out maximumComponentLength, out _volumeInfoAttributes, fileSystemNameBuffer, (uint) fileSystemNameBuffer.Capacity)
+
+                  // A trailing backslash is required.
+                  : NativeMethods.GetVolumeInformation(Path.AddTrailingDirectorySeparator(Name, false), volumeNameBuffer, (uint) volumeNameBuffer.Capacity, out serialNumber, out maximumComponentLength, out _volumeInfoAttributes, fileSystemNameBuffer, (uint) fileSystemNameBuffer.Capacity);
+
+
+               lastError = (uint) Marshal.GetLastWin32Error();
+               if (!success)
+               {
+                  switch (lastError)
+                  {
+                     case Win32Errors.ERROR_NOT_READY:
+                        if (!_continueOnAccessError)
+                           throw new DeviceNotReadyException(Name, true);
+                        break;
+
+                     case Win32Errors.ERROR_MORE_DATA:
+                        // With a large enough buffer this code never executes.
+                        volumeNameBuffer.Capacity = volumeNameBuffer.Capacity*2;
+                        fileSystemNameBuffer.Capacity = fileSystemNameBuffer.Capacity*2;
+                        break;
+
+                     default:
+                        if (!_continueOnAccessError)
+                           NativeError.ThrowException(lastError, Name);
+                        break;
+                  }
+               }
+
+               else
+                  break;
+
+            } while (lastError == Win32Errors.ERROR_MORE_DATA);
+         }
+
+         FullPath = Path.GetRegularPathCore(Name, GetFullPathOptions.None, false);
+         Name = volumeNameBuffer.ToString();
+
+         FileSystemName = fileSystemNameBuffer.ToString();
+         FileSystemName = !Utils.IsNullOrWhiteSpace(FileSystemName) ? FileSystemName : null;
+
+         MaximumComponentLength = maximumComponentLength;
+         SerialNumber = serialNumber;
+      }
+
+
+      /// <summary>Returns the full path of the volume.</summary>
+      /// <returns>A string that represents this instance.</returns>
+      public override string ToString()
+      {
+         return Guid;
+      }
+
+
+
+
+      /// <summary>The specified volume supports preserved case of file names when it places a name on disk.</summary>
+      public bool CasePreservedNames
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_CASE_PRESERVED_NAMES) != 0; }
+      }
+
+
+      /// <summary>The specified volume supports case-sensitive file names.</summary>
+      public bool CaseSensitiveSearch
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_CASE_SENSITIVE_SEARCH) != 0; }
+      }
+
+
+      /// <summary>The specified volume supports file-based compression.</summary>
+      public bool Compression
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_FILE_COMPRESSION) != 0; }
+      }
+
+
+      /// <summary>The specified volume is a direct access (DAX) volume.</summary>
+      public bool DirectAccess
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_DAX_VOLUME) != 0; }
+      }
+
+
+      /// <summary>Gets the name of the file system, for example, the FAT file system or the NTFS file system.</summary>
+      /// <value>The name of the file system.</value>
+      public string FileSystemName { get; private set; }
+
+
+      /// <summary>The full path to the volume.</summary>
+      public string FullPath { get; private set; }
+
+
+      private string _guid;
+      /// <summary>The volume GUID.</summary>
+      public string Guid
+      {
+         get
+         {
+            if (Utils.IsNullOrWhiteSpace(_guid))
+               _guid = !Utils.IsNullOrWhiteSpace(FullPath) ? Volume.GetUniqueVolumeNameForPath(FullPath) : null;
+
+            return _guid;
+         }
+      }
+
+
+      /// <summary>Gets the maximum length of a file name component that the file system supports.</summary>
+      /// <value>The maximum length of a file name component that the file system supports.</value>      
+      public int MaximumComponentLength { get; set; }
+
+
+      /// <summary>Gets the label of the volume.</summary>
+      /// <returns>The label of the volume.</returns>
+      /// <remarks>This property is the label assigned to the volume, such "MyDrive"</remarks>
+      public string Name { get; private set; }
+
+
+      /// <summary>The specified volume supports named streams.</summary>
+      public bool NamedStreams
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_NAMED_STREAMS) != 0; }
+      }
+
+
+      /// <summary>The specified volume preserves and enforces access control lists (ACL).</summary>
+      [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Acls")]
+      public bool PersistentAcls
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_PERSISTENT_ACLS) != 0; }
+      }
+
+      
+      /// <summary>The specified volume is read-only.</summary>
+      public bool ReadOnlyVolume
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_READ_ONLY_VOLUME) != 0; }
+      }
+
+      
+      /// <summary>The specified volume supports a single sequential write.</summary>
+      public bool SequentialWriteOnce
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_SEQUENTIAL_WRITE_ONCE) != 0; }
+      }
+
+
+      /// <summary>Gets the volume serial number that the operating system assigns when a hard disk is formatted.</summary>
+      /// <value>The volume serial number that the operating system assigns when a hard disk is formatted.</value>
+      public long SerialNumber { get; private set; }
+
+
+      /// <summary>The specified volume supports the Encrypted File System (EFS).</summary>
+      public bool SupportsEncryption
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_SUPPORTS_ENCRYPTION) != 0; }
+      }
+
+
+      /// <summary>The specified volume supports extended attributes.</summary>
+      public bool SupportsExtendedAttributes
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_SUPPORTS_EXTENDED_ATTRIBUTES) != 0; }
+      }
+
+
+      /// <summary>The specified volume supports hard links.</summary>
+      public bool SupportsHardLinks
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_SUPPORTS_HARD_LINKS) != 0; }
+      }
+
+
+      /// <summary>The specified volume supports object identifiers.</summary>
+      public bool SupportsObjectIds
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_SUPPORTS_OBJECT_IDS) != 0; }
+      }
+
+
+      /// <summary>The file system supports open by FileID.</summary>
+      public bool SupportsOpenByFileId
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_SUPPORTS_OPEN_BY_FILE_ID) != 0; }
+      }
+
+
+      /// <summary>The specified volume supports remote storage. (This property does not appear on MSDN)</summary>
+      public bool SupportsRemoteStorage
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_SUPPORTS_REMOTE_STORAGE) != 0; }
+      }
+
+
+      /// <summary>The specified volume supports re-parse points.</summary>
+      public bool SupportsReparsePoints
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_SUPPORTS_REPARSE_POINTS) != 0; }
+      }
+
+
+      /// <summary>The specified volume supports sparse files.</summary>
+      public bool SupportsSparseFiles
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_SUPPORTS_SPARSE_FILES) != 0; }
+      }
+
+
+      /// <summary>The specified volume supports transactions.</summary>
+      public bool SupportsTransactions
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_SUPPORTS_TRANSACTIONS) != 0; }
+      }
+
+
+      /// <summary>The specified volume supports update sequence number (USN) journals.</summary>
+      [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Usn")]
+      public bool SupportsUsnJournal
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_SUPPORTS_USN_JOURNAL) != 0; }
+      }
+
+
+      /// <summary>The specified volume supports Unicode in file names as they appear on disk.</summary>
+      public bool UnicodeOnDisk
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_UNICODE_ON_DISK) != 0; }
+      }
+
+
+      /// <summary>The specified volume is a compressed volume, for example, a DoubleSpace volume.</summary>
+      public bool VolumeIsCompressed
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_VOLUME_IS_COMPRESSED) != 0; }
+      }
+
+
+      /// <summary>The specified volume supports disk quotas.</summary>
+      public bool VolumeQuotas
+      {
+         get { return (_volumeInfoAttributes & NativeMethods.VOLUME_INFO_FLAGS.FILE_VOLUME_QUOTAS) != 0; }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/ByHandleFileInfo.cs

@@ -0,0 +1,132 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   /// <summary>Contains information that the GetFileInformationByHandle function retrieves.</summary>
+   [Serializable]
+   [SecurityCritical]
+   public sealed class ByHandleFileInfo
+   {
+      internal ByHandleFileInfo(NativeMethods.BY_HANDLE_FILE_INFORMATION fibh)
+      {
+         CreationTimeUtc = DateTime.FromFileTimeUtc(fibh.ftCreationTime);
+         LastAccessTimeUtc = DateTime.FromFileTimeUtc(fibh.ftLastAccessTime);
+         LastWriteTimeUtc = DateTime.FromFileTimeUtc(fibh.ftLastWriteTime);
+
+         Attributes = fibh.dwFileAttributes;
+         FileIndex = NativeMethods.ToLong(fibh.nFileIndexHigh, fibh.nFileIndexLow);
+         FileSize = NativeMethods.ToLong(fibh.nFileSizeHigh, fibh.nFileSizeLow);
+         NumberOfLinks = (int) fibh.nNumberOfLinks;
+         VolumeSerialNumber = fibh.dwVolumeSerialNumber;
+      }
+
+
+      /// <summary>Gets the file attributes.</summary>
+      /// <value>The file attributes.</value>
+      public FileAttributes Attributes { get; private set; }
+
+
+      /// <summary>Gets the time this entry was created.</summary>
+      /// <value>The time this entry was created.</value>
+      public DateTime CreationTime
+      {
+         get { return CreationTimeUtc.ToLocalTime(); }
+      }
+
+
+      /// <summary>Gets the time, in coordinated universal time (UTC), this entry was created.</summary>
+      /// <value>The time, in coordinated universal time (UTC), this entry was created.</value>
+      public DateTime CreationTimeUtc { get; private set; }
+
+
+      /// <summary>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).
+      /// </summary>
+      /// <value>The time this entry was last accessed.</value>
+      public DateTime LastAccessTime
+      {
+         get { return LastAccessTimeUtc.ToLocalTime(); }
+      }
+
+
+      /// <summary>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).
+      /// </summary>
+      /// <value>The time, in coordinated universal time (UTC), this entry was last accessed.</value>
+      public DateTime LastAccessTimeUtc { get; private set; }
+
+
+      /// <summary>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).
+      /// </summary>
+      /// <value>The time this entry was last modified.</value>
+      public DateTime LastWriteTime
+      {
+         get { return LastWriteTimeUtc.ToLocalTime(); }
+      }
+
+
+      /// <summary>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).
+      /// </summary>
+      /// <value>The time, in coordinated universal time (UTC), this entry was last modified.</value>
+      public DateTime LastWriteTimeUtc { get; private set; }
+
+
+      /// <summary>Gets the serial number of the volume that contains a file.</summary>
+      /// <value>The serial number of the volume that contains a file.</value>
+      public long VolumeSerialNumber { get; private set; }
+
+
+      /// <summary>Gets the size of the file.</summary>
+      /// <value>The size of the file.</value>
+      public long FileSize { get; private set; }
+
+
+      /// <summary>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.</summary>
+      /// <value>The number of links to this file. </value>
+      public int NumberOfLinks { get; private set; }
+
+
+      /// <summary>
+      /// 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.
+      /// </summary>
+      /// <value>The unique identifier of the file.</value>
+      public long FileIndex { get; private set; }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/CopyMoveArguments.cs

@@ -0,0 +1,61 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   internal struct CopyMoveArguments
+   {
+      public int Retry;
+      public int RetryTimeout;
+
+      public KernelTransaction Transaction;
+      public string SourcePath;
+      public string DestinationPath;
+
+      public bool CopyTimestamps;
+
+      public CopyOptions? CopyOptions;
+      public MoveOptions? MoveOptions;
+
+      public CopyMoveProgressRoutine ProgressHandler;
+      public object UserProgressData;
+
+      public PathFormat PathFormat;
+
+
+      internal DirectoryEnumerationFilters DirectoryEnumerationFilters;
+      internal string SourcePathLp;
+      internal string DestinationPathLp;
+      internal bool IsCopy;
+      
+      /// <summary>A Move action fallback using Copy + Delete.</summary>
+      internal bool EmulateMove;
+
+      /// <summary>A file/folder will be deleted or renamed on Computer startup.</summary>
+      internal bool DelayUntilReboot;
+
+      internal bool DeleteOnStartup;
+
+      internal NativeMethods.NativeCopyMoveProgressRoutine Routine;
+
+      internal bool PathsChecked;
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/CopyMoveProgressRoutine.cs

@@ -0,0 +1,26 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   /// <summary>Callback used by CopyFileXxx and MoveFileXxx to report progress about the copy/move operation.</summary>
+   public delegate CopyMoveProgressResult CopyMoveProgressRoutine(long totalFileSize, long totalBytesTransferred, long streamSize, long streamBytesTransferred, int streamNumber, CopyMoveProgressCallbackReason callbackReason, object userData);
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/CopyMoveResult.cs

@@ -0,0 +1,171 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   /// <summary>Class for CopyMoveResult that contains the results for the Copy or Move action.</summary>
+   /// <remarks>Normally there is no need to manually instantiate and/or populate this class.</remarks>
+   [Serializable]
+   public sealed class CopyMoveResult
+   {
+      #region Private Fields
+
+      [NonSerialized] internal readonly Stopwatch Stopwatch;
+
+      #endregion // Private Fields
+      
+
+      #region Constructors
+
+      /// <summary>Initializes a CopyMoveResult instance for the Copy or Move action.</summary>
+      /// <param name="source">Indicates the full path to the source file or directory.</param>
+      /// <param name="destination">Indicates the full path to the destination file or directory.</param>
+      private CopyMoveResult(string source, string destination)
+      {
+         Source = source;
+
+         Destination = destination;
+
+         IsCopy = true;
+
+         Retries = 0;
+
+         Stopwatch = new Stopwatch();
+      }
+
+
+      internal CopyMoveResult(CopyMoveArguments cma, bool isFolder) : this(cma.SourcePath, cma.DestinationPath)
+      {
+         IsEmulatedMove = cma.EmulateMove;
+
+         IsCopy = cma.IsCopy;
+
+         IsDirectory = isFolder;
+
+         TimestampsCopied = cma.CopyTimestamps;
+      }
+
+
+      internal CopyMoveResult(CopyMoveArguments cma, bool isFolder, string source, string destination) : this(source, destination)
+      {
+         IsEmulatedMove = cma.EmulateMove;
+
+         IsCopy = cma.IsCopy;
+
+         IsDirectory = isFolder;
+
+         TimestampsCopied = cma.CopyTimestamps;
+      }
+
+      #endregion // Constructors
+
+
+      #region Properties
+
+      /// <summary>Indicates the duration of the Copy or Move action.</summary>
+      public TimeSpan Duration
+      {
+         get { return TimeSpan.FromMilliseconds(Stopwatch.Elapsed.TotalMilliseconds); }
+      }
+      
+
+      /// <summary>Indicates the destination file or directory.</summary>
+      public string Destination { get; private set; }
+      
+
+      /// <summary>The error code encountered during the Copy or Move action.</summary>
+      /// <value>0 (zero) indicates success.</value>
+      public int ErrorCode { get; internal set; }
+
+
+      /// <summary>The error message from the <see cref="ErrorCode"/> that was encountered during the Copy or Move action.</summary>
+      /// <value>A message describing the error.</value>
+      [SuppressMessage("Microsoft.Design", "CA1065:DoNotRaiseExceptionsInUnexpectedLocations")]
+      public string ErrorMessage { get { return new Win32Exception(ErrorCode).Message; } }
+
+
+      /// <summary>When <c>true</c> indicates that the Copy or Move action was canceled.</summary>
+      /// <value><c>true</c> when the Copy/Move action was canceled. Otherwise <c>false</c>.</value>
+      public bool IsCanceled { get; internal set; }
+
+
+      /// <summary>When <c>true</c> the action was a Copy, Move otherwise.</summary>
+      /// <value><c>true</c> when the action was a Copy. Otherwise a Move action was performed.</value>
+      public bool IsCopy { get; private set; }
+
+
+      /// <summary>Gets a value indicating whether this instance represents a directory.</summary>
+      /// <value><c>true</c> if this instance represents a directory; otherwise, <c>false</c>.</value>
+      public bool IsDirectory { get; private set; }
+
+
+      /// <summary>Indicates the Move action used a fallback of Copy + Delete actions.</summary>
+      public bool IsEmulatedMove { get; private set; }
+
+
+      /// <summary>Gets a value indicating whether this instance represents a file.</summary>
+      /// <value><c>true</c> if this instance represents a file; otherwise, <c>false</c>.</value>
+      public bool IsFile { get { return !IsDirectory; } }
+
+
+      /// <summary>When <c>true</c> the action was a Move, Copy otherwise.</summary>
+      /// <value><c>true</c> when the action was a Move. Otherwise a Copy action was performed.</value>
+      public bool IsMove { get { return !IsCopy; } }
+
+
+      /// <summary>The total number of retry attempts.</summary>
+      public long Retries { get; internal set; }
+
+
+      /// <summary>Indicates the source file or directory.</summary>
+      public string Source { get; private set; }
+
+
+      /// <summary>Indicates that the source date and timestamps have been applied to the destination file system objects.</summary>
+      public bool TimestampsCopied { get; private set; }
+
+
+      /// <summary>The total number of bytes copied.</summary>
+      public long TotalBytes { get; internal set; }
+
+
+      /// <summary>The total number of bytes copied, formatted as a unit size.</summary>
+      public string TotalBytesUnitSize
+      {
+         get { return Utils.UnitSizeToText(TotalBytes); }
+      }
+
+
+      /// <summary>The total number of files copied.</summary>
+      public long TotalFiles { get; internal set; }
+
+
+      /// <summary>The total number of folders copied.</summary>
+      public long TotalFolders { get; internal set; }
+
+      #endregion // Properties
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Compression/Directory.Compress.cs

@@ -0,0 +1,167 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <remarks>This will only compress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      [SecurityCritical]
+      public static void Compress(string path)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, null, null, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <remarks>This will only compress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void Compress(string path, PathFormat pathFormat)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, null, null, true, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      [SecurityCritical]
+      public static void Compress(string path, DirectoryEnumerationOptions options)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, options, null, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void Compress(string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, options, null, true, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <remarks>This will only compress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      [SecurityCritical]
+      public static void Compress(string path, DirectoryEnumerationFilters filters)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, null, filters, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <remarks>This will only compress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void Compress(string path, DirectoryEnumerationFilters filters, PathFormat pathFormat)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, null, filters, true, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <remarks>This will only compress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      [SecurityCritical]
+      public static void Compress(string path, DirectoryEnumerationOptions options, DirectoryEnumerationFilters filters)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, options, filters, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <remarks>This will only compress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void Compress(string path, DirectoryEnumerationOptions options, DirectoryEnumerationFilters filters, PathFormat pathFormat)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, options, filters, true, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Compression/Directory.CompressTransacted.cs

@@ -0,0 +1,175 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <remarks>This will only compress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      [SecurityCritical]
+      public static void CompressTransacted(KernelTransaction transaction, string path)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, null, null, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <remarks>This will only compress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CompressTransacted(KernelTransaction transaction, string path, PathFormat pathFormat)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, null, null, true, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      [SecurityCritical]
+      public static void CompressTransacted(KernelTransaction transaction, string path, DirectoryEnumerationOptions options)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, options, null, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CompressTransacted(KernelTransaction transaction, string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, options, null, true, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <remarks>This will only compress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      [SecurityCritical]
+      public static void CompressTransacted(KernelTransaction transaction, string path, DirectoryEnumerationFilters filters)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, null, filters, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <remarks>This will only compress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CompressTransacted(KernelTransaction transaction, string path, DirectoryEnumerationFilters filters, PathFormat pathFormat)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, null, filters, true, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <remarks>This will only compress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      [SecurityCritical]
+      public static void CompressTransacted(KernelTransaction transaction, string path, DirectoryEnumerationOptions options, DirectoryEnumerationFilters filters)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, options, filters, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Compresses a directory using NTFS compression.</summary>
+      /// <remarks>This will only compress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CompressTransacted(KernelTransaction transaction, string path, DirectoryEnumerationOptions options, DirectoryEnumerationFilters filters, PathFormat pathFormat)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, options, filters, true, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Compression/Directory.Decompress.cs

@@ -0,0 +1,165 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <remarks>This will only decompress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      [SecurityCritical]
+      public static void Decompress(string path)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, null, null, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <remarks>This will only decompress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void Decompress(string path, PathFormat pathFormat)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, null, null, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      [SecurityCritical]
+      public static void Decompress(string path, DirectoryEnumerationOptions options)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, options, null, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void Decompress(string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, options, null, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <remarks>This will only decompress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      [SecurityCritical]
+      public static void Decompress(string path, DirectoryEnumerationFilters filters)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, null, filters, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <remarks>This will only decompress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      [SecurityCritical]
+      public static void Decompress(string path, DirectoryEnumerationFilters filters, PathFormat pathFormat)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, null, filters, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      [SecurityCritical]
+      public static void Decompress(string path, DirectoryEnumerationOptions options, DirectoryEnumerationFilters filters)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, options, filters, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void Decompress(string path, DirectoryEnumerationOptions options, DirectoryEnumerationFilters filters, PathFormat pathFormat)
+      {
+         CompressDecompressCore(null, path, Path.WildcardStarMatchAll, options, filters, false, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Compression/Directory.DecompressTransacted.cs

@@ -0,0 +1,173 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <remarks>This will only decompress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      [SecurityCritical]
+      public static void DecompressTransacted(KernelTransaction transaction, string path)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, null, null, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <remarks>This will only decompress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void DecompressTransacted(KernelTransaction transaction, string path, PathFormat pathFormat)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, null, null, false, pathFormat);
+      }
+      
+
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      [SecurityCritical]
+      public static void DecompressTransacted(KernelTransaction transaction, string path, DirectoryEnumerationOptions options)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, options, null, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void DecompressTransacted(KernelTransaction transaction, string path, DirectoryEnumerationOptions options, PathFormat pathFormat)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, options, null, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <remarks>This will only decompress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      [SecurityCritical]
+      public static void DecompressTransacted(KernelTransaction transaction, string path, DirectoryEnumerationFilters filters)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, null, filters, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <remarks>This will only decompress the root items (non recursive).</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      [SecurityCritical]
+      public static void DecompressTransacted(KernelTransaction transaction, string path, DirectoryEnumerationFilters filters, PathFormat pathFormat)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, null, filters, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      [SecurityCritical]
+      public static void DecompressTransacted(KernelTransaction transaction, string path, DirectoryEnumerationOptions options, DirectoryEnumerationFilters filters)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, options, filters, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Decompresses an NTFS compressed directory.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to decompress.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void DecompressTransacted(KernelTransaction transaction, string path, DirectoryEnumerationOptions options, DirectoryEnumerationFilters filters, PathFormat pathFormat)
+      {
+         CompressDecompressCore(transaction, path, Path.WildcardStarMatchAll, options, filters, false, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Compression/Directory.DisableCompression.cs

@@ -0,0 +1,62 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Disables NTFS compression of the specified directory and the files in it.</summary>
+      /// <remarks>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.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path to a directory to decompress.</param>
+      [SecurityCritical]
+      public static void DisableCompression(string path)
+      {
+         Device.ToggleCompressionCore(null, true, path, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Disables NTFS compression of the specified directory and the files in it.</summary>
+      /// <remarks>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.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path to a directory to decompress.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void DisableCompression(string path, PathFormat pathFormat)
+      {
+         Device.ToggleCompressionCore(null, true, path, false, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Compression/Directory.DisableCompressionTransacted.cs

@@ -0,0 +1,64 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Disables NTFS compression of the specified directory and the files in it.</summary>
+      /// <remarks>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.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path to a directory to decompress.</param>
+      [SecurityCritical]
+      public static void DisableCompressionTransacted(KernelTransaction transaction, string path)
+      {
+         Device.ToggleCompressionCore(transaction, true, path, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Disables NTFS compression of the specified directory and the files in it.</summary>
+      /// <remarks>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.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      /// <param name="path">A path to a directory to decompress.</param>
+      [SecurityCritical]
+      public static void DisableCompressionTransacted(KernelTransaction transaction, string path, PathFormat pathFormat)
+      {
+         Device.ToggleCompressionCore(transaction, true, path, false, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Compression/Directory.EnableCompression.cs

@@ -0,0 +1,62 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Enables NTFS compression of the specified directory and the files in it.</summary>
+      /// <remarks>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.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path to a directory to compress.</param>
+      [SecurityCritical]
+      public static void EnableCompression(string path)
+      {
+         Device.ToggleCompressionCore(null, true, path, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Enables NTFS compression of the specified directory and the files in it.</summary>
+      /// <remarks>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.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path to a directory to compress.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void EnableCompression(string path, PathFormat pathFormat)
+      {
+         Device.ToggleCompressionCore(null, true, path, true, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Compression/Directory.EnableCompressionTransacted.cs

@@ -0,0 +1,64 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Enables NTFS compression of the specified directory and the files in it.</summary>
+      /// <remarks>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.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path to a directory to compress.</param>
+      [SecurityCritical]
+      public static void EnableCompressionTransacted(KernelTransaction transaction, string path)
+      {
+         Device.ToggleCompressionCore(transaction, true, path, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Enables NTFS compression of the specified directory and the files in it.</summary>
+      /// <remarks>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.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path to a directory to compress.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void EnableCompressionTransacted(KernelTransaction transaction, string path, PathFormat pathFormat)
+      {
+         Device.ToggleCompressionCore(transaction, true, path, true, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory CopyMove/Directory.CopyFolderTimestamps.cs

@@ -0,0 +1,47 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      private static void CopyFolderTimestamps(CopyMoveArguments cma)
+      {
+         // TODO 2018-01-09: Not 100% yet with local + UNC paths.
+         var dstLp = cma.SourcePathLp.ReplaceIgnoreCase(cma.SourcePathLp, cma.DestinationPathLp);
+
+
+         // Traverse the source folder, processing only folders.
+
+         foreach (var fseiSource in EnumerateFileSystemEntryInfosCore<FileSystemEntryInfo>(true, cma.Transaction, cma.SourcePathLp, Path.WildcardStarMatchAll, null, null, cma.DirectoryEnumerationFilters, PathFormat.LongFullPath))
+
+            File.CopyTimestampsCore(cma.Transaction, true, fseiSource.LongFullPath, Path.CombineCore(false, dstLp, fseiSource.FileName), false, PathFormat.LongFullPath);
+
+         
+         // Process the root directory, the given path.
+
+         File.CopyTimestampsCore(cma.Transaction, true, cma.SourcePathLp, cma.DestinationPathLp, false, PathFormat.LongFullPath);
+
+
+         // TODO: When enabled on Computer, FindFirstFile will change the last accessed time.
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory CopyMove/Directory.Move.cs

@@ -0,0 +1,216 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      #region .NET
+
+      /// <summary>Moves a file or a directory and its contents to a new location.</summary>
+      /// <remarks>
+      ///   <para>This method does not work across disk volumes.</para>
+      ///   <para>Whenever possible, avoid using short file names (such as <c>XXXXXX~1.XXX</c>) with this method.</para>
+      ///   <para>If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior.</para>
+      /// </remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="sourcePath">The source directory path.</param>
+      /// <param name="destinationPath">The destination directory path.</param>
+      [SecurityCritical]
+      public static void Move(string sourcePath, string destinationPath)
+      {
+         CopyMoveCore(new CopyMoveArguments
+         {
+            SourcePath = sourcePath,
+            DestinationPath = destinationPath,
+            MoveOptions = MoveOptions.None
+         });
+      }
+
+      #endregion // .NET
+
+
+      /// <summary>[AlphaFS] Moves a file or a directory and its contents to a new location.</summary>
+      /// <remarks>
+      ///   <para>This method does not work across disk volumes.</para>
+      ///   <para>Whenever possible, avoid using short file names (such as <c>XXXXXX~1.XXX</c>) with this method.</para>
+      ///   <para>If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior.</para>
+      /// </remarks>
+      /// <returns>A <see cref="CopyMoveResult"/> class with details of the Move action.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="sourcePath">The source directory path.</param>
+      /// <param name="destinationPath">The destination directory path.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static CopyMoveResult Move(string sourcePath, string destinationPath, PathFormat pathFormat)
+      {
+         return CopyMoveCore(new CopyMoveArguments
+         {
+            SourcePath = sourcePath,
+            DestinationPath = destinationPath,
+            MoveOptions = MoveOptions.None,
+            PathFormat = pathFormat
+         });
+      }
+
+
+      /// <summary>[AlphaFS] Moves a file or a directory and its contents to a new location, <see cref="MoveOptions"/> can be specified.</summary>
+      /// <remarks>
+      ///   <para>This method does not work across disk volumes unless <paramref name="moveOptions"/> contains <see cref="MoveOptions.CopyAllowed"/>.</para>
+      ///   <para>Whenever possible, avoid using short file names (such as <c>XXXXXX~1.XXX</c>) with this method.</para>
+      ///   <para>If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior.</para>
+      /// </remarks>
+      /// <returns>A <see cref="CopyMoveResult"/> class with details of the Move action.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="sourcePath">The source directory path.</param>
+      /// <param name="destinationPath">The destination directory path.</param>
+      /// <param name="moveOptions"><see cref="MoveOptions"/> that specify how the directory is to be moved. This parameter can be <c>null</c>.</param>
+      [SecurityCritical]
+      public static CopyMoveResult Move(string sourcePath, string destinationPath, MoveOptions moveOptions)
+      {
+         return CopyMoveCore(new CopyMoveArguments
+         {
+            SourcePath = sourcePath,
+            DestinationPath = destinationPath,
+            MoveOptions = moveOptions
+         });
+      }
+
+
+      /// <summary>[AlphaFS] Moves a file or a directory and its contents to a new location, <see cref="MoveOptions"/> can be specified.</summary>
+      /// <remarks>
+      ///   <para>This method does not work across disk volumes unless <paramref name="moveOptions"/> contains <see cref="MoveOptions.CopyAllowed"/>.</para>
+      ///   <para>Whenever possible, avoid using short file names (such as <c>XXXXXX~1.XXX</c>) with this method.</para>
+      ///   <para>If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior.</para>
+      /// </remarks>
+      /// <returns>A <see cref="CopyMoveResult"/> class with details of the Move action.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="sourcePath">The source directory path.</param>
+      /// <param name="destinationPath">The destination directory path.</param>
+      /// <param name="moveOptions"><see cref="MoveOptions"/> that specify how the directory is to be moved. This parameter can be <c>null</c>.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static CopyMoveResult Move(string sourcePath, string destinationPath, MoveOptions moveOptions, PathFormat pathFormat)
+      {
+         return CopyMoveCore(new CopyMoveArguments
+         {
+            SourcePath = sourcePath,
+            DestinationPath = destinationPath,
+            MoveOptions = moveOptions,
+            PathFormat = pathFormat
+         });
+      }
+
+
+      /// <summary>[AlphaFS] Moves a file or a directory and its contents to a new location, <see cref="MoveOptions"/> can be specified,
+      /// and the possibility of notifying the application of its progress through a callback function.
+      /// </summary>
+      /// <remarks>
+      ///   <para>This method does not work across disk volumes unless <paramref name="moveOptions"/> contains <see cref="MoveOptions.CopyAllowed"/>.</para>
+      ///   <para>Whenever possible, avoid using short file names (such as <c>XXXXXX~1.XXX</c>) with this method.</para>
+      ///   <para>If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior.</para>
+      /// </remarks>
+      /// <returns>A <see cref="CopyMoveResult"/> class with details of the Move action.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="sourcePath">The source directory path.</param>
+      /// <param name="destinationPath">The destination directory path.</param>
+      /// <param name="moveOptions"><see cref="MoveOptions"/> that specify how the directory is to be moved. This parameter can be <c>null</c>.</param>
+      /// <param name="progressHandler">A callback function that is called each time another portion of the directory has been moved. This parameter can be <c>null</c>.</param>
+      /// <param name="userProgressData">The argument to be passed to the callback function. This parameter can be <c>null</c>.</param>
+      [SecurityCritical]
+      public static CopyMoveResult Move(string sourcePath, string destinationPath, MoveOptions moveOptions, CopyMoveProgressRoutine progressHandler, object userProgressData)
+      {
+         return CopyMoveCore(new CopyMoveArguments
+         {
+            SourcePath = sourcePath,
+            DestinationPath = destinationPath,
+            MoveOptions = moveOptions,
+            ProgressHandler = progressHandler,
+            UserProgressData = userProgressData
+         });
+      }
+
+
+      /// <summary>[AlphaFS] Moves a file or a directory and its contents to a new location, <see cref="MoveOptions"/> can be specified,
+      ///   and the possibility of notifying the application of its progress through a callback function.
+      /// </summary>
+      /// <remarks>
+      ///   <para>This method does not work across disk volumes unless <paramref name="moveOptions"/> contains <see cref="MoveOptions.CopyAllowed"/>.</para>
+      ///   <para>Whenever possible, avoid using short file names (such as <c>XXXXXX~1.XXX</c>) with this method.</para>
+      ///   <para>If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior.</para>
+      /// </remarks>
+      /// <returns>A <see cref="CopyMoveResult"/> class with details of the Move action.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="sourcePath">The source directory path.</param>
+      /// <param name="destinationPath">The destination directory path.</param>
+      /// <param name="moveOptions"><see cref="MoveOptions"/> that specify how the directory is to be moved. This parameter can be <c>null</c>.</param>
+      /// <param name="progressHandler">A callback function that is called each time another portion of the directory has been moved. This parameter can be <c>null</c>.</param>
+      /// <param name="userProgressData">The argument to be passed to the callback function. This parameter can be <c>null</c>.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static CopyMoveResult Move(string sourcePath, string destinationPath, MoveOptions moveOptions, CopyMoveProgressRoutine progressHandler, object userProgressData, PathFormat pathFormat)
+      {
+         return CopyMoveCore(new CopyMoveArguments
+         {
+            SourcePath = sourcePath,
+            DestinationPath = destinationPath,
+            MoveOptions = moveOptions,
+            ProgressHandler = progressHandler,
+            UserProgressData = userProgressData,
+            PathFormat = pathFormat
+         });
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory CopyMove/Directory.MoveTransacted.cs

@@ -0,0 +1,223 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Moves a file or a directory and its contents to a new location.</summary>
+      /// <remarks>
+      ///   <para>This method does not work across disk volumes.</para>
+      ///   <para>Whenever possible, avoid using short file names (such as <c>XXXXXX~1.XXX</c>) with this method.</para>
+      ///   <para>If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior.</para>
+      /// </remarks>
+      /// <returns>A <see cref="CopyMoveResult"/> class with details of the Move action.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="sourcePath">The source directory path.</param>
+      /// <param name="destinationPath">The destination directory path.</param>
+      [SecurityCritical]
+      public static CopyMoveResult MoveTransacted(KernelTransaction transaction, string sourcePath, string destinationPath)
+      {
+         return CopyMoveCore(new CopyMoveArguments
+         {
+            Transaction = transaction,
+            SourcePath = sourcePath,
+            DestinationPath = destinationPath
+         });
+      }
+
+
+      /// <summary>[AlphaFS] Moves a file or a directory and its contents to a new location.</summary>
+      /// <remarks>
+      ///   <para>This method does not work across disk volumes.</para>
+      ///   <para>Whenever possible, avoid using short file names (such as <c>XXXXXX~1.XXX</c>) with this method.</para>
+      ///   <para>If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior.</para>
+      /// </remarks>
+      /// <returns>A <see cref="CopyMoveResult"/> class with details of the Move action.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="sourcePath">The source directory path.</param>
+      /// <param name="destinationPath">The destination directory path.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static CopyMoveResult MoveTransacted(KernelTransaction transaction, string sourcePath, string destinationPath, PathFormat pathFormat)
+      {
+         return CopyMoveCore(new CopyMoveArguments
+         {
+            Transaction = transaction,
+            SourcePath = sourcePath,
+            DestinationPath = destinationPath,
+            PathFormat = pathFormat
+         });
+      }
+
+
+      /// <summary>[AlphaFS] Moves a file or a directory and its contents to a new location, <see cref="MoveOptions"/> can be specified.</summary>
+      /// <remarks>
+      ///   <para>This method does not work across disk volumes unless <paramref name="moveOptions"/> contains <see cref="MoveOptions.CopyAllowed"/>.</para>
+      ///   <para>Whenever possible, avoid using short file names (such as <c>XXXXXX~1.XXX</c>) with this method.</para>
+      ///   <para>If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior.</para>
+      /// </remarks>
+      /// <returns>A <see cref="CopyMoveResult"/> class with details of the Move action.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="sourcePath">The source directory path.</param>
+      /// <param name="destinationPath">The destination directory path.</param>
+      /// <param name="moveOptions"><see cref="MoveOptions"/> that specify how the directory is to be moved. This parameter can be <c>null</c>.</param>
+      [SecurityCritical]
+      public static CopyMoveResult MoveTransacted(KernelTransaction transaction, string sourcePath, string destinationPath, MoveOptions moveOptions)
+      {
+         return CopyMoveCore(new CopyMoveArguments
+         {
+            Transaction = transaction,
+            SourcePath = sourcePath,
+            DestinationPath = destinationPath,
+            MoveOptions = moveOptions
+         });
+      }
+
+      /// <summary>[AlphaFS] Moves a file or a directory and its contents to a new location, <see cref="MoveOptions"/> can be specified.</summary>
+      /// <remarks>
+      ///   <para>This method does not work across disk volumes unless <paramref name="moveOptions"/> contains <see cref="MoveOptions.CopyAllowed"/>.</para>
+      ///   <para>Whenever possible, avoid using short file names (such as <c>XXXXXX~1.XXX</c>) with this method.</para>
+      ///   <para>If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior.</para>
+      /// </remarks>
+      /// <returns>A <see cref="CopyMoveResult"/> class with details of the Move action.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="sourcePath">The source directory path.</param>
+      /// <param name="destinationPath">The destination directory path.</param>
+      /// <param name="moveOptions"><see cref="MoveOptions"/> that specify how the directory is to be moved. This parameter can be <c>null</c>.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static CopyMoveResult MoveTransacted(KernelTransaction transaction, string sourcePath, string destinationPath, MoveOptions moveOptions, PathFormat pathFormat)
+      {
+         return CopyMoveCore(new CopyMoveArguments
+         {
+            Transaction = transaction,
+            SourcePath = sourcePath,
+            DestinationPath = destinationPath,
+            MoveOptions = moveOptions,
+            PathFormat = pathFormat
+         });
+      }
+
+
+      /// <summary>[AlphaFS] Moves a file or a directory and its contents to a new location, <see cref="MoveOptions"/> can be specified,
+      ///   and the possibility of notifying the application of its progress through a callback function.
+      /// </summary>
+      /// <remarks>
+      ///   <para>This method does not work across disk volumes unless <paramref name="moveOptions"/> contains <see cref="MoveOptions.CopyAllowed"/>.</para>
+      ///   <para>Whenever possible, avoid using short file names (such as <c>XXXXXX~1.XXX</c>) with this method.</para>
+      ///   <para>If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior.</para>
+      /// </remarks>
+      /// <returns>A <see cref="CopyMoveResult"/> class with details of the Move action.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="sourcePath">The source directory path.</param>
+      /// <param name="destinationPath">The destination directory path.</param>
+      /// <param name="moveOptions"><see cref="MoveOptions"/> that specify how the directory is to be moved. This parameter can be <c>null</c>.</param>
+      /// <param name="progressHandler">A callback function that is called each time another portion of the directory has been moved. This parameter can be <c>null</c>.</param>
+      /// <param name="userProgressData">The argument to be passed to the callback function. This parameter can be <c>null</c>.</param>
+      [SecurityCritical]
+      public static CopyMoveResult MoveTransacted(KernelTransaction transaction, string sourcePath, string destinationPath, MoveOptions moveOptions, CopyMoveProgressRoutine progressHandler, object userProgressData)
+      {
+         return CopyMoveCore(new CopyMoveArguments
+         {
+            Transaction = transaction,
+            SourcePath = sourcePath,
+            DestinationPath = destinationPath,
+            MoveOptions = moveOptions,
+            ProgressHandler = progressHandler,
+            UserProgressData = userProgressData
+         });
+      }
+
+
+      /// <summary>[AlphaFS] Moves a file or a directory and its contents to a new location, <see cref="MoveOptions"/> can be specified,
+      ///   and the possibility of notifying the application of its progress through a callback function.
+      /// </summary>
+      /// <returns>A <see cref="CopyMoveResult"/> class with the status of the Move action.</returns>
+      /// <remarks>
+      ///   <para>This method does not work across disk volumes unless <paramref name="moveOptions"/> contains <see cref="MoveOptions.CopyAllowed"/>.</para>
+      ///   <para>Whenever possible, avoid using short file names (such as <c>XXXXXX~1.XXX</c>) with this method.</para>
+      ///   <para>If two directories have equivalent short file names then this method may fail and raise an exception and/or result in undesirable behavior.</para>
+      /// </remarks>
+      /// <returns>A <see cref="CopyMoveResult"/> class with details of the Move action.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="sourcePath">The source directory path.</param>
+      /// <param name="destinationPath">The destination directory path.</param>
+      /// <param name="moveOptions"><see cref="MoveOptions"/> that specify how the directory is to be moved. This parameter can be <c>null</c>.</param>
+      /// <param name="progressHandler">A callback function that is called each time another portion of the directory has been moved. This parameter can be <c>null</c>.</param>
+      /// <param name="userProgressData">The argument to be passed to the callback function. This parameter can be <c>null</c>.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static CopyMoveResult MoveTransacted(KernelTransaction transaction, string sourcePath, string destinationPath, MoveOptions moveOptions, CopyMoveProgressRoutine progressHandler, object userProgressData, PathFormat pathFormat)
+      {
+         return CopyMoveCore(new CopyMoveArguments
+         {
+            Transaction = transaction,
+            SourcePath = sourcePath,
+            DestinationPath = destinationPath,
+            MoveOptions = moveOptions,
+            ProgressHandler = progressHandler,
+            UserProgressData = userProgressData,
+            PathFormat = pathFormat
+         });
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory CopyMove/Directory.ValidateMoveAction.cs

@@ -0,0 +1,95 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      [SecurityCritical]
+      internal static CopyMoveArguments ValidateMoveAction(CopyMoveArguments cma)
+      {
+         // Determine if a Move action or Copy action-fallback is possible.
+
+         cma.IsCopy = false;
+         cma.EmulateMove = false;
+         
+
+         // Compare the root part of both paths.
+
+         var equalRootPaths = Path.GetPathRoot(cma.SourcePathLp, false).Equals(Path.GetPathRoot(cma.DestinationPathLp, false), StringComparison.OrdinalIgnoreCase);
+         
+
+         // Method Volume.IsSameVolume() returns true when both paths refer to the same volume, even if one of the paths is a UNC path.
+         // For example, src = C:\TempSrc and dst = \\localhost\C$\TempDst
+
+         var isSameVolume = equalRootPaths || Volume.IsSameVolume(cma.SourcePathLp, cma.DestinationPathLp);
+         
+         var isMove = isSameVolume && equalRootPaths;
+
+         if (!isMove)
+         {
+            // A Move() can be emulated by using Copy() and Delete(), but only if the MoveOptions.CopyAllowed flag is set.
+
+            isMove = File.HasCopyAllowed(cma.MoveOptions);
+
+
+            // MSDN: .NET3.5+: IOException: An attempt was made to move a directory to a different volume.
+
+            if (!isMove)
+               NativeError.ThrowException(Win32Errors.ERROR_NOT_SAME_DEVICE, cma.SourcePathLp, cma.DestinationPathLp);
+         }
+
+
+         // The MoveFileXxx methods fail when:
+         // - A directory is being moved;
+         // - One of the paths is a UNC path, even though both paths refer to the same volume.
+         //   For example, src = C:\TempSrc and dst = \\localhost\C$\TempDst
+
+         if (isMove)
+         {
+            var srcIsUncPath = Path.IsUncPathCore(cma.SourcePathLp, false, false);
+            var dstIsUncPath = Path.IsUncPathCore(cma.DestinationPathLp, false, false);
+
+            isMove = srcIsUncPath == dstIsUncPath;
+         }
+
+
+         isMove = isMove && isSameVolume && equalRootPaths;
+
+
+         // Emulate Move().
+         if (!isMove)
+         {
+            cma.MoveOptions = null;
+
+            cma.IsCopy = true;
+            cma.EmulateMove = true;
+            cma.CopyOptions = CopyOptions.None;
+         }
+
+
+         return cma;
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.CompressDecompressCore.cs

@@ -0,0 +1,69 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>Compress/decompress Non-/Transacted files/directories.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">A path that describes a directory to compress.</param>
+      /// <param name="searchPattern">
+      ///    The search string to match against the names of directories in <paramref name="path"/>.
+      ///    This parameter can contain a combination of valid literal path and wildcard
+      ///    (<see cref="Path.WildcardStarMatchAll"/> and <see cref="Path.WildcardQuestion"/>) characters, but does not support regular expressions.
+      /// </param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      /// <param name="compress"><c>true</c> compress, when <c>false</c> decompress.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static void CompressDecompressCore(KernelTransaction transaction, string path, string searchPattern, DirectoryEnumerationOptions? options, DirectoryEnumerationFilters filters, bool compress, PathFormat pathFormat)
+      {
+         var pathLp = Path.GetExtendedLengthPathCore(transaction, path, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.FullCheck);
+
+         if (null == options)
+            options = DirectoryEnumerationOptions.None;
+
+
+         // Traverse the source folder, processing files and folders.
+
+         foreach (var fsei in EnumerateFileSystemEntryInfosCore<FileSystemEntryInfo>(null, transaction, pathLp, searchPattern, null, options | DirectoryEnumerationOptions.AsLongPath, filters, PathFormat.LongFullPath))
+
+            Device.ToggleCompressionCore(transaction, fsei.IsDirectory, fsei.FullPath, compress, PathFormat.LongFullPath);
+
+
+         // Process the root directory, the given path.
+
+         Device.ToggleCompressionCore(transaction, true, pathLp, compress, PathFormat.LongFullPath);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.CopyMoveCore.cs

@@ -0,0 +1,145 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>Copy/move a Non-/Transacted file or directory including its children to a new location, <see cref="CopyOptions"/> or <see cref="MoveOptions"/> can be specified,
+      /// and the possibility of notifying the application of its progress through a callback function.
+      /// </summary>
+      /// <returns>A <see cref="CopyMoveResult"/> class with the status of the Copy or Move action.</returns>
+      /// <remarks>
+      ///   <para>Option <see cref="CopyOptions.NoBuffering"/> is recommended for very large file transfers.</para>
+      ///   <para>You cannot use the Move method to overwrite an existing file, unless <paramref name="cma.moveOptions"/> contains <see cref="MoveOptions.ReplaceExisting"/>.</para>
+      ///   <para>Note that if you attempt to replace a file by moving a file of the same name into that directory, you get an IOException.</para>
+      /// </remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <exception cref="PlatformNotSupportedException">The operating system is older than Windows Vista.</exception>
+      [SecurityCritical]
+      internal static CopyMoveResult CopyMoveCore(CopyMoveArguments cma)
+      {
+         #region Setup
+         
+         var fsei = File.GetFileSystemEntryInfoCore(cma.Transaction, false, cma.SourcePath, true, cma.PathFormat);
+
+         var isFolder = null == fsei || fsei.IsDirectory;
+
+         // Directory.Move is applicable to both files and folders.
+
+         cma = File.ValidateFileOrDirectoryMoveArguments(cma, false, isFolder);
+
+
+         var copyMoveResult = new CopyMoveResult(cma, isFolder);
+
+         var errorFilter = null != cma.DirectoryEnumerationFilters && null != cma.DirectoryEnumerationFilters.ErrorFilter ? cma.DirectoryEnumerationFilters.ErrorFilter : null;
+
+         var retry = null != errorFilter && (cma.DirectoryEnumerationFilters.ErrorRetry > 0 || cma.DirectoryEnumerationFilters.ErrorRetryTimeout > 0);
+
+         if (retry)
+         {
+            if (cma.DirectoryEnumerationFilters.ErrorRetry <= 0)
+               cma.DirectoryEnumerationFilters.ErrorRetry = 2;
+
+            if (cma.DirectoryEnumerationFilters.ErrorRetryTimeout <= 0)
+               cma.DirectoryEnumerationFilters.ErrorRetryTimeout = 10;
+         }
+
+
+         // Calling start on a running Stopwatch is a no-op.
+         copyMoveResult.Stopwatch.Start();
+
+         #endregion // Setup
+
+
+         if (cma.IsCopy)
+         {
+            // Copy folder SymbolicLinks.
+            // Cannot be done by CopyFileEx() so emulate this.
+
+            if (File.HasCopySymbolicLink(cma.CopyOptions))
+            {
+               var lvi = File.GetLinkTargetInfoCore(cma.Transaction, cma.SourcePathLp, true, PathFormat.LongFullPath);
+
+               if (null != lvi)
+               {
+                  File.CreateSymbolicLinkCore(cma.Transaction, cma.DestinationPathLp, lvi.SubstituteName, SymbolicLinkTarget.Directory, PathFormat.LongFullPath);
+
+                  copyMoveResult.TotalFolders = 1;
+               }
+            }
+
+            else
+            {
+               if (isFolder)
+                  CopyMoveDirectoryCore(retry, cma, copyMoveResult);
+
+               else
+                  File.CopyMoveCore(retry, cma, true, false, cma.SourcePathLp, cma.DestinationPathLp, copyMoveResult);
+            }
+         }
+
+
+         // Move
+
+         else
+         {
+            // AlphaFS feature to overcome a MoveFileXxx limitation.
+            // MoveOptions.ReplaceExisting: This value cannot be used if lpNewFileName or lpExistingFileName names a directory.
+
+            if (isFolder && !cma.DelayUntilReboot && File.HasReplaceExisting(cma.MoveOptions))
+
+               DeleteDirectoryCore(cma.Transaction, null, cma.DestinationPathLp, true, true, true, PathFormat.LongFullPath);
+
+
+            // 2017-06-07: A large target directory will probably create a progress-less delay in UI.
+            // One way to get around this is to perform the delete in the File.CopyMove method.
+
+
+            // Moves a file or directory, including its children.
+            // Copies an existing directory, including its children to a new directory.
+
+            File.CopyMoveCore(retry, cma, true, isFolder, cma.SourcePathLp, cma.DestinationPathLp, copyMoveResult);
+
+
+            // If the move happened on the same drive, we have no knowledge of the number of files/folders.
+            // However, we do know that the one folder was moved successfully.
+            
+            if (copyMoveResult.ErrorCode == Win32Errors.NO_ERROR && isFolder)
+               copyMoveResult.TotalFolders = 1;
+         }
+
+
+         copyMoveResult.Stopwatch.Stop();
+
+         return copyMoveResult;
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.CopyMoveDirectoryCore.cs

@@ -0,0 +1,102 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System.Collections.Generic;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      [SecurityCritical]
+      internal static void CopyMoveDirectoryCore(bool retry, CopyMoveArguments cma, CopyMoveResult copyMoveResult)
+      {
+         var dirs = new Queue<string>(NativeMethods.DefaultFileBufferSize);
+
+         dirs.Enqueue(cma.SourcePathLp);
+
+
+         while (dirs.Count > 0)
+         {
+            var srcLp = dirs.Dequeue();
+
+            // TODO 2018-01-09: Not 100% yet with local + UNC paths.
+            var dstLp = srcLp.ReplaceIgnoreCase(cma.SourcePathLp, cma.DestinationPathLp);
+            
+
+            // Traverse the source folder, processing files and folders.
+            // No recursion is applied; a Queue is used instead.
+
+            foreach (var fseiSource in EnumerateFileSystemEntryInfosCore<FileSystemEntryInfo>(null, cma.Transaction, srcLp, Path.WildcardStarMatchAll, null, null, cma.DirectoryEnumerationFilters, PathFormat.LongFullPath))
+            {
+               var fseiSourcePath = fseiSource.LongFullPath;
+
+               var fseiDestinationPath = Path.CombineCore(false, dstLp, fseiSource.FileName);
+
+               if (fseiSource.IsDirectory)
+               {
+                  CreateDirectoryCore(true, cma.Transaction, fseiDestinationPath, null, null, false, PathFormat.LongFullPath);
+
+                  copyMoveResult.TotalFolders++;
+
+                  dirs.Enqueue(fseiSourcePath);
+               }
+
+               else
+               {
+                  // File count is done in File.CopyMoveCore method.
+
+                  File.CopyMoveCore(retry, cma, true, false, fseiSourcePath, fseiDestinationPath, copyMoveResult);
+
+                  if (copyMoveResult.IsCanceled)
+                  {
+                     // Break while loop.
+                     dirs.Clear();
+
+                     // Break foreach loop.
+                     break;
+                  }
+                  
+
+                  if (copyMoveResult.ErrorCode == Win32Errors.NO_ERROR)
+                  {
+                     copyMoveResult.TotalBytes += fseiSource.FileSize;
+
+                     if (cma.EmulateMove)
+                        File.DeleteFileCore(cma.Transaction, fseiSourcePath, true, fseiSource.Attributes, PathFormat.LongFullPath);
+                  }
+               }
+            }
+         }
+
+
+         if (!copyMoveResult.IsCanceled && copyMoveResult.ErrorCode == Win32Errors.NO_ERROR)
+         {
+            if (cma.CopyTimestamps)
+               CopyFolderTimestamps(cma);
+
+            if (cma.EmulateMove)
+               DeleteDirectoryCore(cma.Transaction, null, cma.SourcePathLp, true, true, true, PathFormat.LongFullPath);
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.CreateDirectoryCore.cs

@@ -0,0 +1,206 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Security.AccessControl;
+using winPEAS._3rdParty.AlphaFS;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>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.
+      /// </summary>
+      /// <returns>
+      ///   <para>Returns an object that represents the directory at the specified path.</para>
+      ///   <para>This object is returned regardless of whether a directory at the specified path already exists.</para>
+      /// </returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="returnNull">When <c>true</c> returns <c>null</c> instead of a <see cref="DirectoryInfo"/> instance.</param>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory to create.</param>
+      /// <param name="templatePath">The path of the directory to use as a template when creating the new directory. May be <c>null</c> to indicate that no template should be used.</param>
+      /// <param name="directorySecurity">The <see cref="DirectorySecurity"/> access control to apply to the directory, may be null.</param>
+      /// <param name="compress">When <c>true</c> compresses the directory using NTFS compression.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static DirectoryInfo CreateDirectoryCore(bool returnNull, KernelTransaction transaction, string path, string templatePath, ObjectSecurity directorySecurity, bool compress, PathFormat pathFormat)
+      {
+         var longPath = path;
+
+         if (pathFormat != PathFormat.LongFullPath)
+         {
+            if (null == path)
+               throw new ArgumentNullException("path");
+
+
+            Path.CheckSupportedPathFormat(path, true, true);
+            Path.CheckSupportedPathFormat(templatePath, true, true);
+
+            longPath = Path.GetExtendedLengthPathCore(transaction, path, pathFormat, GetFullPathOptions.TrimEnd | GetFullPathOptions.RemoveTrailingDirectorySeparator);
+
+            pathFormat = PathFormat.LongFullPath;
+         }
+
+
+         if (!char.IsWhiteSpace(longPath[longPath.Length - 1]))
+         {
+            // Return DirectoryInfo instance if the directory specified by path already exists.
+
+            if (File.ExistsCore(transaction, true, longPath, PathFormat.LongFullPath))
+
+               // We are not always interested in a new DirectoryInfo instance.
+               return returnNull ? null : new DirectoryInfo(transaction, longPath, PathFormat.LongFullPath);
+         }
+
+
+         // MSDN: .NET 3.5+: IOException: The directory specified by path is a file or the network name was not found.
+         if (File.ExistsCore(transaction, false, longPath, PathFormat.LongFullPath))
+            NativeError.ThrowException(Win32Errors.ERROR_ALREADY_EXISTS, longPath);
+
+
+         var templatePathLp = Utils.IsNullOrWhiteSpace(templatePath)
+            ? null
+            : Path.GetExtendedLengthPathCore(transaction, templatePath, pathFormat, GetFullPathOptions.TrimEnd | GetFullPathOptions.RemoveTrailingDirectorySeparator);
+         
+
+         var list = ConstructFullPath(transaction, longPath);
+         
+         // Directory security.
+         using (var securityAttributes = new Security.NativeMethods.SecurityAttributes(directorySecurity))
+         {
+            // Create the directory paths.
+            while (list.Count > 0)
+            {
+               var folderLp = list.Pop();
+
+               // CreateDirectory() / CreateDirectoryEx()
+               // 2013-01-13: MSDN confirms LongPath usage.
+
+               if (!(transaction == null || !NativeMethods.IsAtLeastWindowsVista
+
+                  ? (templatePathLp == null
+
+                     ? NativeMethods.CreateDirectory(folderLp, securityAttributes)
+
+                     : NativeMethods.CreateDirectoryEx(templatePathLp, folderLp, securityAttributes))
+
+                  : NativeMethods.CreateDirectoryTransacted(templatePathLp, folderLp, securityAttributes, transaction.SafeHandle)))
+               {
+                  var lastError = Marshal.GetLastWin32Error();
+
+                  switch ((uint) lastError)
+                  {
+                     // MSDN: .NET 3.5+: If the directory already exists, this method does nothing.
+                     // MSDN: .NET 3.5+: IOException: The directory specified by path is a file.
+                     case Win32Errors.ERROR_ALREADY_EXISTS:
+                        if (File.ExistsCore(transaction, false, longPath, PathFormat.LongFullPath))
+                           NativeError.ThrowException(lastError, longPath);
+
+                        if (File.ExistsCore(transaction, false, folderLp, PathFormat.LongFullPath))
+                           NativeError.ThrowException(Win32Errors.ERROR_PATH_NOT_FOUND, null, folderLp);
+                        break;
+
+
+                     case Win32Errors.ERROR_BAD_NET_NAME:
+                        NativeError.ThrowException(Win32Errors.ERROR_BAD_NET_NAME, longPath);
+                        break;
+
+
+                     case Win32Errors.ERROR_DIRECTORY:
+                        // MSDN: .NET 3.5+: NotSupportedException: path contains a colon character (:) that is not part of a drive label ("C:\").
+                        throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, Resources.Unsupported_Path_Format, longPath));
+
+
+                     case Win32Errors.ERROR_ACCESS_DENIED:
+                        // Report the parent folder, the inaccessible folder.
+                        var parent = GetParent(folderLp);
+
+                        NativeError.ThrowException(lastError, null != parent ? parent.FullName : folderLp);
+                        break;
+
+
+                     default:
+                        NativeError.ThrowException(lastError, true, folderLp);
+                        break;
+                  }
+               }
+
+               else if (compress)
+                  Device.ToggleCompressionCore(transaction, true, folderLp, true, PathFormat.LongFullPath);
+            }
+
+
+            // We are not always interested in a new DirectoryInfo instance.
+
+            return returnNull ? null : new DirectoryInfo(transaction, longPath, PathFormat.LongFullPath);
+         }
+      }
+
+
+      private static Stack<string> ConstructFullPath(KernelTransaction transaction, string path)
+      {
+         var longPathPrefix = Path.IsUncPathCore(path, false, false) ? Path.LongPathUncPrefix : Path.LongPathPrefix;
+         path = Path.GetRegularPathCore(path, GetFullPathOptions.None, false);
+
+         var length = path.Length;
+         if (length >= 2 && Path.IsDVsc(path[length - 1], false))
+            --length;
+
+         var rootLength = Path.GetRootLength(path, false);
+         if (length == 2 && Path.IsDVsc(path[1], false))
+            throw new ArgumentException(Resources.Cannot_Create_Directory, "path");
+
+
+         // Check if directories are missing.
+         var list = new Stack<string>(100);
+
+         if (length > rootLength)
+         {
+            for (var index = length - 1; index >= rootLength; --index)
+            {
+               var path1 = path.Substring(0, index + 1);
+               var path2 = longPathPrefix + path1.TrimStart('\\');
+
+               if (!File.ExistsCore(transaction, true, path2, PathFormat.LongFullPath))
+                  list.Push(path2);
+
+               while (index > rootLength && !Path.IsDVsc(path[index], false))
+                  --index;
+            }
+         }
+
+         return list;
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.CreateJunctionCore.cs

@@ -0,0 +1,131 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Globalization;
+using System.IO;
+using System.Security;
+using System.Security.AccessControl;
+using Microsoft.Win32.SafeHandles;
+using winPEAS._3rdParty.AlphaFS;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>Creates an NTFS directory junction (similar to CMD command: "MKLINK /J"). Overwriting a junction point of the same name is allowed.</summary>
+      /// <returns>Returns the long path to the directory junction.</returns>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// The directory date and time stamps from <paramref name="directoryPath"/> (the target) are copied to the directory junction.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="overwrite"><c>true</c> to overwrite an existing junction point. The directory is removed and recreated.</param>
+      /// <param name="copyTargetTimestamps"><c>true</c> to copy the target date and time stamps to the directory junction.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static string CreateJunctionCore(KernelTransaction transaction, string junctionPath, string directoryPath, bool overwrite, bool copyTargetTimestamps, PathFormat pathFormat)
+      {
+         if (pathFormat != PathFormat.LongFullPath)
+         {
+            Path.CheckSupportedPathFormat(directoryPath, true, true);
+            Path.CheckSupportedPathFormat(junctionPath, true, true);
+
+            directoryPath = Path.GetExtendedLengthPathCore(transaction, directoryPath, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator);
+            junctionPath = Path.GetExtendedLengthPathCore(transaction, junctionPath, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator);
+
+            pathFormat = PathFormat.LongFullPath;
+         }
+
+
+         // Directory Junction logic.
+
+
+         // Check if drive letter is a mapped network drive.
+         if (new DriveInfo(directoryPath).IsUnc)
+            throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, Resources.Network_Path_Not_Allowed, directoryPath), "directoryPath");
+
+         if (new DriveInfo(junctionPath).IsUnc)
+            throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, Resources.Network_Path_Not_Allowed, junctionPath), "junctionPath");
+
+
+         // Check for existing file.
+         File.ThrowIOExceptionIfFsoExist(transaction, false, directoryPath, pathFormat);
+         File.ThrowIOExceptionIfFsoExist(transaction, false, junctionPath, pathFormat);
+
+
+         // Check for existing directory junction folder.
+         if (File.ExistsCore(transaction, true, junctionPath, pathFormat))
+         {
+            if (overwrite)
+            {
+               DeleteDirectoryCore(transaction, null, junctionPath, true, true, true, pathFormat);
+
+               CreateDirectoryCore(true, transaction, junctionPath, null, null, false, pathFormat);
+            }
+
+            else
+            {
+               // Ensure the folder is empty.
+               if (!IsEmptyCore(transaction, junctionPath, pathFormat))
+                  throw new DirectoryNotEmptyException(junctionPath, true);
+
+               throw new AlreadyExistsException(junctionPath, true);
+            }
+         }
+
+
+         // Create the folder and convert it to a directory junction.
+         CreateDirectoryCore(true, transaction, junctionPath, null, null, false, pathFormat);
+
+         using (var safeHandle = OpenDirectoryJunction(transaction, junctionPath, pathFormat))
+            Device.CreateDirectoryJunction(safeHandle, directoryPath);
+
+
+         // Copy the target date and time stamps to the directory junction.
+         if (copyTargetTimestamps)
+            File.CopyTimestampsCore(transaction, true, directoryPath, junctionPath, true, pathFormat);
+
+
+         return junctionPath;
+      }
+
+
+      private static SafeFileHandle OpenDirectoryJunction(KernelTransaction transaction, string junctionPath, PathFormat pathFormat)
+      {
+         return File.CreateFileCore(transaction, true, junctionPath, ExtendedFileAttributes.BackupSemantics | ExtendedFileAttributes.OpenReparsePoint, null, FileMode.Open, FileSystemRights.WriteData, FileShare.ReadWrite, false, false, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.DeleteDirectoryCore.cs

@@ -0,0 +1,113 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Security;
+using System.Security.AccessControl;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>Deletes the specified directory and, if indicated, any subdirectories in the directory.</summary>
+      /// <remarks>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.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="fsEntryInfo">A FileSystemEntryInfo instance. Use either <paramref name="fsEntryInfo"/> or <paramref name="path"/>, not both.</param>
+      /// <param name="path">The name of the directory to remove. Use either <paramref name="path"/> or <paramref name="fsEntryInfo"/>, not both.</param>
+      /// <param name="recursive"><c>true</c> to remove all files and subdirectories recursively; <c>false</c> otherwise only the top level empty directory.</param>
+      /// <param name="ignoreReadOnly"><c>true</c> overrides read only attribute of files and directories.</param>
+      /// <param name="continueOnNotFound">When <c>true</c> does not throw an <see cref="DirectoryNotFoundException"/> when the directory does not exist.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static void DeleteDirectoryCore(KernelTransaction transaction, FileSystemEntryInfo fsEntryInfo, string path, bool recursive, bool ignoreReadOnly, bool continueOnNotFound, PathFormat pathFormat)
+      {
+         if (null == fsEntryInfo)
+         {
+            if (null == path)
+               throw new ArgumentNullException("path");
+            
+            fsEntryInfo = File.GetFileSystemEntryInfoCore(transaction, true, Path.GetExtendedLengthPathCore(transaction, path, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator), continueOnNotFound, pathFormat);
+
+            if (null == fsEntryInfo)
+               return;
+         }
+
+
+         PrepareDirectoryForDelete(transaction, fsEntryInfo, ignoreReadOnly);
+
+
+         // Do not follow mount points nor symbolic links, but do delete the reparse point itself.
+         // If directory is reparse point, disable recursion.
+
+         if (recursive && !fsEntryInfo.IsReparsePoint)
+         {
+            // The stack will contain the entire folder structure to prevent any open directory handles because of enumeration.
+            // The root folder is at the bottom of the stack.
+
+            var dirs = new Stack<string>(NativeMethods.DefaultFileBufferSize);
+            
+            foreach (var fsei in EnumerateFileSystemEntryInfosCore<FileSystemEntryInfo>(null, transaction, fsEntryInfo.LongFullPath, Path.WildcardStarMatchAll, null, DirectoryEnumerationOptions.Recursive, null, PathFormat.LongFullPath))
+            {
+               PrepareDirectoryForDelete(transaction, fsei, ignoreReadOnly);
+
+               if (fsei.IsDirectory)
+                  dirs.Push(fsei.LongFullPath);
+
+               else
+                  File.DeleteFileCore(transaction, fsei.LongFullPath, ignoreReadOnly, fsei.Attributes, PathFormat.LongFullPath);
+            }
+
+
+            while (dirs.Count > 0)
+               DeleteDirectoryNative(transaction, dirs.Pop(), ignoreReadOnly, continueOnNotFound, 0);
+         }
+         
+
+         DeleteDirectoryNative(transaction, fsEntryInfo.LongFullPath, ignoreReadOnly, continueOnNotFound, fsEntryInfo.Attributes);
+      }
+
+
+      internal static void PrepareDirectoryForDelete(KernelTransaction transaction, FileSystemEntryInfo fsei, bool ignoreReadOnly)
+      {
+         // Check to see if the folder is a mount point and unmount it. Only then is it safe to delete the actual folder.
+
+         if (fsei.IsMountPoint)
+
+            DeleteJunctionCore(transaction, fsei, null, false, PathFormat.LongFullPath);
+
+
+         // Reset attributes to Normal if we already know the facts.
+
+         if (ignoreReadOnly && (fsei.IsReadOnly || fsei.IsHidden))
+
+            File.SetAttributesCore(transaction, fsei.IsDirectory, fsei.LongFullPath, FileAttributes.Normal, PathFormat.LongFullPath);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.DeleteDirectoryNative.cs

@@ -0,0 +1,128 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.IO;
+using System.Runtime.InteropServices;
+using winPEAS._3rdParty.AlphaFS;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
+      private static void DeleteDirectoryNative(KernelTransaction transaction, string pathLp, bool ignoreReadOnly, bool continueOnNotFound, FileAttributes attributes)
+      {
+
+      startRemoveDirectory:
+
+         var success = null == transaction || !NativeMethods.IsAtLeastWindowsVista
+
+            // RemoveDirectory() / RemoveDirectoryTransacted()
+            // 2014-09-09: MSDN confirms LongPath usage.
+
+            // RemoveDirectory on a symbolic link will remove the link itself.
+
+            ? NativeMethods.RemoveDirectory(pathLp)
+
+            : NativeMethods.RemoveDirectoryTransacted(pathLp, transaction.SafeHandle);
+
+
+         var lastError = Marshal.GetLastWin32Error();
+
+         if (!success)
+         {
+            switch ((uint) lastError)
+            {
+               case Win32Errors.ERROR_DIR_NOT_EMPTY:
+                  // MSDN: .NET 3.5+: IOException: The directory specified by path is not an empty directory. 
+                  throw new DirectoryNotEmptyException(pathLp, true);
+
+
+               case Win32Errors.ERROR_DIRECTORY:
+                  // MSDN: .NET 3.5+: DirectoryNotFoundException: Path refers to a file instead of a directory.
+                  if (File.ExistsCore(transaction, false, pathLp, PathFormat.LongFullPath))
+                     throw new DirectoryNotFoundException(string.Format(CultureInfo.InvariantCulture, "({0}) {1}", lastError, string.Format(CultureInfo.InvariantCulture, Resources.Target_Directory_Is_A_File, pathLp)));
+                  break;
+
+
+               case Win32Errors.ERROR_PATH_NOT_FOUND:
+                  if (continueOnNotFound)
+                     return;
+                  break;
+
+
+               case Win32Errors.ERROR_SHARING_VIOLATION:
+                  // MSDN: .NET 3.5+: IOException: The directory is being used by another process or there is an open handle on the directory.
+                  NativeError.ThrowException(lastError, pathLp);
+                  break;
+
+
+               case Win32Errors.ERROR_ACCESS_DENIED:
+
+                  if (attributes == 0)
+                  {
+                     var attrs = new NativeMethods.WIN32_FILE_ATTRIBUTE_DATA();
+
+                     if (File.FillAttributeInfoCore(transaction, pathLp, ref attrs, false, true) == Win32Errors.NO_ERROR)
+
+                        attributes = attrs.dwFileAttributes;
+                  }
+
+
+                  if (File.IsReadOnlyOrHidden(attributes))
+                  {
+                     // MSDN: .NET 3.5+: IOException: The directory specified by path is read-only.
+
+                     if (ignoreReadOnly)
+                     {
+                        // Reset attributes to Normal.
+                        File.SetAttributesCore(transaction, true, pathLp, FileAttributes.Normal, PathFormat.LongFullPath);
+
+                        goto startRemoveDirectory;
+                     }
+
+
+                     // MSDN: .NET 3.5+: IOException: The directory is read-only.
+                     throw new DirectoryReadOnlyException(pathLp);
+                  }
+
+
+                  // MSDN: .NET 3.5+: UnauthorizedAccessException: The caller does not have the required permission.
+                  if (attributes == 0)
+                     NativeError.ThrowException(lastError, File.IsDirectory(attributes), pathLp);
+
+                  break;
+            }
+
+            // MSDN: .NET 3.5+: IOException:
+            // A file with the same name and location specified by path exists.
+            // The directory specified by path is read-only, or recursive is false and path is not an empty directory. 
+            // The directory is the application's current working directory. 
+            // The directory contains a read-only file.
+            // The directory is being used by another process.
+
+            NativeError.ThrowException(lastError, pathLp);
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.DeleteEmptySubdirectoriesCore.cs

@@ -0,0 +1,91 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Security;
+using winPEAS._3rdParty.AlphaFS;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Delete empty subdirectories from the specified directory.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <param name="fsEntryInfo">A FileSystemEntryInfo instance. Use either <paramref name="fsEntryInfo"/> or <paramref name="path"/>, not both.</param>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The name of the directory to remove empty subdirectories from. Use either <paramref name="path"/> or <paramref name="fsEntryInfo"/>, not both.</param>
+      /// <param name="recursive"><c>true</c> deletes empty subdirectories from this directory and its subdirectories.</param>
+      /// <param name="ignoreReadOnly"><c>true</c> overrides read only <see cref="FileAttributes"/> of empty directories.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static void DeleteEmptySubdirectoriesCore(FileSystemEntryInfo fsEntryInfo, KernelTransaction transaction, string path, bool recursive, bool ignoreReadOnly, PathFormat pathFormat)
+      {
+         #region Setup
+
+         if (null == fsEntryInfo)
+         {
+            if (pathFormat == PathFormat.RelativePath)
+               Path.CheckSupportedPathFormat(path, true, true);
+
+            if (!File.ExistsCore(transaction, true, path, pathFormat))
+               NativeError.ThrowException(Win32Errors.ERROR_PATH_NOT_FOUND, path);
+
+            fsEntryInfo = File.GetFileSystemEntryInfoCore(transaction, true, Path.GetExtendedLengthPathCore(transaction, path, pathFormat, GetFullPathOptions.TrimEnd | GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.FullCheck), false, pathFormat);
+
+            if (null == fsEntryInfo)
+               return;
+         }
+
+         #endregion // Setup
+
+
+         // Ensure path is a directory.
+         if (!fsEntryInfo.IsDirectory)
+            throw new IOException(string.Format(CultureInfo.InvariantCulture, Resources.Target_Directory_Is_A_File, fsEntryInfo.LongFullPath));
+
+
+         var dirs = new Stack<string>(1000);
+         dirs.Push(fsEntryInfo.LongFullPath);
+
+         while (dirs.Count > 0)
+         {
+            foreach (var fsei in EnumerateFileSystemEntryInfosCore<FileSystemEntryInfo>(true, transaction, dirs.Pop(), Path.WildcardStarMatchAll, null, DirectoryEnumerationOptions.ContinueOnException, null, PathFormat.LongFullPath))
+            {
+               // Ensure the directory is empty.
+               if (IsEmptyCore(transaction, fsei.LongFullPath, pathFormat))
+                  DeleteDirectoryCore(transaction, fsei, null, false, ignoreReadOnly, true, PathFormat.LongFullPath);
+
+               else if (recursive)
+                  dirs.Push(fsei.LongFullPath);
+            }
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.DeleteJunctionCore.cs

@@ -0,0 +1,86 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Globalization;
+using System.IO;
+using System.Security;
+using winPEAS._3rdParty.AlphaFS;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>Deletes an NTFS directory junction.</summary>
+      /// <remarks>Only the directory junction is removed, not the target.</remarks>
+      /// <returns>A <see cref="DirectoryInfo"/> instance referencing the junction point.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotAReparsePointException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="fsEntryInfo">A FileSystemEntryInfo instance. Use either <paramref name="fsEntryInfo"/> or <paramref name="junctionPath"/>, not both.</param>
+      /// <param name="junctionPath">The path of the junction point to remove.</param>
+      /// <param name="removeDirectory">When <c>true</c>, also removes the directory and all its contents.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static void DeleteJunctionCore(KernelTransaction transaction, FileSystemEntryInfo fsEntryInfo, string junctionPath, bool removeDirectory, PathFormat pathFormat)
+      {
+         if (null == fsEntryInfo)
+         {
+            if (pathFormat != PathFormat.LongFullPath)
+            {
+               Path.CheckSupportedPathFormat(junctionPath, true, true);
+
+               junctionPath = Path.GetExtendedLengthPathCore(transaction, junctionPath, pathFormat, GetFullPathOptions.CheckInvalidPathChars | GetFullPathOptions.RemoveTrailingDirectorySeparator);
+
+               pathFormat = PathFormat.LongFullPath;
+            }
+
+
+            fsEntryInfo = File.GetFileSystemEntryInfoCore(transaction, true, junctionPath, false, pathFormat);
+
+            if (!fsEntryInfo.IsMountPoint)
+               throw new NotAReparsePointException(string.Format(CultureInfo.InvariantCulture, Resources.Directory_Is_Not_A_MountPoint, fsEntryInfo.LongFullPath), (int) Win32Errors.ERROR_NOT_A_REPARSE_POINT);
+         }
+         
+
+         pathFormat = PathFormat.LongFullPath;
+
+
+         // Remove the directory junction.
+
+         using (var safeHandle = OpenDirectoryJunction(transaction, fsEntryInfo.LongFullPath, pathFormat))
+
+            Device.DeleteDirectoryJunction(safeHandle);
+
+
+         // Optionally the folder itself, which should and must be empty.
+
+         if (removeDirectory)
+
+            DeleteDirectoryCore(transaction, fsEntryInfo, null, false, false, true, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.EnableDisableEncryptionCore.cs

@@ -0,0 +1,63 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>Enables/disables encryption of the specified directory and the files in it.
+      ///   <para>This method only creates/modifies the file "Desktop.ini" in the root of <paramref name="path"/> and  enables/disables encryption by writing: "Disable=0" or "Disable=1".</para>
+      ///   <para>This method does not affect encryption of files and subdirectories below the indicated directory.</para>
+      /// </summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <exception cref="FileReadOnlyException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">The name of the directory for which to enable encryption.</param>
+      /// <param name="enable"><c>true</c> enabled encryption, <c>false</c> disables encryption.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static void EnableDisableEncryptionCore(string path, bool enable, PathFormat pathFormat)
+      {
+         if (Utils.IsNullOrWhiteSpace(path))
+            throw new ArgumentNullException("path");
+
+         var pathLp = Path.GetExtendedLengthPathCore(null, path, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.FullCheck);
+
+         // EncryptionDisable()
+         // 2013-01-13: MSDN does not confirm LongPath usage and no Unicode version of this function exists.
+
+         var success = NativeMethods.EncryptionDisable(pathLp, !enable);
+
+         var lastError = Marshal.GetLastWin32Error();
+         if (!success)
+            NativeError.ThrowException(lastError, true, pathLp);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.EncryptDecryptDirectoryCore.cs

@@ -0,0 +1,67 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>Decrypts/encrypts a directory recursively so that only the account used to encrypt the directory can decrypt it.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <exception cref="FileReadOnlyException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to encrypt.</param>
+      /// <param name="encrypt"><c>true</c> encrypt, <c>false</c> decrypt.</param>
+      /// <param name="recursive"><c>true</c> to decrypt the directory recursively. <c>false</c> only decrypt files and directories in the root of <paramref name="path"/>.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static void EncryptDecryptDirectoryCore(string path, bool encrypt, bool recursive, PathFormat pathFormat)
+      {
+         if (pathFormat != PathFormat.LongFullPath)
+         {
+            path = Path.GetExtendedLengthPathCore(null, path, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.FullCheck);
+
+            pathFormat = PathFormat.LongFullPath;
+         }
+
+
+         // Process folders and files when recursive. 
+
+         if (recursive)
+         {
+            foreach (var fsei in EnumerateFileSystemEntryInfosCore<string>(null, null, path, Path.WildcardStarMatchAll, SearchOption.AllDirectories, DirectoryEnumerationOptions.AsLongPath, null, pathFormat))
+
+               File.EncryptDecryptFileCore(true, fsei, encrypt, pathFormat);
+         }
+
+         // Process the root folder, the given path.
+
+         File.EncryptDecryptFileCore(true, path, encrypt, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.EnumerateFileIdBothDirectoryInfoCore.cs

@@ -0,0 +1,141 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using Microsoft.Win32.SafeHandles;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Security.AccessControl;
+using System.Text;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>Returns an enumerable collection of information about files in the directory handle specified.</summary>
+      /// <returns>An IEnumerable of <see cref="FileIdBothDirectoryInfo"/> records for each file system entry in the specified diretory.</returns>    
+      /// <exception cref="PlatformNotSupportedException">The operating system is older than Windows Vista.</exception>
+      /// <remarks>
+      ///   <para>Either use <paramref name="path"/> or <paramref name="safeFileHandle"/>, not both.</para>
+      ///   <para>
+      ///   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.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="PlatformNotSupportedException">The operating system is older than Windows Vista.</exception>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="safeFileHandle">An open handle to the directory from which to retrieve information.</param>
+      /// <param name="path">A path to the directory.</param>
+      /// <param name="shareMode">The <see cref="FileShare"/> mode with which to open a handle to the directory.</param>
+      /// <param name="continueOnException"><c>true</c> suppress any Exception that might be thrown as a result from a failure, such as ACLs protected directories or non-accessible reparse points.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static IEnumerable<FileIdBothDirectoryInfo> EnumerateFileIdBothDirectoryInfoCore(KernelTransaction transaction, SafeFileHandle safeFileHandle, string path, FileShare shareMode, bool continueOnException, PathFormat pathFormat)
+      {
+         if (!NativeMethods.IsAtLeastWindowsVista)
+            throw new PlatformNotSupportedException(new Win32Exception((int) Win32Errors.ERROR_OLD_WIN_VERSION).Message);
+
+
+         var pathLp = path;
+
+         var callerHandle = null != safeFileHandle;
+         if (!callerHandle)
+         {
+            if (Utils.IsNullOrWhiteSpace(path))
+               throw new ArgumentNullException("path");
+
+            pathLp = Path.GetExtendedLengthPathCore(transaction, path, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.FullCheck);
+
+            safeFileHandle = File.CreateFileCore(transaction, true, pathLp, ExtendedFileAttributes.BackupSemantics, null, FileMode.Open, FileSystemRights.ReadData, shareMode, true, false, PathFormat.LongFullPath);
+         }
+
+
+         try
+         {
+            if (!NativeMethods.IsValidHandle(safeFileHandle, Marshal.GetLastWin32Error(), !continueOnException))
+               yield break;
+
+            var fileNameOffset = (int) Marshal.OffsetOf(typeof(NativeMethods.FILE_ID_BOTH_DIR_INFO), "FileName");
+
+            using (var safeBuffer = new SafeGlobalMemoryBufferHandle(NativeMethods.DefaultFileBufferSize))
+            {
+               while (true)
+               {
+                  var success = NativeMethods.GetFileInformationByHandleEx(safeFileHandle, NativeMethods.FILE_INFO_BY_HANDLE_CLASS.FILE_ID_BOTH_DIR_INFO, safeBuffer, (uint) safeBuffer.Capacity);
+
+                  var lastError = Marshal.GetLastWin32Error();
+                  if (!success)
+                  {
+                     switch ((uint) lastError)
+                     {
+                        case Win32Errors.ERROR_SUCCESS:
+                        case Win32Errors.ERROR_NO_MORE_FILES:
+                        case Win32Errors.ERROR_HANDLE_EOF:
+                           yield break;
+
+                        case Win32Errors.ERROR_MORE_DATA:
+                           continue;
+
+                        default:
+                           NativeError.ThrowException(lastError, pathLp);
+
+                           // Keep the compiler happy as we never get here.
+                           yield break;
+                     }
+                  }
+                  
+
+                  var offset = 0;
+                  NativeMethods.FILE_ID_BOTH_DIR_INFO fibdi;
+
+                  do
+                  {
+                     fibdi = safeBuffer.PtrToStructure<NativeMethods.FILE_ID_BOTH_DIR_INFO>(offset);
+
+                     var fileName = safeBuffer.PtrToStringUni(offset + fileNameOffset, (int) (fibdi.FileNameLength / UnicodeEncoding.CharSize));
+
+                     offset += fibdi.NextEntryOffset;
+
+
+                     if (File.IsDirectory(fibdi.FileAttributes) &&
+                         (fileName.Equals(Path.CurrentDirectoryPrefix, StringComparison.Ordinal) ||
+                          fileName.Equals(Path.ParentDirectoryPrefix, StringComparison.Ordinal)))
+                        continue;
+
+
+                     yield return new FileIdBothDirectoryInfo(fibdi, fileName);
+
+                  } while (fibdi.NextEntryOffset != 0);
+               }                           
+            }
+         }
+         finally
+         {
+            // Handle is ours, dispose.
+            if (!callerHandle && null != safeFileHandle && !safeFileHandle.IsClosed)
+               safeFileHandle.Close();
+         }
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.EnumerateFileSystemEntryInfosCore.cs

@@ -0,0 +1,104 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Returns an enumerable collection of file system entries in a specified path using <see cref="DirectoryEnumerationOptions"/> and <see cref="DirectoryEnumerationFilters"/>.</summary>
+      /// <returns>The matching file system entries. The type of the items is determined by the type <typeparamref name="T"/>.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <typeparam name="T">The type to return. This may be one of the following types:
+      ///    <list type="definition">
+      ///    <item>
+      ///       <term><see cref="FileSystemEntryInfo"/></term>
+      ///       <description>This method will return instances of <see cref="FileSystemEntryInfo"/> instances.</description>
+      ///    </item>
+      ///    <item>
+      ///       <term><see cref="FileSystemInfo"/></term>
+      ///       <description>This method will return instances of <see cref="DirectoryInfo"/> and <see cref="FileInfo"/> instances.</description>
+      ///    </item>
+      ///    <item>
+      ///       <term><see cref="string"/></term>
+      ///       <description>This method will return the full path of each item.</description>
+      ///    </item>
+      /// </list>
+      /// </typeparam>
+      /// <param name="onlyFolders"></param>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory to search.</param>
+      /// <param name="searchPattern">
+      ///    The search string to match against the names of directories in <paramref name="path"/>.
+      ///    This parameter can contain a combination of valid literal path and wildcard
+      ///    (<see cref="Path.WildcardStarMatchAll"/> and <see cref="Path.WildcardQuestion"/>) characters, but does not support regular expressions.
+      /// </param>
+      /// <param name="searchOption"></param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      /// <param name="filters">The specification of custom filters to be used in the process.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static IEnumerable<T> EnumerateFileSystemEntryInfosCore<T>(bool? onlyFolders, KernelTransaction transaction, string path, string searchPattern, SearchOption? searchOption, DirectoryEnumerationOptions? options, DirectoryEnumerationFilters filters, PathFormat pathFormat)
+      {
+         if (null == options)
+            options = DirectoryEnumerationOptions.None;
+
+
+         if (searchOption == SearchOption.AllDirectories)
+            options |= DirectoryEnumerationOptions.Recursive;
+
+
+         if (null != onlyFolders)
+         {
+            // Adhere to the method name by validating the DirectoryEnumerationOptions value.
+            // For example, method Directory.EnumerateDirectories() should only return folders
+            // and method Directory.EnumerateFiles() should only return files.
+
+
+            // Folders only.
+            if ((bool) onlyFolders)
+            {
+               options &= ~DirectoryEnumerationOptions.Files;  // Remove enumeration of files.
+               options |= DirectoryEnumerationOptions.Folders; // Add enumeration of folders.
+            }
+
+            // Files only.
+            else
+            {
+               options &= ~DirectoryEnumerationOptions.Folders; // Remove enumeration of folders.
+               options |= DirectoryEnumerationOptions.Files;    // Add enumeration of files.
+            }
+         }
+         
+
+         return new FindFileSystemEntryInfo(transaction, true, path, searchPattern, options, filters, pathFormat, typeof(T)).Enumerate<T>();
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.ExistsJunctionCore.cs

@@ -0,0 +1,72 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>Determines whether the given path refers to an existing directory junction on disk.</summary>
+      /// <returns>
+      ///   <para>Returns <c>true</c> if <paramref name="junctionPath"/> refers to an existing directory junction.</para>
+      ///   <para>Returns <c>false</c> if the directory junction does not exist or an error occurs when trying to determine if the specified file exists.</para>
+      /// </returns>
+      /// <para>&#160;</para>
+      /// <remarks>
+      ///   <para>The Exists method returns <c>false</c> if any error occurs while trying to determine if the specified file exists.</para>
+      ///   <para>This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters,</para>
+      ///   <para>a failing or missing disk, or if the caller does not have permission to read the file.</para>
+      /// </remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="fsEntryInfo">A FileSystemEntryInfo instance. Use either <paramref name="fsEntryInfo"/> or <paramref name="junctionPath"/>, not both.</param>
+      /// <param name="junctionPath">The path to test.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static bool ExistsJunctionCore(KernelTransaction transaction, FileSystemEntryInfo fsEntryInfo, string junctionPath, PathFormat pathFormat)
+      {
+         if (null == fsEntryInfo)
+         {
+            if (pathFormat != PathFormat.LongFullPath)
+            {
+               Path.CheckSupportedPathFormat(junctionPath, true, true);
+
+               junctionPath = Path.GetExtendedLengthPathCore(transaction, junctionPath, pathFormat, GetFullPathOptions.CheckInvalidPathChars | GetFullPathOptions.RemoveTrailingDirectorySeparator);
+
+               pathFormat = PathFormat.LongFullPath;
+            }
+
+
+            fsEntryInfo = File.GetFileSystemEntryInfoCore(transaction, true, junctionPath, true, pathFormat);
+         }
+
+
+         return null != fsEntryInfo && fsEntryInfo.IsMountPoint;
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.GetDirectoryRootCore.cs

@@ -0,0 +1,57 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>Returns the volume information, root information, or both for the specified path.</summary>
+      /// <returns>The volume information, root information, or both for the specified path, or <c>null</c> if <paramref name="path"/> path does not contain root directory information.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The path of a file or directory.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static string GetDirectoryRootCore(KernelTransaction transaction, string path, PathFormat pathFormat)
+      {
+         var pathLp = path;
+
+         if (pathFormat != PathFormat.LongFullPath)
+         {
+            Path.CheckInvalidUncPath(path);
+
+            pathLp = Path.GetExtendedLengthPathCore(transaction, path, pathFormat, GetFullPathOptions.CheckInvalidPathChars);
+
+            pathLp = Path.GetRegularPathCore(pathLp, GetFullPathOptions.None, false);
+         }
+         
+
+         var rootPath = Path.GetPathRoot(pathLp, false);
+
+         return Utils.IsNullOrWhiteSpace(rootPath) ? null : rootPath;
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.GetParentCore.cs

@@ -0,0 +1,45 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>Retrieves the parent directory of the specified path, including both absolute and relative paths.</summary>
+      /// <returns>The parent directory, or <c>null</c> if <paramref name="path"/> is the root directory, including the root of a UNC server or share name.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The path for which to retrieve the parent directory.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static DirectoryInfo GetParentCore(KernelTransaction transaction, string path, PathFormat pathFormat)
+      {
+         var pathLp = pathFormat == PathFormat.LongFullPath ? path : Path.GetExtendedLengthPathCore(transaction, path, pathFormat, GetFullPathOptions.CheckInvalidPathChars);
+
+         pathLp = Path.GetRegularPathCore(pathLp, GetFullPathOptions.None, false);
+
+         var dirName = Path.GetDirectoryName(pathLp, false);
+
+         return !Utils.IsNullOrWhiteSpace(dirName) ? new DirectoryInfo(transaction, dirName, PathFormat.RelativePath) : null;
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.GetPropertiesCore.cs

@@ -0,0 +1,89 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>Gets the properties of the particular directory without following any symbolic links or mount points.
+      ///   <para>Properties include aggregated info from <see cref="FileAttributes"/> of each encountered file system object, plus additional ones: Total, File, Size and Error.</para>
+      ///   <para><b>Total:</b> is the total number of enumerated objects.</para>
+      ///   <para><b>File:</b> is the total number of files. File is considered when object is neither <see cref="FileAttributes.Directory"/> nor <see cref="FileAttributes.ReparsePoint"/>.</para>
+      ///   <para><b>Size:</b> is the total size of enumerated objects.</para>
+      ///   <para><b>Error:</b> is the total number of errors encountered during enumeration.</para>
+      /// </summary>
+      /// <returns>A dictionary mapping the keys mentioned above to their respective aggregated values.</returns>
+      /// <remarks><b>Directory:</b> is an object which has <see cref="FileAttributes.Directory"/> attribute without <see cref="FileAttributes.ReparsePoint"/> one.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The target directory.</param>
+      /// <param name="options"><see cref="DirectoryEnumerationOptions"/> flags that specify how the directory is to be enumerated.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static Dictionary<string, long> GetPropertiesCore(KernelTransaction transaction, string path, DirectoryEnumerationOptions? options, PathFormat pathFormat)
+      {
+         long total = 0;
+         long size = 0;
+
+         const string propFile = "File";
+         const string propTotal = "Total";
+         const string propSize = "Size";
+         
+         var typeOfAttrs = typeof(FileAttributes);
+         var attributes = Enum.GetValues(typeOfAttrs);
+         var props = Enum.GetNames(typeOfAttrs).OrderBy(attrs => attrs).ToDictionary<string, string, long>(name => name, name => 0);
+         var pathLp = Path.GetExtendedLengthPathCore(transaction, path, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.FullCheck);
+
+
+         foreach (var fsei in EnumerateFileSystemEntryInfosCore<FileSystemEntryInfo>(null, transaction, pathLp, Path.WildcardStarMatchAll, null, options,  null, PathFormat.LongFullPath))
+         {
+            total++;
+
+            if (!fsei.IsDirectory)
+               size += fsei.FileSize;
+
+            var fsei1 = fsei;
+
+            foreach (var attributeMarker in attributes.Cast<FileAttributes>().Where(attributeMarker => (fsei1.Attributes & attributeMarker) != 0))
+
+               props[((attributeMarker & FileAttributes.Directory) != 0 ? FileAttributes.Directory : attributeMarker).ToString()]++;
+         }
+
+         // Adjust regular files count.
+         props.Add(propFile, total - props[FileAttributes.Directory.ToString()] - props[FileAttributes.ReparsePoint.ToString()]);
+         props.Add(propTotal, total);
+         props.Add(propSize, size);
+
+         return props;
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.GetSizeCore.cs

@@ -0,0 +1,73 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>Retrieves the size of all alternate data streams of the specified directory and it files.</summary>
+      /// <returns>The size of all alternate data streams of the specified directory and its files.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The path to the directory.</param>
+      /// <param name="sizeOfAllStreams"><c>true</c> to retrieve the size of all alternate data streams, <c>false</c> to get the size of the first stream.</param>
+      /// <param name="recursive"><c>true</c> to include subdirectories.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static long GetSizeCore(KernelTransaction transaction, string path, bool sizeOfAllStreams, bool recursive, PathFormat pathFormat)
+      {
+         var streamSizes = new Collection<long>();
+
+         var pathLp = Path.GetExtendedLengthPathCore(transaction, path, pathFormat, GetFullPathOptions.RemoveTrailingDirectorySeparator | GetFullPathOptions.FullCheck);
+
+
+         var enumOptions = (recursive ? DirectoryEnumerationOptions.Recursive : DirectoryEnumerationOptions.None) | DirectoryEnumerationOptions.SkipReparsePoints;
+
+         if (sizeOfAllStreams)
+         {
+            enumOptions |= DirectoryEnumerationOptions.FilesAndFolders;
+
+            streamSizes.Add(File.FindAllStreamsCore(transaction, pathLp));
+         }
+
+         else
+            enumOptions |= DirectoryEnumerationOptions.Files;
+
+
+         foreach (var fsei in EnumerateFileSystemEntryInfosCore<FileSystemEntryInfo>(null, transaction, pathLp, Path.WildcardStarMatchAll, null, enumOptions, null, PathFormat.LongFullPath))
+         {
+            // Although tempting, AlphaFS does not use the fsei.FileSize property.
+            //
+            // https://blogs.msdn.microsoft.com/oldnewthing/20111226-00/?p=8813/
+            // "The directory-enumeration functions report the last-updated metadata, which may not correspond to the actual metadata if the directory entry is stale. 
+
+
+            streamSizes.Add(sizeOfAllStreams ? File.FindAllStreamsCore(transaction, fsei.LongFullPath) : File.GetSizeCore(null, transaction, fsei.LongFullPath, false, PathFormat.LongFullPath));
+         }
+
+
+         return streamSizes.Sum();
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Core Methods/Directory.IsEmptyCore.cs

@@ -0,0 +1,43 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System.Linq;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Determines whether the given directory is empty; i.e. it contains no files and no subdirectories.</summary>
+      /// <returns>
+      ///   <para>Returns <c>true</c> when the directory contains no file system objects.</para>
+      ///   <para>Returns <c>false</c> when directory contains at least one file system object.</para>
+      /// </returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="directoryPath">The path to the directory.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      internal static bool IsEmptyCore(KernelTransaction transaction, string directoryPath, PathFormat pathFormat)
+      {
+         return !EnumerateFileSystemEntryInfosCore<string>(null, transaction, directoryPath, Path.WildcardStarMatchAll, null, null, null, pathFormat).Any();
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Encryption/Directory.Decrypt.cs

@@ -0,0 +1,97 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <exception cref="FileReadOnlyException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to decrypt.</param>
+      [SecurityCritical]
+      public static void Decrypt(string path)
+      {
+         EncryptDecryptDirectoryCore(path, false, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <exception cref="FileReadOnlyException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to decrypt.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void Decrypt(string path, PathFormat pathFormat)
+      {
+         EncryptDecryptDirectoryCore(path, false, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <exception cref="FileReadOnlyException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to decrypt.</param>
+      /// <param name="recursive"><c>true</c> to decrypt the directory recursively. <c>false</c> only decrypt the directory.</param>
+      [SecurityCritical]
+      public static void Decrypt(string path, bool recursive)
+      {
+         EncryptDecryptDirectoryCore(path, false, recursive, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Decrypts a directory that was encrypted by the current account using the Encrypt method.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <exception cref="FileReadOnlyException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to decrypt.</param>
+      /// <param name="recursive"><c>true</c> to decrypt the directory recursively. <c>false</c> only decrypt the directory.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void Decrypt(string path, bool recursive, PathFormat pathFormat)
+      {
+         EncryptDecryptDirectoryCore(path, false, recursive, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Encryption/Directory.DisableEncryption.cs

@@ -0,0 +1,68 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Disables encryption of the specified directory and the files in it.
+      ///   <para>This method only creates/modifies the file "Desktop.ini" in the root of <paramref name="path"/> and disables encryption by writing: "Disable=1"</para>
+      ///   <para>This method does not affect encryption of files and subdirectories below the indicated directory.</para>
+      /// </summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <exception cref="FileReadOnlyException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">The name of the directory for which to disable encryption.</param>
+      [SecurityCritical]
+      public static void DisableEncryption(string path)
+      {
+         EnableDisableEncryptionCore(path, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Disables encryption of the specified directory and the files in it.
+      ///   <para>This method only creates/modifies the file "Desktop.ini" in the root of <paramref name="path"/> and disables encryption by writing: "Disable=1"</para>
+      ///   <para>This method does not affect encryption of files and subdirectories below the indicated directory.</para>
+      /// </summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <exception cref="FileReadOnlyException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">The name of the directory for which to disable encryption.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void DisableEncryption(string path, PathFormat pathFormat)
+      {
+         EnableDisableEncryptionCore(path, false, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Encryption/Directory.EnableEncryption.cs

@@ -0,0 +1,68 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Enables encryption of the specified directory and the files in it.
+      ///   <para>This method only creates/modifies the file "Desktop.ini" in the root of <paramref name="path"/> and enables encryption by writing: "Disable=0"</para>
+      ///   <para>This method does not affect encryption of files and subdirectories below the indicated directory.</para>
+      /// </summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <exception cref="FileReadOnlyException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">The name of the directory for which to enable encryption.</param>
+      [SecurityCritical]
+      public static void EnableEncryption(string path)
+      {
+         EnableDisableEncryptionCore(path, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Enables encryption of the specified directory and the files in it.
+      ///   <para>This method only creates/modifies the file "Desktop.ini" in the root of <paramref name="path"/> and enables encryption by writing: "Disable=0"</para>
+      ///   <para>This method does not affect encryption of files and subdirectories below the indicated directory.</para>
+      /// </summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <exception cref="FileReadOnlyException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">The name of the directory for which to enable encryption.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void EnableEncryption(string path, PathFormat pathFormat)
+      {
+         EnableDisableEncryptionCore(path, true, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Encryption/Directory.Encrypt.cs

@@ -0,0 +1,97 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Encrypts a directory so that only the account used to encrypt the directory can decrypt it.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <exception cref="FileReadOnlyException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to encrypt.</param>
+      [SecurityCritical]
+      public static void Encrypt(string path)
+      {
+         EncryptDecryptDirectoryCore(path, true, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Encrypts a directory so that only the account used to encrypt the directory can decrypt it.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <exception cref="FileReadOnlyException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to encrypt.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void Encrypt(string path, PathFormat pathFormat)
+      {
+         EncryptDecryptDirectoryCore(path, true, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Encrypts a directory so that only the account used to encrypt the directory can decrypt it.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <exception cref="FileReadOnlyException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to encrypt.</param>
+      /// <param name="recursive"><c>true</c> to encrypt the directory recursively. <c>false</c> only encrypt the directory.</param>
+      [SecurityCritical]
+      public static void Encrypt(string path, bool recursive)
+      {
+         EncryptDecryptDirectoryCore(path, true, recursive, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Encrypts a directory so that only the account used to encrypt the directory can decrypt it.</summary>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryReadOnlyException"/>
+      /// <exception cref="FileReadOnlyException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="path">A path that describes a directory to encrypt.</param>
+      /// <param name="recursive"><c>true</c> to encrypt the directory recursively. <c>false</c> only encrypt the directory.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void Encrypt(string path, bool recursive, PathFormat pathFormat)
+      {
+         EncryptDecryptDirectoryCore(path, true, recursive, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Encryption/Directory.ExportEncryptedDirectoryRaw.cs

@@ -0,0 +1,70 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System.IO;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[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.
+      /// </summary>
+      /// <remarks>
+      ///   <para>The directory being backed up is not decrypted; it is backed up in its encrypted state.</para>
+      ///   <para>If the caller does not have access to the key for the file, the caller needs <see cref="Security.Privilege.Backup"/> to export encrypted files. See <see cref="Security.PrivilegeEnabler"/>.</para>
+      ///   <para>To backup an encrypted directory call one of the <see cref="O:Alphaleonis.Win32.Filesystem.Directory.ExportEncryptedDirectoryRaw"/> overloads and specify the directory to backup along with the destination stream of the backup data.</para>
+      ///   <para>This function is intended for the backup of only encrypted directories; see <see cref="BackupFileStream"/> for backup of unencrypted directories.</para>
+      ///   <para>Note that this method does not back up the files inside the directory, only the directory entry itself.</para>
+      /// </remarks>
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.File.ExportEncryptedFileRaw"/>      
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.File.ImportEncryptedFileRaw"/>
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.Directory.ImportEncryptedDirectoryRaw"/>
+      /// <param name="fileName">The name of the file to be backed up.</param>
+      /// <param name="outputStream">The destination stream to which the backup data will be written.</param>
+      public static void ExportEncryptedDirectoryRaw(string fileName, Stream outputStream)
+      {
+         File.ImportExportEncryptedFileDirectoryRawCore(true, false, outputStream, fileName, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[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.
+      /// </summary>
+      /// <remarks>
+      ///   <para>The directory being backed up is not decrypted; it is backed up in its encrypted state.</para>
+      ///   <para>If the caller does not have access to the key for the file, the caller needs <see cref="Security.Privilege.Backup"/> to export encrypted files. See <see cref="Security.PrivilegeEnabler"/>.</para>
+      ///   <para>To backup an encrypted directory call one of the <see cref="O:Alphaleonis.Win32.Filesystem.Directory.ExportEncryptedDirectoryRaw"/> overloads and specify the directory to backup along with the destination stream of the backup data.</para>
+      ///   <para>This function is intended for the backup of only encrypted directories; see <see cref="BackupFileStream"/> for backup of unencrypted directories.</para>
+      ///   <para>Note that this method does not back up the files inside the directory, only the directory entry itself.</para>
+      /// </remarks>
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.File.ExportEncryptedFileRaw"/>      
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.File.ImportEncryptedFileRaw"/>
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.Directory.ImportEncryptedDirectoryRaw"/>
+      /// <param name="fileName">The name of the file to be backed up.</param>
+      /// <param name="outputStream">The destination stream to which the backup data will be written.</param>
+      /// <param name="pathFormat">The path format of the <paramref name="fileName"/> parameter.</param>
+      public static void ExportEncryptedDirectoryRaw(string fileName, Stream outputStream, PathFormat pathFormat)
+      {
+         File.ImportExportEncryptedFileDirectoryRawCore(true, false, outputStream, fileName, false, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Encryption/Directory.ImportEncryptedDirectoryRaw.cs

@@ -0,0 +1,107 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System.IO;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[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.
+      /// </summary>
+      /// <remarks>
+      ///   <para>If the caller does not have access to the key for the directory, the caller needs <see cref="Security.Privilege.Backup"/> to restore encrypted directories. See <see cref="Security.PrivilegeEnabler"/>.</para>
+      ///   <para>To restore an encrypted directory call one of the <see cref="O:Alphaleonis.Win32.Filesystem.Directory.ImportEncryptedDirectoryRaw"/> overloads and specify the file to restore along with the destination stream of the restored data.</para>
+      ///   <para>This function is intended for the restoration of only encrypted directories; see <see cref="BackupFileStream"/> for backup of unencrypted files.</para>
+      /// </remarks>
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.File.ExportEncryptedFileRaw"/>      
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.File.ImportEncryptedFileRaw"/>
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.Directory.ExportEncryptedDirectoryRaw"/>
+      /// <param name="inputStream">The stream to read previously backed up data from.</param>
+      /// <param name="destinationPath">The path of the destination directory to restore to.</param>
+      public static void ImportEncryptedDirectoryRaw(Stream inputStream, string destinationPath)
+      {
+         File.ImportExportEncryptedFileDirectoryRawCore(false, true, inputStream, destinationPath, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[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.
+      /// </summary>
+      /// <remarks>
+      ///   <para>If the caller does not have access to the key for the directory, the caller needs <see cref="Security.Privilege.Backup"/> to restore encrypted directories. See <see cref="Security.PrivilegeEnabler"/>.</para>
+      ///   <para>To restore an encrypted directory call one of the <see cref="O:Alphaleonis.Win32.Filesystem.Directory.ImportEncryptedDirectoryRaw"/> overloads and specify the file to restore along with the destination stream of the restored data.</para>
+      ///   <para>This function is intended for the restoration of only encrypted directories; see <see cref="BackupFileStream"/> for backup of unencrypted files.</para>
+      /// </remarks>
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.File.ExportEncryptedFileRaw"/>
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.File.ImportEncryptedFileRaw"/>
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.Directory.ExportEncryptedDirectoryRaw"/>
+      /// <param name="inputStream">The stream to read previously backed up data from.</param>
+      /// <param name="destinationPath">The path of the destination directory to restore to.</param>
+      /// <param name="pathFormat">The path format of the <paramref name="destinationPath"/> parameter.</param>
+      public static void ImportEncryptedDirectoryRaw(Stream inputStream, string destinationPath, PathFormat pathFormat)
+      {
+         File.ImportExportEncryptedFileDirectoryRawCore(false, true, inputStream, destinationPath, false, pathFormat);
+      }
+
+
+      /// <summary>[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.
+      /// </summary>
+      /// <remarks>
+      ///   <para>If the caller does not have access to the key for the directory, the caller needs <see cref="Security.Privilege.Backup"/> to restore encrypted directories. See <see cref="Security.PrivilegeEnabler"/>.</para>
+      ///   <para>To restore an encrypted directory call one of the <see cref="O:Alphaleonis.Win32.Filesystem.Directory.ImportEncryptedDirectoryRaw"/> overloads and specify the file to restore along with the destination stream of the restored data.</para>
+      ///   <para>This function is intended for the restoration of only encrypted directories; see <see cref="BackupFileStream"/> for backup of unencrypted files.</para>
+      /// </remarks>
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.File.ExportEncryptedFileRaw"/>
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.File.ImportEncryptedFileRaw"/>
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.Directory.ExportEncryptedDirectoryRaw"/>
+      /// <param name="inputStream">The stream to read previously backed up data from.</param>
+      /// <param name="destinationPath">The path of the destination directory to restore to.</param>
+      /// <param name="overwriteHidden">If set to <c>true</c> a hidden directory will be overwritten on import.</param>
+      public static void ImportEncryptedDirectoryRaw(Stream inputStream, string destinationPath, bool overwriteHidden)
+      {
+         File.ImportExportEncryptedFileDirectoryRawCore(false, true, inputStream, destinationPath, overwriteHidden, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[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.
+      /// </summary>
+      /// <remarks>
+      ///   <para>If the caller does not have access to the key for the directory, the caller needs <see cref="Security.Privilege.Backup"/> to restore encrypted directories. See <see cref="Security.PrivilegeEnabler"/>.</para>
+      ///   <para>To restore an encrypted directory call one of the <see cref="O:Alphaleonis.Win32.Filesystem.Directory.ImportEncryptedDirectoryRaw"/> overloads and specify the file to restore along with the destination stream of the restored data.</para>
+      ///   <para>This function is intended for the restoration of only encrypted directories; see <see cref="BackupFileStream"/> for backup of unencrypted files.</para>
+      /// </remarks>
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.File.ExportEncryptedFileRaw"/>
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.File.ImportEncryptedFileRaw"/>
+      /// <seealso cref="O:Alphaleonis.Win32.Filesystem.Directory.ExportEncryptedDirectoryRaw"/>
+      /// <param name="inputStream">The stream to read previously backed up data from.</param>
+      /// <param name="destinationPath">The path of the destination directory to restore to.</param>
+      /// <param name="overwriteHidden">If set to <c>true</c> a hidden directory will be overwritten on import.</param>
+      /// <param name="pathFormat">The path format of the <paramref name="destinationPath"/> parameter.</param>
+      public static void ImportEncryptedDirectoryRaw(Stream inputStream, string destinationPath, bool overwriteHidden, PathFormat pathFormat)
+      {
+         File.ImportExportEncryptedFileDirectoryRawCore(false, true, inputStream, destinationPath, overwriteHidden, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Junctions, Links/Directory.CreateJunction.cs

@@ -0,0 +1,188 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J")</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      [SecurityCritical]
+      public static void CreateJunction(string junctionPath, string directoryPath)
+      {
+         CreateJunctionCore(null, junctionPath, directoryPath, false, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J").</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CreateJunction(string junctionPath, string directoryPath, PathFormat pathFormat)
+      {
+         CreateJunctionCore(null, junctionPath, directoryPath, false, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J"). Overwriting a junction point of the same name is allowed.</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="overwrite"><c>true</c> to overwrite an existing junction point. The directory is removed and recreated.</param>
+      [SecurityCritical]
+      public static void CreateJunction(string junctionPath, string directoryPath, bool overwrite)
+      {
+         CreateJunctionCore(null, junctionPath, directoryPath, overwrite, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J"). Overwriting a junction point of the same name is allowed.</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="overwrite"><c>true</c> to overwrite an existing junction point. The directory is removed and recreated.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CreateJunction(string junctionPath, string directoryPath, bool overwrite, PathFormat pathFormat)
+      {
+         CreateJunctionCore(null, junctionPath, directoryPath, overwrite, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J"). Overwriting a junction point of the same name is allowed.</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="overwrite"><c>true</c> to overwrite an existing junction point. The directory is removed and recreated.</param>
+      /// <param name="copyTargetTimestamps"><c>true</c> to copy the target date and time stamps to the directory junction.</param>
+      [SecurityCritical]
+      public static void CreateJunction(string junctionPath, string directoryPath, bool overwrite, bool copyTargetTimestamps)
+      {
+         CreateJunctionCore(null, junctionPath, directoryPath, overwrite, copyTargetTimestamps, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J"). Overwriting a junction point of the same name is allowed.</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="overwrite"><c>true</c> to overwrite an existing junction point. The directory is removed and recreated.</param>
+      /// <param name="copyTargetTimestamps"><c>true</c> to copy the target date and time stamps to the directory junction.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CreateJunction(string junctionPath, string directoryPath, bool overwrite, bool copyTargetTimestamps, PathFormat pathFormat)
+      {
+         CreateJunctionCore(null, junctionPath, directoryPath, overwrite, copyTargetTimestamps, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Junctions, Links/Directory.CreateJunctionTransacted.cs

@@ -0,0 +1,367 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      #region Obsolete
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J").</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      [SecurityCritical]
+      public static void CreateJunction(KernelTransaction transaction, string junctionPath, string directoryPath)
+      {
+         CreateJunctionCore(transaction, junctionPath, directoryPath, false, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J").</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CreateJunction(KernelTransaction transaction, string junctionPath, string directoryPath, PathFormat pathFormat)
+      {
+         CreateJunctionCore(transaction, junctionPath, directoryPath, false, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J"). Overwriting a junction point of the same name is allowed.</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="overwrite"><c>true</c> to overwrite an existing junction point. The directory is removed and recreated.</param>
+      [SecurityCritical]
+      public static void CreateJunction(KernelTransaction transaction, string junctionPath, string directoryPath, bool overwrite)
+      {
+         CreateJunctionCore(transaction, junctionPath, directoryPath, overwrite, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J"). Overwriting a junction point of the same name is allowed.</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="overwrite"><c>true</c> to overwrite an existing junction point. The directory is removed and recreated.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CreateJunction(KernelTransaction transaction, string junctionPath, string directoryPath, bool overwrite, PathFormat pathFormat)
+      {
+         CreateJunctionCore(transaction, junctionPath, directoryPath, overwrite, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J"). Overwriting a junction point of the same name is allowed.</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// The directory date and time stamps from <paramref name="directoryPath"/> (the target) are copied to the directory junction.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="overwrite"><c>true</c> to overwrite an existing junction point. The directory is removed and recreated.</param>
+      /// <param name="copyTargetTimestamps"><c>true</c> to copy the target date and time stamps to the directory junction.</param>
+      [SecurityCritical]
+      public static void CreateJunction(KernelTransaction transaction, string junctionPath, string directoryPath, bool overwrite, bool copyTargetTimestamps)
+      {
+         CreateJunctionCore(transaction, junctionPath, directoryPath, overwrite, copyTargetTimestamps, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J"). Overwriting a junction point of the same name is allowed.</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// The directory date and time stamps from <paramref name="directoryPath"/> (the target) are copied to the directory junction.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="overwrite"><c>true</c> to overwrite an existing junction point. The directory is removed and recreated.</param>
+      /// <param name="copyTargetTimestamps"><c>true</c> to copy the target date and time stamps to the directory junction.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CreateJunction(KernelTransaction transaction, string junctionPath, string directoryPath, bool overwrite, bool copyTargetTimestamps, PathFormat pathFormat)
+      {
+         CreateJunctionCore(transaction, junctionPath, directoryPath, overwrite, copyTargetTimestamps, pathFormat);
+      }
+
+      #endregion // Obsolete
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J").</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      [SecurityCritical]
+      public static void CreateJunctionTransacted(KernelTransaction transaction, string junctionPath, string directoryPath)
+      {
+         CreateJunctionCore(transaction, junctionPath, directoryPath, false, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J").</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CreateJunctionTransacted(KernelTransaction transaction, string junctionPath, string directoryPath, PathFormat pathFormat)
+      {
+         CreateJunctionCore(transaction, junctionPath, directoryPath, false, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J"). Overwriting a junction point of the same name is allowed.</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="overwrite"><c>true</c> to overwrite an existing junction point. The directory is removed and recreated.</param>
+      [SecurityCritical]
+      public static void CreateJunctionTransacted(KernelTransaction transaction, string junctionPath, string directoryPath, bool overwrite)
+      {
+         CreateJunctionCore(transaction, junctionPath, directoryPath, overwrite, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J"). Overwriting a junction point of the same name is allowed.</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="overwrite"><c>true</c> to overwrite an existing junction point. The directory is removed and recreated.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CreateJunctionTransacted(KernelTransaction transaction, string junctionPath, string directoryPath, bool overwrite, PathFormat pathFormat)
+      {
+         CreateJunctionCore(transaction, junctionPath, directoryPath, overwrite, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J"). Overwriting a junction point of the same name is allowed.</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// The directory date and time stamps from <paramref name="directoryPath"/> (the target) are copied to the directory junction.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="overwrite"><c>true</c> to overwrite an existing junction point. The directory is removed and recreated.</param>
+      /// <param name="copyTargetTimestamps"><c>true</c> to copy the target date and time stamps to the directory junction.</param>
+      [SecurityCritical]
+      public static void CreateJunctionTransacted(KernelTransaction transaction, string junctionPath, string directoryPath, bool overwrite, bool copyTargetTimestamps)
+      {
+         CreateJunctionCore(transaction, junctionPath, directoryPath, overwrite, copyTargetTimestamps, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Creates an NTFS directory junction (similar to CMD command: "MKLINK /J"). Overwriting a junction point of the same name is allowed.</summary>
+      /// <remarks>
+      /// The directory must be empty and reside on a local volume.
+      /// The directory date and time stamps from <paramref name="directoryPath"/> (the target) are copied to the directory junction.
+      /// <para>
+      ///   MSDN: A junction (also called a soft link) differs from a hard link in that the storage objects it references are separate directories,
+      ///   and a junction can link directories located on different local volumes on the same computer.
+      ///   Otherwise, junctions operate identically to hard links. Junctions are implemented through reparse points.
+      /// </para>
+      /// </remarks>
+      /// <exception cref="AlreadyExistsException"/>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to create.</param>
+      /// <param name="directoryPath">The path to the directory. If the directory does not exist it will be created.</param>
+      /// <param name="overwrite"><c>true</c> to overwrite an existing junction point. The directory is removed and recreated.</param>
+      /// <param name="copyTargetTimestamps"><c>true</c> to copy the target date and time stamps to the directory junction.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CreateJunctionTransacted(KernelTransaction transaction, string junctionPath, string directoryPath, bool overwrite, bool copyTargetTimestamps, PathFormat pathFormat)
+      {
+         CreateJunctionCore(transaction, junctionPath, directoryPath, overwrite, copyTargetTimestamps, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Junctions, Links/Directory.CreateSymbolicLink.cs

@@ -0,0 +1,77 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Creates a symbolic link  to a directory (similar to CMD command: "MKLINK /D").</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Symbolic links can point to a non-existent target.</para>
+      /// <para>When creating a symbolic link, the operating system does not check to see if the target exists.</para>
+      /// <para>Symbolic links are reparse points.</para>
+      /// <para>There is a maximum of 31 reparse points (and therefore symbolic links) allowed in a particular path.</para>
+      /// <para>See <see cref="Security.Privilege.CreateSymbolicLink"/> to run this method in an elevated state.</para>
+      /// </remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="PlatformNotSupportedException">The operating system is older than Windows Vista.</exception>
+      /// <param name="symlinkDirectoryName">The name of the target for the symbolic link to be created.</param>
+      /// <param name="targetDirectoryName">The symbolic link to be created.</param>
+      [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "symlink")]
+      [SecurityCritical]
+      public static void CreateSymbolicLink(string symlinkDirectoryName, string targetDirectoryName)
+      {
+         File.CreateSymbolicLinkCore(null, symlinkDirectoryName, targetDirectoryName, SymbolicLinkTarget.Directory, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Creates a symbolic link  to a directory (similar to CMD command: "MKLINK /D").</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Symbolic links can point to a non-existent target.</para>
+      /// <para>When creating a symbolic link, the operating system does not check to see if the target exists.</para>
+      /// <para>Symbolic links are reparse points.</para>
+      /// <para>There is a maximum of 31 reparse points (and therefore symbolic links) allowed in a particular path.</para>
+      /// <para>See <see cref="Security.Privilege.CreateSymbolicLink"/> to run this method in an elevated state.</para>
+      /// </remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="PlatformNotSupportedException">The operating system is older than Windows Vista.</exception>
+      /// <param name="symlinkDirectoryName">The name of the target for the symbolic link to be created.</param>
+      /// <param name="targetDirectoryName">The symbolic link to be created.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>      
+      [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "symlink")]
+      [SecurityCritical]
+      public static void CreateSymbolicLink(string symlinkDirectoryName, string targetDirectoryName, PathFormat pathFormat)
+      {
+         File.CreateSymbolicLinkCore(null, symlinkDirectoryName, targetDirectoryName, SymbolicLinkTarget.Directory, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Junctions, Links/Directory.CreateSymbolicLinkTransacted.cs

@@ -0,0 +1,79 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Creates a symbolic link (similar to CMD command: "MKLINK /D") to a directory as a transacted operation.</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Symbolic links can point to a non-existent target.</para>
+      /// <para>When creating a symbolic link, the operating system does not check to see if the target exists.</para>
+      /// <para>Symbolic links are reparse points.</para>
+      /// <para>There is a maximum of 31 reparse points (and therefore symbolic links) allowed in a particular path.</para>
+      /// <para>See <see cref="Security.Privilege.CreateSymbolicLink"/> to run this method in an elevated state.</para>
+      /// </remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="PlatformNotSupportedException">The operating system is older than Windows Vista.</exception>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="symlinkDirectoryName">The name of the target for the symbolic link to be created.</param>
+      /// <param name="targetDirectoryName">The symbolic link to be created.</param>
+      [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "symlink")]
+      [SecurityCritical]
+      public static void CreateSymbolicLinkTransacted(KernelTransaction transaction, string symlinkDirectoryName, string targetDirectoryName)
+      {
+         File.CreateSymbolicLinkCore(transaction, symlinkDirectoryName, targetDirectoryName, SymbolicLinkTarget.Directory, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Creates a symbolic link (similar to CMD command: "MKLINK /D") to a directory as a transacted operation.</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Symbolic links can point to a non-existent target.</para>
+      /// <para>When creating a symbolic link, the operating system does not check to see if the target exists.</para>
+      /// <para>Symbolic links are reparse points.</para>
+      /// <para>There is a maximum of 31 reparse points (and therefore symbolic links) allowed in a particular path.</para>
+      /// <para>See <see cref="Security.Privilege.CreateSymbolicLink"/> to run this method in an elevated state.</para>
+      /// </remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="PlatformNotSupportedException">The operating system is older than Windows Vista.</exception>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="symlinkDirectoryName">The name of the target for the symbolic link to be created.</param>
+      /// <param name="targetDirectoryName">The symbolic link to be created.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>      
+      [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "symlink")]
+      [SecurityCritical]
+      public static void CreateSymbolicLinkTransacted(KernelTransaction transaction, string symlinkDirectoryName, string targetDirectoryName, PathFormat pathFormat)
+      {
+         File.CreateSymbolicLinkCore(transaction, symlinkDirectoryName, targetDirectoryName, SymbolicLinkTarget.Directory, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Junctions, Links/Directory.DeleteJunction.cs

@@ -0,0 +1,117 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Deletes an NTFS directory junction.</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Only the directory junction is removed, not the target.</para>
+      /// </remarks>
+      /// <returns>A <see cref="DirectoryInfo"/> instance referencing the junction point.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotAReparsePointException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="junctionPath">The path of the junction point to remove.</param>
+      [SecurityCritical]
+      public static void DeleteJunction(string junctionPath)
+      {
+         DeleteJunctionCore(null, null, junctionPath, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Deletes an NTFS directory junction.</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Only the directory junction is removed, not the target.</para>
+      /// </remarks>
+      /// <returns>A <see cref="DirectoryInfo"/> instance referencing the junction point.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotAReparsePointException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="junctionPath">The path of the junction point to remove.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void DeleteJunction(string junctionPath, PathFormat pathFormat)
+      {
+         DeleteJunctionCore(null, null, junctionPath, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Deletes an NTFS directory junction.</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Only the directory junction is removed, not the target.</para>
+      /// </remarks>
+      /// <returns>A <see cref="DirectoryInfo"/> instance referencing the junction point.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotAReparsePointException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="junctionPath">The path of the junction point to remove.</param>
+      /// <param name="removeDirectory">When <c>true</c>, also removes the directory and all its contents.</param>
+      [SecurityCritical]
+      public static void DeleteJunction(string junctionPath, bool removeDirectory)
+      {
+         DeleteJunctionCore(null, null, junctionPath, removeDirectory, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Deletes an NTFS directory junction.</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Only the directory junction is removed, not the target.</para>
+      /// </remarks>
+      /// <returns>A <see cref="DirectoryInfo"/> instance referencing the junction point.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotAReparsePointException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="junctionPath">The path of the junction point to remove.</param>
+      /// <param name="removeDirectory">When <c>true</c>, also removes the directory and all its contents.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void DeleteJunction(string junctionPath, bool removeDirectory, PathFormat pathFormat)
+      {
+         DeleteJunctionCore(null, null, junctionPath, removeDirectory, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Junctions, Links/Directory.DeleteJunctionTransacted.cs

@@ -0,0 +1,221 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      #region Obsolete
+
+      /// <summary>[AlphaFS] Deletes an NTFS directory junction.</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Only the directory junction is removed, not the target.</para>
+      /// </remarks>
+      /// <returns>A <see cref="DirectoryInfo"/> instance referencing the junction point.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotAReparsePointException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to remove.</param>
+      [Obsolete("Use method DeleteJunctionTransacted.")]
+      [SecurityCritical]
+      public static void DeleteJunction(KernelTransaction transaction, string junctionPath)
+      {
+         DeleteJunctionCore(transaction, null, junctionPath, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Deletes an NTFS directory junction.</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Only the directory junction is removed, not the target.</para>
+      /// </remarks>
+      /// <returns>A <see cref="DirectoryInfo"/> instance referencing the junction point.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotAReparsePointException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to remove.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [Obsolete("Use method DeleteJunctionTransacted.")]
+      [SecurityCritical]
+      public static void DeleteJunction(KernelTransaction transaction, string junctionPath, PathFormat pathFormat)
+      {
+         DeleteJunctionCore(transaction, null, junctionPath, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Deletes an NTFS directory junction.</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Only the directory junction is removed, not the target.</para>
+      /// </remarks>
+      /// <returns>A <see cref="DirectoryInfo"/> instance referencing the junction point.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotAReparsePointException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to remove.</param>
+      /// <param name="removeDirectory">When <c>true</c>, also removes the directory and all its contents.</param>
+      [Obsolete("Use method DeleteJunctionTransacted.")]
+      [SecurityCritical]
+      public static void DeleteJunction(KernelTransaction transaction, string junctionPath, bool removeDirectory)
+      {
+         DeleteJunctionCore(transaction, null, junctionPath, removeDirectory, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Deletes an NTFS directory junction.</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Only the directory junction is removed, not the target.</para>
+      /// </remarks>
+      /// <returns>A <see cref="DirectoryInfo"/> instance referencing the junction point.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotAReparsePointException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to remove.</param>
+      /// <param name="removeDirectory">When <c>true</c>, also removes the directory and all its contents.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [Obsolete("Use method DeleteJunctionTransacted.")]
+      [SecurityCritical]
+      public static void DeleteJunction(KernelTransaction transaction, string junctionPath, bool removeDirectory, PathFormat pathFormat)
+      {
+         DeleteJunctionCore(transaction, null, junctionPath, removeDirectory, pathFormat);
+      }
+
+      #endregion // Obsolete
+
+
+      /// <summary>[AlphaFS] Deletes an NTFS directory junction.</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Only the directory junction is removed, not the target.</para>
+      /// </remarks>
+      /// <returns>A <see cref="DirectoryInfo"/> instance referencing the junction point.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotAReparsePointException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to remove.</param>
+      [SecurityCritical]
+      public static void DeleteJunctionTransacted(KernelTransaction transaction, string junctionPath)
+      {
+         DeleteJunctionCore(transaction, null, junctionPath, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Deletes an NTFS directory junction.</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Only the directory junction is removed, not the target.</para>
+      /// </remarks>
+      /// <returns>A <see cref="DirectoryInfo"/> instance referencing the junction point.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotAReparsePointException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to remove.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void DeleteJunctionTransacted(KernelTransaction transaction, string junctionPath, PathFormat pathFormat)
+      {
+         DeleteJunctionCore(transaction, null, junctionPath, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Deletes an NTFS directory junction.</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Only the directory junction is removed, not the target.</para>
+      /// </remarks>
+      /// <returns>A <see cref="DirectoryInfo"/> instance referencing the junction point.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotAReparsePointException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to remove.</param>
+      /// <param name="removeDirectory">When <c>true</c>, also removes the directory and all its contents.</param>
+      [SecurityCritical]
+      public static void DeleteJunctionTransacted(KernelTransaction transaction, string junctionPath, bool removeDirectory)
+      {
+         DeleteJunctionCore(transaction, null, junctionPath, removeDirectory, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Deletes an NTFS directory junction.</summary>
+      /// <para>&#160;</para>
+      /// <remarks>
+      /// <para>Only the directory junction is removed, not the target.</para>
+      /// </remarks>
+      /// <returns>A <see cref="DirectoryInfo"/> instance referencing the junction point.</returns>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotAReparsePointException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path of the junction point to remove.</param>
+      /// <param name="removeDirectory">When <c>true</c>, also removes the directory and all its contents.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void DeleteJunctionTransacted(KernelTransaction transaction, string junctionPath, bool removeDirectory, PathFormat pathFormat)
+      {
+         DeleteJunctionCore(transaction, null, junctionPath, removeDirectory, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Junctions, Links/Directory.ExistsJunction.cs

@@ -0,0 +1,78 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Determines whether the given path refers to an existing directory junction on disk.</summary>
+      /// <returns>
+      ///   <para>Returns <c>true</c> if <paramref name="junctionPath"/> refers to an existing directory junction.</para>
+      ///   <para>Returns <c>false</c> if the directory junction does not exist or an error occurs when trying to determine if the specified file exists.</para>
+      /// </returns>
+      /// <para>&#160;</para>
+      /// <remarks>
+      ///   <para>The Exists method returns <c>false</c> if any error occurs while trying to determine if the specified file exists.</para>
+      ///   <para>This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters,</para>
+      ///   <para>a failing or missing disk, or if the caller does not have permission to read the file.</para>
+      /// </remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="junctionPath">The path to test.</param>
+      [SecurityCritical]
+      public static bool ExistsJunction(string junctionPath)
+      {
+         return ExistsJunctionCore(null, null, junctionPath, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Determines whether the given path refers to an existing directory junction on disk.</summary>
+      /// <returns>
+      ///   <para>Returns <c>true</c> if <paramref name="junctionPath"/> refers to an existing directory junction.</para>
+      ///   <para>Returns <c>false</c> if the directory junction does not exist or an error occurs when trying to determine if the specified file exists.</para>
+      /// </returns>
+      /// <para>&#160;</para>
+      /// <remarks>
+      ///   <para>The Exists method returns <c>false</c> if any error occurs while trying to determine if the specified file exists.</para>
+      ///   <para>This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters,</para>
+      ///   <para>a failing or missing disk, or if the caller does not have permission to read the file.</para>
+      /// </remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="junctionPath">The path to test.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static bool ExistsJunction(string junctionPath, PathFormat pathFormat)
+      {
+         return ExistsJunctionCore(null, null, junctionPath, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Junctions, Links/Directory.ExistsJunctionTransacted.cs

@@ -0,0 +1,137 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      #region Obsolete
+
+      /// <summary>[AlphaFS] Determines whether the given path refers to an existing directory junction on disk.</summary>
+      /// <returns>
+      ///   <para>Returns <c>true</c> if <paramref name="junctionPath"/> refers to an existing directory junction.</para>
+      ///   <para>Returns <c>false</c> if the directory junction does not exist or an error occurs when trying to determine if the specified file exists.</para>
+      /// </returns>
+      /// <para>&#160;</para>
+      /// <remarks>
+      ///   <para>The Exists method returns <c>false</c> if any error occurs while trying to determine if the specified file exists.</para>
+      ///   <para>This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters,</para>
+      ///   <para>a failing or missing disk, or if the caller does not have permission to read the file.</para>
+      /// </remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path to test.</param>
+      [Obsolete("Use ExistsJunctionTransacted method.")]
+      [SecurityCritical]
+      public static bool ExistsJunction(KernelTransaction transaction, string junctionPath)
+      {
+         return ExistsJunctionCore(transaction, null, junctionPath, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Determines whether the given path refers to an existing directory junction on disk.</summary>
+      /// <returns>
+      ///   <para>Returns <c>true</c> if <paramref name="junctionPath"/> refers to an existing directory junction.</para>
+      ///   <para>Returns <c>false</c> if the directory junction does not exist or an error occurs when trying to determine if the specified file exists.</para>
+      /// </returns>
+      /// <para>&#160;</para>
+      /// <remarks>
+      ///   <para>The Exists method returns <c>false</c> if any error occurs while trying to determine if the specified file exists.</para>
+      ///   <para>This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters,</para>
+      ///   <para>a failing or missing disk, or if the caller does not have permission to read the file.</para>
+      /// </remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path to test.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [Obsolete("Use ExistsJunctionTransacted method.")]
+      [SecurityCritical]
+      public static bool ExistsJunction(KernelTransaction transaction, string junctionPath, PathFormat pathFormat)
+      {
+         return ExistsJunctionCore(transaction, null, junctionPath, pathFormat);
+      }
+
+      #endregion // Obsolete
+
+
+      /// <summary>[AlphaFS] Determines whether the given path refers to an existing directory junction on disk.</summary>
+      /// <returns>
+      ///   <para>Returns <c>true</c> if <paramref name="junctionPath"/> refers to an existing directory junction.</para>
+      ///   <para>Returns <c>false</c> if the directory junction does not exist or an error occurs when trying to determine if the specified file exists.</para>
+      /// </returns>
+      /// <para>&#160;</para>
+      /// <remarks>
+      ///   <para>The Exists method returns <c>false</c> if any error occurs while trying to determine if the specified file exists.</para>
+      ///   <para>This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters,</para>
+      ///   <para>a failing or missing disk, or if the caller does not have permission to read the file.</para>
+      /// </remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path to test.</param>
+      [SecurityCritical]
+      public static bool ExistsJunctionTransacted(KernelTransaction transaction, string junctionPath)
+      {
+         return ExistsJunctionCore(transaction, null, junctionPath, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Determines whether the given path refers to an existing directory junction on disk.</summary>
+      /// <returns>
+      ///   <para>Returns <c>true</c> if <paramref name="junctionPath"/> refers to an existing directory junction.</para>
+      ///   <para>Returns <c>false</c> if the directory junction does not exist or an error occurs when trying to determine if the specified file exists.</para>
+      /// </returns>
+      /// <para>&#160;</para>
+      /// <remarks>
+      ///   <para>The Exists method returns <c>false</c> if any error occurs while trying to determine if the specified file exists.</para>
+      ///   <para>This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters,</para>
+      ///   <para>a failing or missing disk, or if the caller does not have permission to read the file.</para>
+      /// </remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="ArgumentNullException"/>
+      /// <exception cref="IOException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <exception cref="UnauthorizedAccessException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="junctionPath">The path to test.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static bool ExistsJunctionTransacted(KernelTransaction transaction, string junctionPath, PathFormat pathFormat)
+      {
+         return ExistsJunctionCore(transaction, null, junctionPath, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.CopyTimestamps.cs

@@ -0,0 +1,145 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      #region Obsolete
+
+      /// <summary>[AlphaFS] Copies the date and timestamps for the specified directories.</summary>
+      /// <remarks>This method uses BackupSemantics flag to get Timestamp changed for directories.</remarks>
+      /// <param name="sourcePath">The source directory to get the date and time stamps from.</param>
+      /// <param name="destinationPath">The destination directory to set the date and time stamps.</param>
+      [Obsolete("Use new method name: CopyTimestamp")]
+      [SecurityCritical]
+      public static void TransferTimestamps(string sourcePath, string destinationPath)
+      {
+         CopyTimestamps(sourcePath, destinationPath);
+      }
+
+      /// <summary>[AlphaFS] Copies the date and timestamps for the specified directories.</summary>
+      /// <remarks>This method uses BackupSemantics flag to get Timestamp changed for directories.</remarks>
+      /// <param name="sourcePath">The source directory to get the date and time stamps from.</param>
+      /// <param name="destinationPath">The destination directory to set the date and time stamps.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [Obsolete("Use new method name: CopyTimestamp")]
+      [SecurityCritical]
+      public static void TransferTimestamps(string sourcePath, string destinationPath, PathFormat pathFormat)
+      {
+         CopyTimestamps(sourcePath, destinationPath, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Copies the date and timestamps for the specified directories.</summary>
+      /// <remarks>This method uses BackupSemantics flag to get Timestamp changed for directories.</remarks>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="sourcePath">The source directory to get the date and time stamps from.</param>
+      /// <param name="destinationPath">The destination directory to set the date and time stamps.</param>
+      [Obsolete("Use new method name: CopyTimestampsTransacted")]
+      [SecurityCritical]
+      public static void TransferTimestampsTransacted(KernelTransaction transaction, string sourcePath, string destinationPath)
+      {
+         CopyTimestampsTransacted(transaction, sourcePath, destinationPath, PathFormat.RelativePath);
+      }
+
+      /// <summary>[AlphaFS] Copies the date and timestamps for the specified directories.</summary>
+      /// <remarks>This method uses BackupSemantics flag to get Timestamp changed for directories.</remarks>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="sourcePath">The source directory to get the date and time stamps from.</param>
+      /// <param name="destinationPath">The destination directory to set the date and time stamps.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [Obsolete("Use new method name: CopyTimestampsTransacted")]
+      [SecurityCritical]
+      public static void TransferTimestampsTransacted(KernelTransaction transaction, string sourcePath, string destinationPath, PathFormat pathFormat)
+      {
+         CopyTimestampsTransacted(transaction, sourcePath, destinationPath, pathFormat);
+      }
+
+      #endregion // Obsolete
+
+
+
+
+      /// <summary>[AlphaFS] Copies the date and timestamps for the specified existing directories.</summary>
+      /// <remarks>This method uses BackupSemantics flag to get Timestamp changed for directories.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <param name="sourcePath">The source directory to get the date and time stamps from.</param>
+      /// <param name="destinationPath">The destination directory to set the date and time stamps.</param>
+      [SecurityCritical]
+      public static void CopyTimestamps(string sourcePath, string destinationPath)
+      {
+         File.CopyTimestampsCore(null, true, sourcePath, destinationPath, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Copies the date and timestamps for the specified existing directories.</summary>
+      /// <remarks>This method uses BackupSemantics flag to get Timestamp changed for directories.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <param name="sourcePath">The source directory to get the date and time stamps from.</param>
+      /// <param name="destinationPath">The destination directory to set the date and time stamps.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CopyTimestamps(string sourcePath, string destinationPath, PathFormat pathFormat)
+      {
+         File.CopyTimestampsCore(null, true, sourcePath, destinationPath, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Copies the date and timestamps for the specified existing directories.</summary>
+      /// <remarks>This method uses BackupSemantics flag to get Timestamp changed for directories.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <param name="sourcePath">The source directory to get the date and time stamps from.</param>
+      /// <param name="destinationPath">The destination directory to set the date and time stamps.</param>
+      /// <param name="modifyReparsePoint">If <c>true</c>, the date and time information will apply to the reparse point (symlink or junction) and not the directory linked to. No effect if <paramref name="destinationPath"/> does not refer to a reparse point.</param>
+      [SecurityCritical]
+      public static void CopyTimestamps(string sourcePath, string destinationPath, bool modifyReparsePoint)
+      {
+         File.CopyTimestampsCore(null, true, sourcePath, destinationPath, modifyReparsePoint, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Copies the date and timestamps for the specified existing directories.</summary>
+      /// <remarks>This method uses BackupSemantics flag to get Timestamp changed for directories.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <param name="sourcePath">The source directory to get the date and time stamps from.</param>
+      /// <param name="destinationPath">The destination directory to set the date and time stamps.</param>
+      /// <param name="modifyReparsePoint">If <c>true</c>, the date and time information will apply to the reparse point (symlink or junction) and not the directory linked to. No effect if <paramref name="destinationPath"/> does not refer to a reparse point.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CopyTimestamps(string sourcePath, string destinationPath, bool modifyReparsePoint, PathFormat pathFormat)
+      {
+         File.CopyTimestampsCore(null, true, sourcePath, destinationPath, modifyReparsePoint, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.CopyTimestampsTransacted.cs

@@ -0,0 +1,93 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.IO;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Copies the date and timestamps for the specified existing directories.</summary>
+      /// <remarks>This method uses BackupSemantics flag to get Timestamp changed for directories.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="sourcePath">The source directory to get the date and time stamps from.</param>
+      /// <param name="destinationPath">The destination directory to set the date and time stamps.</param>
+      [SecurityCritical]
+      public static void CopyTimestampsTransacted(KernelTransaction transaction, string sourcePath, string destinationPath)
+      {
+         File.CopyTimestampsCore(transaction, true, sourcePath, destinationPath, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Copies the date and timestamps for the specified existing directories.</summary>
+      /// <remarks>This method uses BackupSemantics flag to get Timestamp changed for directories.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="sourcePath">The source directory to get the date and time stamps from.</param>
+      /// <param name="destinationPath">The destination directory to set the date and time stamps.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CopyTimestampsTransacted(KernelTransaction transaction, string sourcePath, string destinationPath, PathFormat pathFormat)
+      {
+         File.CopyTimestampsCore(transaction, true, sourcePath, destinationPath, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Copies the date and timestamps for the specified existing directories.</summary>
+      /// <remarks>This method uses BackupSemantics flag to get Timestamp changed for directories.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="sourcePath">The source directory to get the date and time stamps from.</param>
+      /// <param name="destinationPath">The destination directory to set the date and time stamps.</param>
+      /// <param name="modifyReparsePoint">If <c>true</c>, the date and time information will apply to the reparse point (symlink or junction) and not the directory linked to. No effect if <paramref name="destinationPath"/> does not refer to a reparse point.</param>
+      [SecurityCritical]
+      public static void CopyTimestampsTransacted(KernelTransaction transaction, string sourcePath, string destinationPath, bool modifyReparsePoint)
+      {
+         File.CopyTimestampsCore(transaction, true, sourcePath, destinationPath, modifyReparsePoint, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Copies the date and timestamps for the specified existing directories.</summary>
+      /// <remarks>This method uses BackupSemantics flag to get Timestamp changed for directories.</remarks>
+      /// <exception cref="ArgumentException"/>
+      /// <exception cref="DirectoryNotFoundException"/>
+      /// <exception cref="NotSupportedException"/>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="sourcePath">The source directory to get the date and time stamps from.</param>
+      /// <param name="destinationPath">The destination directory to set the date and time stamps.</param>
+      /// <param name="modifyReparsePoint">If <c>true</c>, the date and time information will apply to the reparse point (symlink or junction) and not the directory linked to. No effect if <paramref name="destinationPath"/> does not refer to a reparse point.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static void CopyTimestampsTransacted(KernelTransaction transaction, string sourcePath, string destinationPath, bool modifyReparsePoint, PathFormat pathFormat)
+      {
+         File.CopyTimestampsCore(transaction, true, sourcePath, destinationPath, modifyReparsePoint, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetChangeTime.cs

@@ -0,0 +1,59 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using Microsoft.Win32.SafeHandles;
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Gets the change date and time of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the change date and time for the specified directory. This value is expressed in local time.</returns>
+      /// <param name="path">The directory for which to obtain creation date and time information.</param>
+      [SecurityCritical]
+      public static DateTime GetChangeTime(string path)
+      {
+         return File.GetChangeTimeCore(null, null, true, path, false, PathFormat.RelativePath);
+      }
+
+      /// <summary>[AlphaFS] Gets the change date and time of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the change date and time for the specified directory. This value is expressed in local time.</returns>
+      /// <param name="path">The directory for which to obtain creation date and time information.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetChangeTime(string path, PathFormat pathFormat)
+      {
+         return File.GetChangeTimeCore(null, null, true, path, false, pathFormat);
+      }
+
+
+      /// <summary>[AlphaFS] Gets the change date and time of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the change date and time for the specified directory. This value is expressed in local time.</returns>
+      /// <param name="safeFileHandle">An open handle to the directory from which to retrieve information.</param>
+      [SecurityCritical]
+      public static DateTime GetChangeTime(SafeFileHandle safeFileHandle)
+      {
+         return File.GetChangeTimeCore(null, safeFileHandle, true, null, true, PathFormat.RelativePath);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetChangeTimeTransacted.cs

@@ -0,0 +1,51 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Gets the change date and time of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the change date and time for the specified directory. This value is expressed in local time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory for which to obtain creation date and time information.</param>
+      [SecurityCritical]
+      public static DateTime GetChangeTimeTransacted(KernelTransaction transaction, string path)
+      {
+         return File.GetChangeTimeCore(transaction, null, true, path, false, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Gets the change date and time of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the change date and time for the specified directory. This value is expressed in local time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory for which to obtain creation date and time information.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetChangeTimeTransacted(KernelTransaction transaction, string path, PathFormat pathFormat)
+      {
+         return File.GetChangeTimeCore(transaction, null, true, path, false, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetChangeTimeUtc.cs

@@ -0,0 +1,49 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the change date and time for the specified directory. This value is expressed in UTC time.</returns>
+      /// <param name="path">The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format.</param>
+      [SecurityCritical]
+      public static DateTime GetChangeTimeUtc(string path)
+      {
+         return File.GetChangeTimeCore(null, null, true, path, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the change date and time for the specified directory. This value is expressed in UTC time.</returns>
+      /// <param name="path">The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetChangeTimeUtc(string path, PathFormat pathFormat)
+      {
+         return File.GetChangeTimeCore(null, null, true, path, true, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetChangeTimeUtcTransacted.cs

@@ -0,0 +1,51 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the change date and time for the specified directory. This value is expressed in UTC time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format.</param>
+      [SecurityCritical]
+      public static DateTime GetChangeTimeUtcTransacted(KernelTransaction transaction, string path)
+      {
+         return File.GetChangeTimeCore(transaction, null, true, path, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Gets the change date and time, in Coordinated Universal Time (UTC) format, of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the change date and time for the specified directory. This value is expressed in UTC time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The file for which to obtain change date and time information, in Coordinated Universal Time (UTC) format.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetChangeTimeUtcTransacted(KernelTransaction transaction, string path, PathFormat pathFormat)
+      {
+         return File.GetChangeTimeCore(transaction, null, true, path, true, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetCreationTime.cs

@@ -0,0 +1,53 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      #region .NET
+
+      /// <summary>Gets the creation date and time of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the creation date and time for the specified directory. This value is expressed in local time.</returns>
+      /// <param name="path">The directory for which to obtain creation date and time information.</param>
+      [SecurityCritical]
+      public static DateTime GetCreationTime(string path)
+      {
+         return File.GetCreationTimeCore(null, path, false, PathFormat.RelativePath).ToLocalTime();
+      }
+
+      #endregion // .NET
+
+
+      /// <summary>[AlphaFS] Gets the creation date and time of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the creation date and time for the specified directory. This value is expressed in local time.</returns>
+      /// <param name="path">The directory for which to obtain creation date and time information.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetCreationTime(string path, PathFormat pathFormat)
+      {
+         return File.GetCreationTimeCore(null, path, false, pathFormat).ToLocalTime();
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetCreationTimeTransacted.cs

@@ -0,0 +1,51 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Gets the creation date and time of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the creation date and time for the specified directory. This value is expressed in local time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory for which to obtain creation date and time information.</param>
+      [SecurityCritical]
+      public static DateTime GetCreationTimeTransacted(KernelTransaction transaction, string path)
+      {
+         return File.GetCreationTimeCore(transaction, path, false, PathFormat.RelativePath).ToLocalTime();
+      }
+
+
+      /// <summary>[AlphaFS] Gets the creation date and time of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the creation date and time for the specified directory. This value is expressed in local time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory for which to obtain creation date and time information.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetCreationTimeTransacted(KernelTransaction transaction, string path, PathFormat pathFormat)
+      {
+         return File.GetCreationTimeCore(transaction, path, false, pathFormat).ToLocalTime();
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetCreationTimeUtc.cs

@@ -0,0 +1,53 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      #region .NET
+
+      /// <summary>Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the creation date and time for the specified directory. This value is expressed in UTC time.</returns>
+      /// <param name="path">The directory for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format.</param>
+      [SecurityCritical]
+      public static DateTime GetCreationTimeUtc(string path)
+      {
+         return File.GetCreationTimeCore(null, path, true, PathFormat.RelativePath);
+      }
+
+      #endregion // .NET
+
+
+      /// <summary>[AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the creation date and time for the specified directory. This value is expressed in UTC time.</returns>
+      /// <param name="path">The directory for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetCreationTimeUtc(string path, PathFormat pathFormat)
+      {
+         return File.GetCreationTimeCore(null, path, true, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetCreationTimeUtcTransacted.cs

@@ -0,0 +1,51 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the creation date and time for the specified directory. This value is expressed in UTC time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format.</param>
+      [SecurityCritical]
+      public static DateTime GetCreationTimeUtcTransacted(KernelTransaction transaction, string path)
+      {
+         return File.GetCreationTimeCore(transaction, path, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Gets the creation date and time, in Coordinated Universal Time (UTC) format, of the specified directory.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the creation date and time for the specified directory. This value is expressed in UTC time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory for which to obtain creation date and time information, in Coordinated Universal Time (UTC) format.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetCreationTimeUtcTransacted(KernelTransaction transaction, string path, PathFormat pathFormat)
+      {
+         return File.GetCreationTimeCore(transaction, path, true, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetLastAccessTime.cs

@@ -0,0 +1,53 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      #region .NET
+
+      /// <summary>Gets the date and time that the specified directory was last accessed.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last accessed. This value is expressed in local time.</returns>
+      /// <param name="path">The directory for which to obtain access date and time information.</param>
+      [SecurityCritical]
+      public static DateTime GetLastAccessTime(string path)
+      {
+         return File.GetLastAccessTimeCore(null, path, false, PathFormat.RelativePath).ToLocalTime();
+      }
+
+      #endregion // .NET
+
+
+      /// <summary>[AlphaFS] Gets the date and time that the specified directory was last accessed.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last accessed. This value is expressed in local time.</returns>
+      /// <param name="path">The directory for which to obtain access date and time information.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetLastAccessTime(string path, PathFormat pathFormat)
+      {
+         return File.GetLastAccessTimeCore(null, path, false, pathFormat).ToLocalTime();
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetLastAccessTimeTransacted.cs

@@ -0,0 +1,51 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Gets the date and time that the specified directory was last accessed.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last accessed. This value is expressed in local time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory for which to obtain access date and time information.</param>
+      [SecurityCritical]
+      public static DateTime GetLastAccessTimeTransacted(KernelTransaction transaction, string path)
+      {
+         return File.GetLastAccessTimeCore(transaction, path, false, PathFormat.RelativePath).ToLocalTime();
+      }
+
+
+      /// <summary>[AlphaFS] Gets the date and time that the specified directory was last accessed.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last accessed. This value is expressed in local time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory for which to obtain access date and time information.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetLastAccessTimeTransacted(KernelTransaction transaction, string path, PathFormat pathFormat)
+      {
+         return File.GetLastAccessTimeCore(transaction, path, false, pathFormat).ToLocalTime();
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetLastAccessTimeUtc.cs

@@ -0,0 +1,53 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      #region .NET
+
+      /// <summary>Gets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last accessed. This value is expressed in local time.</returns>
+      /// <param name="path">The directory for which to obtain access date and time information.</param>
+      [SecurityCritical]
+      public static DateTime GetLastAccessTimeUtc(string path)
+      {
+         return File.GetLastAccessTimeCore(null, path, true, PathFormat.RelativePath);
+      }
+
+      #endregion // .NET
+
+
+      /// <summary>[AlphaFS] Gets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last accessed. This value is expressed in local time.</returns>
+      /// <param name="path">The directory for which to obtain access date and time information.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetLastAccessTimeUtc(string path, PathFormat pathFormat)
+      {
+         return File.GetLastAccessTimeCore(null, path, true, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetLastAccessTimeUtcTransacted.cs

@@ -0,0 +1,51 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Gets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last accessed. This value is expressed in local time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory for which to obtain access date and time information.</param>
+      [SecurityCritical]
+      public static DateTime GetLastAccessTimeUtcTransacted(KernelTransaction transaction, string path)
+      {
+         return File.GetLastAccessTimeCore(transaction, path, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Gets the date and time, in coordinated universal time (UTC), that the specified directory was last accessed.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last accessed. This value is expressed in local time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory for which to obtain access date and time information.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetLastAccessTimeUtcTransacted(KernelTransaction transaction, string path, PathFormat pathFormat)
+      {
+         return File.GetLastAccessTimeCore(transaction, path, true, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetLastWriteTime.cs

@@ -0,0 +1,53 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      #region .NET
+
+      /// <summary>Gets the date and time that the specified directory was last written to.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last written to. This value is expressed in local time.</returns>
+      /// <param name="path">The directory for which to obtain write date and time information.</param>
+      [SecurityCritical]
+      public static DateTime GetLastWriteTime(string path)
+      {
+         return File.GetLastWriteTimeCore(null, path, false, PathFormat.RelativePath).ToLocalTime();
+      }
+
+      #endregion // .NET
+
+
+      /// <summary>[AlphaFS] Gets the date and time that the specified directory was last written to.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last written to. This value is expressed in local time.</returns>
+      /// <param name="path">The directory for which to obtain write date and time information.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetLastWriteTime(string path, PathFormat pathFormat)
+      {
+         return File.GetLastWriteTimeCore(null, path, false, pathFormat).ToLocalTime();
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetLastWriteTimeTransacted.cs

@@ -0,0 +1,51 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Gets the date and time that the specified directory was last written to.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last written to. This value is expressed in local time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory for which to obtain write date and time information.</param>
+      [SecurityCritical]
+      public static DateTime GetLastWriteTimeTransacted(KernelTransaction transaction, string path)
+      {
+         return File.GetLastWriteTimeCore(transaction, path, false, PathFormat.RelativePath).ToLocalTime();
+      }
+
+
+      /// <summary>[AlphaFS] Gets the date and time that the specified directory was last written to.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last written to. This value is expressed in local time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory for which to obtain write date and time information.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetLastWriteTimeTransacted(KernelTransaction transaction, string path, PathFormat pathFormat)
+      {
+         return File.GetLastWriteTimeCore(transaction, path, false, pathFormat).ToLocalTime();
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetLastWriteTimeUtc.cs

@@ -0,0 +1,53 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      #region .NET
+
+      /// <summary>Gets the date and time, in coordinated universal time (UTC) time, that the specified directory was last written to.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last written to. This value is expressed in local time.</returns>
+      /// <param name="path">The directory for which to obtain write date and time information.</param>
+      [SecurityCritical]
+      public static DateTime GetLastWriteTimeUtc(string path)
+      {
+         return File.GetLastWriteTimeCore(null, path, true, PathFormat.RelativePath);
+      }
+
+      #endregion // .NET
+
+
+      /// <summary>[AlphaFS] Gets the date and time, in coordinated universal time (UTC) time, that the specified directory was last written to.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last written to. This value is expressed in local time.</returns>
+      /// <param name="path">The directory for which to obtain write date and time information.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetLastWriteTimeUtc(string path, PathFormat pathFormat)
+      {
+         return File.GetLastWriteTimeCore(null, path, true, pathFormat);
+      }
+   }
+}

winPEAS/winPEASexe/winPEAS/3rdParty/AlphaFS/Filesystem/Directory Class/Directory Time/Directory.GetLastWriteTimeUtcTransacted.cs

@@ -0,0 +1,51 @@
+/*  Copyright (C) 2008-2018 Peter Palotas, Jeffrey Jangli, Alexandr Normuradov
+ *  
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy 
+ *  of this software and associated documentation files (the "Software"), to deal 
+ *  in the Software without restriction, including without limitation the rights 
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ *  copies of the Software, and to permit persons to whom the Software is 
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be included in 
+ *  all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+ *  THE SOFTWARE. 
+ */
+
+using System;
+using System.Security;
+
+namespace Alphaleonis.Win32.Filesystem
+{
+   public static partial class Directory
+   {
+      /// <summary>[AlphaFS] Gets the date and time, in coordinated universal time (UTC) time, that the specified directory was last written to.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last written to. This value is expressed in local time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory for which to obtain write date and time information.</param>
+      [SecurityCritical]
+      public static DateTime GetLastWriteTimeUtcTransacted(KernelTransaction transaction, string path)
+      {
+         return File.GetLastWriteTimeCore(transaction, path, true, PathFormat.RelativePath);
+      }
+
+
+      /// <summary>[AlphaFS] Gets the date and time, in coordinated universal time (UTC) time, that the specified directory was last written to.</summary>
+      /// <returns>A <see cref="DateTime"/> structure set to the date and time that the specified directory was last written to. This value is expressed in local time.</returns>
+      /// <param name="transaction">The transaction.</param>
+      /// <param name="path">The directory for which to obtain write date and time information.</param>
+      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
+      [SecurityCritical]
+      public static DateTime GetLastWriteTimeUtcTransacted(KernelTransaction transaction, string path, PathFormat pathFormat)
+      {
+         return File.GetLastWriteTimeCore(transaction, path, true, pathFormat);
+      }
+   }
+}