2018-10-27 12:28:24 +02:00
//#region Disclaimer / License
//// Copyright (C) 2015, The Duplicati Team
//// http://www.duplicati.com, info@duplicati.com
////
//// This library is free software; you can redistribute it and/or
//// modify it under the terms of the GNU Lesser General Public
//// License as published by the Free Software Foundation; either
//// version 2.1 of the License, or (at your option) any later version.
////
//// This library is distributed in the hope that it will be useful,
//// but WITHOUT ANY WARRANTY; without even the implied warranty of
//// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
//// Lesser General Public License for more details.
////
//// You should have received a copy of the GNU Lesser General Public
//// License along with this library; if not, write to the Free Software
//// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
////
//using System.Security.AccessControl;
//#endregion
//using System;
//using System.Text;
//using System.Runtime.InteropServices;
//using System.ComponentModel;
//using Microsoft.Win32.SafeHandles;
//namespace Duplicati.Library.IO
//{
// /// <summary>
// /// This class contains various Windows system calls related to reading locked files.
// /// Some PInvoke signatures are from http://www.pinvoke.net
// /// </summary>
// public static class WinNativeMethods
// {
// [Flags]
// private enum FileAccess : uint
// {
// GenericNone = 0x00000000,
// GenericRead = 0x80000000,
// GenericWrite = 0x40000000,
// GenericExecute = 0x20000000,
// GenericAll = 0x10000000,
// ReadControl = 0x00020000
// }
// [Flags]
// private enum FileShare : uint
// {
// None = 0x00000000,
// Read = 0x00000001,
// Write = 0x00000002,
// ReadWrite = 0x00000003,
// Delete = 0x00000004
// }
// private enum CreationDisposition : uint
// {
// New = 1,
// CreateAlways = 2,
// OpenExisting = 3,
// OpenAlways = 4,
// TruncateExisting = 5
// }
// [Flags]
// private enum FileAttributes : uint
// {
// Readonly = 0x00000001,
// Hidden = 0x00000002,
// System = 0x00000004,
// Directory = 0x00000010,
// Archive = 0x00000020,
// Device = 0x00000040,
// Normal = 0x00000080,
// Temporary = 0x00000100,
// SparseFile = 0x00000200,
// ReparsePoint = 0x00000400,
// Compressed = 0x00000800,
// Offline = 0x00001000,
// NotContentIndexed = 0x00002000,
// Encrypted = 0x00004000,
// Write_Through = 0x80000000,
// Overlapped = 0x40000000,
// NoBuffering = 0x20000000,
// RandomAccess = 0x10000000,
// SequentialScan = 0x08000000,
// DeleteOnClose = 0x04000000,
// BackupSemantics = 0x02000000,
// PosixSemantics = 0x01000000,
// OpenReparsePoint = 0x00200000,
// OpenNoRecall = 0x00100000,
// FirstPipeInstance = 0x00080000
// }
// private const int TOKEN_ADJUST_PRIVILEGES = 0x00000020;
// private const int TOKEN_QUERY = 0x00000008;
// private const int SE_PRIVILEGE_ENABLED = 0x00000002;
// private const string SE_BACKUP_NAME = "SeBackupPrivilege";
// private const string SE_RESTORE_NAME = "SeRestorePrivilege";
// private const int TOKEN_INFORMATION_CLASS_PRIVILEGES = 0x3;
// private const int ATTRIBUTE_FIXED_SIZE = 200;
// [StructLayout(LayoutKind.Sequential)]
// private struct LUID
// {
// public UInt32 LowPart;
// public Int32 HighPart;
// }
// [StructLayout(LayoutKind.Sequential)]
// private struct LUID_AND_ATTRIBUTES
// {
// public LUID Luid;
// public UInt32 Attributes;
// }
// [StructLayout(LayoutKind.Sequential)]
// private struct TOKEN_PRIVILEGES
// {
// public UInt32 PrivilegeCount;
// [MarshalAs(UnmanagedType.ByValArray, SizeConst = ATTRIBUTE_FIXED_SIZE)] //We make sure there is enough room
// public LUID_AND_ATTRIBUTES[] Privileges;
// }
// [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
// private static extern int OpenProcessToken(int ProcessHandle, int DesiredAccess, ref int tokenhandle);
// [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
// private static extern int GetCurrentProcess();
// [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
// private static extern int GetTokenInformation(int tokenhandle, int tokeninformationclass, [MarshalAs(UnmanagedType.Struct)]ref TOKEN_PRIVILEGES state, int bufferlength, ref int actualsize);
// [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
// private static extern int LookupPrivilegeValue(string lpsystemname, string lpname, [MarshalAs(UnmanagedType.Struct)] ref LUID lpLuid);
// [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
// private static extern int AdjustTokenPrivileges(int tokenhandle, bool disableprivs, [MarshalAs(UnmanagedType.Struct)]ref TOKEN_PRIVILEGES newState, int bufferlength, [MarshalAs(UnmanagedType.Struct)]ref TOKEN_PRIVILEGES previousState, ref int actualsize);
// [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
// private static extern int LookupPrivilegeName(string lpSystemName, [MarshalAs(UnmanagedType.Struct)] ref LUID lpLuid, System.Text.StringBuilder lpName, ref int cchName);
// [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
// private static extern SafeFileHandle CreateFile(
// string lpFileName,
// FileAccess dwDesiredAccess,
// FileShare dwShareMode,
// IntPtr lpSecurityAttributes,
// CreationDisposition dwCreationDisposition,
// FileAttributes dwFlagsAndAttributes,
// IntPtr hTemplateFile
// );
// /// <summary>
// /// Opens a file with backup semantics, only works if the caller has the SeBackupPrivilege
// /// </summary>
// /// <param name="filename">The file to open</param>
// /// <returns>The opened backup filestream</returns>
// public static System.IO.Stream OpenAsBackupFile(string filename)
// {
// var hFile = CreateFile(filename, FileAccess.ReadControl, FileShare.None, IntPtr.Zero, CreationDisposition.OpenExisting, FileAttributes.BackupSemantics | FileAttributes.SequentialScan, IntPtr.Zero);
// if (hFile.IsInvalid)
// throw new Win32Exception(Marshal.GetLastWin32Error());
// //TODO: We need to be able to seek to pos 0
// return new Alphaleonis.Win32.Filesystem.BackupFileStream(hFile, FileSystemRights.Read);
// }
// /// <summary>
// /// Internal helper function that returns two values relating to the SeBackupPrivilege
// /// </summary>
// /// <param name="hasPrivilege">True if the calling proccess has the SeBackupPrivilege, false otherwise</param>
// /// <param name="isEnabled">True if the SeBackupPrivilege is enabled, false otherwise</param>
// private static void GetBackupPrivilege(out bool hasPrivilege, out bool isEnabled)
// {
// int token = 0;
// int outsize = 0;
// TOKEN_PRIVILEGES TP = new TOKEN_PRIVILEGES();
// LUID backupLuid = new LUID();
// if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, ref token) == 0)
// throw new Win32Exception(Marshal.GetLastWin32Error());
// if (LookupPrivilegeValue(null, SE_BACKUP_NAME, ref backupLuid) == 0)
// throw new Win32Exception(Marshal.GetLastWin32Error());
// if (GetTokenInformation(token, TOKEN_INFORMATION_CLASS_PRIVILEGES, ref TP, Marshal.SizeOf(typeof(TOKEN_PRIVILEGES)), ref outsize) == 0)
// throw new Win32Exception(Marshal.GetLastWin32Error());
//#if DEBUG
// Console.WriteLine("Read token information:");
// PrintTokenInformation(TP);
//#endif
// for (int i = 0; i < TP.PrivilegeCount; i++)
// if (TP.Privileges[i].Luid.LowPart == backupLuid.LowPart && TP.Privileges[i].Luid.HighPart == backupLuid.HighPart)
// {
// isEnabled = (TP.Privileges[i].Attributes & SE_PRIVILEGE_ENABLED) == SE_PRIVILEGE_ENABLED;
// hasPrivilege = true;
// return;
// }
// hasPrivilege = false;
// isEnabled = false;
// }
// /// <summary>
// /// Gets a value indicating if the current process can set the SeBackupPrivilege value
// /// </summary>
// public static bool CanEnableBackupPrivilege
// {
// get
// {
// bool hasPrivilege, isEnabled;
// GetBackupPrivilege(out hasPrivilege, out isEnabled);
// return hasPrivilege;
// }
// }
// /// <summary>
// /// Gets or sets a value indicating if the current process has the backup privilege (SE_BACKUP_NAME)
// /// </summary>
// public static bool BackupPrivilege
// {
// get
// {
// bool hasPrivilege, isEnabled;
// GetBackupPrivilege(out hasPrivilege, out isEnabled);
// //if (!hasPrivilege)
// //throw new Duplicati.Library.Interface.UserInformationException(Strings.WinNativeMethod.MissingBackupPrivilegeError, "MissingBackupPrivilege");
// return isEnabled;
// }
// set
// {
// //if (!CanEnableBackupPrivilege)
// //throw new Duplicati.Library.Interface.UserInformationException(Strings.WinNativeMethod.MissingBackupPrivilegeError, "MissingBackupPrivilege");
// int token = 0;
// int outsize = 0;
// TOKEN_PRIVILEGES TP = new TOKEN_PRIVILEGES();
// LUID backupLuid = new LUID();
// LUID restoreLuid = new LUID();
// if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, ref token) == 0)
// throw new Win32Exception(Marshal.GetLastWin32Error());
// if (LookupPrivilegeValue(null, SE_BACKUP_NAME, ref backupLuid) == 0)
// throw new Win32Exception(Marshal.GetLastWin32Error());
// if (LookupPrivilegeValue(null, SE_RESTORE_NAME, ref restoreLuid) == 0)
// throw new Win32Exception(Marshal.GetLastWin32Error());
// TP.PrivilegeCount = 1;
// TP.Privileges = new LUID_AND_ATTRIBUTES[ATTRIBUTE_FIXED_SIZE];
// TP.Privileges[0].Attributes = value ? SE_PRIVILEGE_ENABLED : 0u;
// TP.Privileges[0].Luid = backupLuid;
// TP.Privileges[1].Attributes = value ? SE_PRIVILEGE_ENABLED : 0u;
// TP.Privileges[1].Luid = restoreLuid;
// TOKEN_PRIVILEGES TPOut = new TOKEN_PRIVILEGES();
// if (AdjustTokenPrivileges(token, false, ref TP, Marshal.SizeOf(typeof(TOKEN_PRIVILEGES)), ref TPOut, ref outsize) == 0)
// throw new Win32Exception(Marshal.GetLastWin32Error());
//#if DEBUG
// Console.WriteLine("Modified token information:");
// PrintTokenInformation(TPOut);
//#endif
// if (Marshal.GetLastWin32Error() != 0)
// throw new Win32Exception(Marshal.GetLastWin32Error());
// }
// }
//#if DEBUG
// private static void PrintTokenInformation(TOKEN_PRIVILEGES tp)
// {
// int outsize;
// StringBuilder sbname = new StringBuilder(1024 * 4);
// for (int i = 0; i < tp.PrivilegeCount; i++)
// {
// LUID id = tp.Privileges[i].Luid;
// outsize = sbname.Capacity;
// if (LookupPrivilegeName(null, ref id, sbname, ref outsize) == 0)
// Console.WriteLine("Invalid LUID {0}:{1}: {2}", id.HighPart, id.LowPart, new Win32Exception(Marshal.GetLastWin32Error()).Message);
// else
// Console.WriteLine("{0}, status {1}", sbname, tp.Privileges[i].Attributes);
// }
// }
//#endif
// }
//}
