/// <summary> /// Impersonates the identity specified by <see cref="ApplicationIdentity"/>. /// </summary> public static System.Security.Principal.WindowsImpersonationContext Impersonate() { System.Security.Principal.WindowsPrincipal newPrin = new System.Security.Principal.WindowsPrincipal(ApplicationIdentity); System.Threading.Thread.CurrentPrincipal = newPrin; return ApplicationIdentity.Impersonate(); }
private static bool IsRunAsAdmin() { var wi = System.Security.Principal.WindowsIdentity.GetCurrent(); var wp = new System.Security.Principal.WindowsPrincipal(wi); return wp.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator); }
/// <summary> /// 以管理员身份重启本程序,成功或已有管理员权限,返回True /// </summary> /// <param name="Argument">启动参数,默认为空字符串</param> /// <param name="ShouldExit">指示调用进程是否应当退出</param> /// <returns>若已有管理员权限,返回True,若用户拒绝提权,返回false</returns> public static bool RunAsAdministrator(string Argument = "", bool ShouldExit = true) { uc_timer.ShouldPauseTopMost = true; System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); if (!principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { bool Canceled = false; ProcessStartInfo startInfo = new ProcessStartInfo(); startInfo.FileName = Application.ExecutablePath; startInfo.Verb = "runas"; startInfo.Arguments = Argument; try { Process.Start(startInfo); } catch (Exception) { Canceled = true; } if (Canceled == false) { if (ShouldExit) Application.Exit(); else return true; } } else return true; return false; }
public static bool IsAdmin() { System.Security.Principal.WindowsIdentity id = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal p = new System.Security.Principal.WindowsPrincipal(id); return p.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator); }
static void Main(string[] args) { /** * 当前用户是管理员的时候,直接启动应用程序 * 如果不是管理员,则使用启动对象启动程序,以确保使用管理员身份运行 */ //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //判断当前登录用户是否为管理员 //如果不是管理员,则以管理员方式运行 if (!principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //创建启动对象 System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); startInfo.UseShellExecute = true; startInfo.WorkingDirectory = Environment.CurrentDirectory; startInfo.FileName = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName; //设置启动动作,确保以管理员身份运行 startInfo.Verb = "runas"; try { System.Diagnostics.Process.Start(startInfo); } catch (Exception ex) { throw ex; } System.Environment.Exit(0); } Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new FrmMain(args)); }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); bool isFirstInstance; /** * 当前用户是管理员的时候,直接启动应用程序 * 如果不是管理员,则使用启动对象启动程序,以确保使用管理员身份运行 */ //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //判断当前登录用户是否为管理员 if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { // Please use a unique name for the mutex to prevent conflicts with other programs using (Mutex mtx = new Mutex(true, "Notify", out isFirstInstance)) { if (isFirstInstance) { //如果是管理员,则直接运行 Application.Run(new Form1()); } else { LogBuilder.buildLog("Already Running!"); //MessageBox.Show("Already Running!"); Application.Exit(); } } // releases the Mutex } else { //创建启动对象 System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); startInfo.UseShellExecute = true; startInfo.WorkingDirectory = Environment.CurrentDirectory; startInfo.FileName = Application.ExecutablePath; //设置启动动作,确保以管理员身份运行 startInfo.Verb = "runas"; try { System.Diagnostics.Process.Start(startInfo); } catch { return; } //退出 Application.Exit(); //Application.Run(new S2_0()); } }
private static bool IsElevated() { System.Security.Principal.WindowsIdentity currentIdentity = System.Security.Principal.WindowsIdentity.GetCurrent(); if (currentIdentity == null) return false; System.Security.Principal.WindowsPrincipal pricipal = new System.Security.Principal.WindowsPrincipal(currentIdentity); return pricipal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator); }
static void Main(string[] args) { #region Check if program is running as admin. System.Security.Principal.WindowsPrincipal user = new System.Security.Principal.WindowsPrincipal(System.Security.Principal.WindowsIdentity.GetCurrent()); if (user.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator) != true) { int exitCode = 1; System.Windows.Forms.MessageBox.Show("You do not have administrative priviledges and cannot install this program."); Environment.Exit(exitCode); } #endregion #region Check if the resources have been set. if (Resources.logmeinDeployID == "" || Resources.spiceworksAuthKey == "" || Resources.spiceworksServer == "" || Resources.spiceworksPort == "" || Resources.spiceworksSiteName == "") { int exitCode = 1; System.Windows.Forms.MessageBox.Show("Resources have not been set. Recompile."); Environment.Exit(exitCode); } #endregion #region Create SupportInstaller directory in the user's temp directory. var temp = Directory.CreateDirectory(Path.GetTempPath() + "SupportInstaller\\"); #endregion #region Extract installers. File.WriteAllBytes(temp.FullName + "logmein.msi", Support_Installer.Properties.Resources.logmein); File.WriteAllBytes(temp.FullName + "SpiceworksAgent.msi", Support_Installer.Properties.Resources.SpiceworksAgent); #endregion #region Run the LogMeIn and then the Spiceworks Agent installers and wait for them to exit. var logmein = Process.Start("msiexec.exe", "/i \"" + temp.FullName + "logmein.msi\" /quiet DEPLOYID=" + Resources.logmeinDeployID + " INSTALLMETHOD=5 FQDNDESC=0 /lp \"" + temp.FullName + "LogMeInLog.log\""); logmein.WaitForExit(); var spiceworks = Process.Start("msiexec.exe", "/i \"" + temp.FullName + "SpiceworksAgent.msi\" SPICEWORKS_SERVER=\"" + Resources.spiceworksServer + "\" SPICEWORKS_AUTH_KEY=\"" + Resources.spiceworksAuthKey + "\" SPICEWORKS_PORT=" + Resources.spiceworksPort + " SPICEWORKS_SITE_LABEL=\"" + Resources.spiceworksSiteName + "\" ADDLOCAL=FeatureService /qn /norestart /log \"" + temp.FullName + "SpiceworksAgentLog.log\""); spiceworks.WaitForExit(); #endregion #region Delete the installers. File.Delete(temp.FullName + "logmein.msi"); File.Delete(temp.FullName + "SpiceworksAgent.msi"); #endregion #region Set registry keys so LogMeIn does not show messages or tray icon. Registry.SetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\LogMeIn\\V5\\Appearance", "KioskMode", "1", RegistryValueKind.DWord); Registry.SetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\LogMeIn\\V5\\Appearance", "Language", "en", RegistryValueKind.String); Registry.SetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\LogMeIn\\V5\\Gui", "EnableSystray", "0", RegistryValueKind.DWord); #endregion #region Restart the LogMeIn process so the above settings take effect. Process LMIRestart = new Process(); LMIRestart.StartInfo.WindowStyle = ProcessWindowStyle.Hidden; LMIRestart.StartInfo.FileName = Registry.GetValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\LogMeIn", "InstallPath", "") + "\\x86\\LogMeIn.exe"; LMIRestart.StartInfo.Arguments = "restart"; LMIRestart.Start(); #endregion }
public static bool IsCurrentlyRunningAsAdmin() { var isAdmin = false; var currentIdentity = System.Security.Principal.WindowsIdentity.GetCurrent(); if (currentIdentity != null) { var pricipal = new System.Security.Principal.WindowsPrincipal(currentIdentity); isAdmin = pricipal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator); pricipal = null; } return isAdmin; }
static void Main() { //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainForm()); } }
//设置开机自动登录 public static void SetAutoRun(string fileName, bool isAutoRun) { System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); RegistryKey reg = null; try { if (!System.IO.File.Exists(fileName)) { throw new Exception("可执行文件不存在"); } string name = fileName.Substring(fileName.LastIndexOf(@"\") + 1); reg = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Run", true); //reg = reg.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true); if (reg == null) { reg = Registry.LocalMachine.CreateSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Run"); //Run = reg.CreateSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Run"); } if (isAutoRun) { reg.SetValue(name, fileName); } else { //reg.SetValue(name, false); //if (reg.GetValue(name) == null) //{ // return; //} reg.SetValue(name, false); } } catch (Exception ex) { throw new Exception(ex.ToString()); } finally { if (reg != null) { reg.Close(); } } }
static void Main(String[] Args) { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); /** * 当前用户是管理员的时候,直接启动应用程序 * 如果不是管理员,则使用启动对象启动程序,以确保使用管理员身份运行 */ //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //判断当前登录用户是否为管理员 if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //如果是管理员,则直接运行 Application.Run(new Form1(Args)); } else { //创建启动对象 //String str; //str = Args[0]; System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); startInfo.UseShellExecute = true; startInfo.WorkingDirectory = Environment.CurrentDirectory; startInfo.FileName = Application.ExecutablePath; startInfo.Arguments = Args[0]; //设置启动动作,确保以管理员身份运行 startInfo.Verb = "runas"; try { System.Diagnostics.Process.Start(startInfo); } catch { return; } //退出 Application.Exit(); //Application.Run(new Form1()); } }
static void Main(string[] Args) { try { //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); Application.SetCompatibleTextRenderingDefault(false); Process intance = RunningIntance(); //调用检查函数 System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //判断当前登录用户是否为管理员 if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //如果是管理员,则直接运行 Application.EnableVisualStyles(); if (intance == null) //不存在相同的程序 { Application.Run(new FormWIFI()); } else //存在相同的程序 { HandleRunningInstance(intance); } } else { //创建启动对象 System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); //设置运行文件 startInfo.FileName = System.Windows.Forms.Application.ExecutablePath; //设置启动参数 startInfo.Arguments = String.Join(" ", Args); //设置启动动作,确保以管理员身份运行 startInfo.Verb = "runas"; //如果不是管理员,则启动UAC System.Diagnostics.Process.Start(startInfo); //退出 System.Windows.Forms.Application.Exit(); } } catch { } }
static void Main(string[] Args) { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); /** * 当前用户是管理员的时候,直接启动应用程序 * 如果不是管理员,则使用启动对象启动程序,以确保使用管理员身份运行 */ //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); //创建Windows用户主题 Application.EnableVisualStyles(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //判断当前登录用户是否为管理员 if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //如果是管理员,则直接运行 Application.EnableVisualStyles(); const string dbPath = "./local.db"; //Application.Run(new LoginForm(dbPath)); Application.Run(new LoginForm(dbPath)); } else { //创建启动对象 System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); //设置运行文件 startInfo.FileName = System.Windows.Forms.Application.ExecutablePath; //设置启动参数 startInfo.Arguments = String.Join(" ", Args); //设置启动动作,确保以管理员身份运行 startInfo.Verb = "runas"; //如果不是管理员,则启动UAC System.Diagnostics.Process.Start(startInfo); //退出 System.Windows.Forms.Application.Exit(); } }
public Logger() { // Display System information StringBuilder systeminfo_sb = new StringBuilder(string.Empty); systeminfo_sb.Append("========================================\r\n"); try { var win_reg = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion"); string productName = (string)win_reg.GetValue("ProductName"); systeminfo_sb.AppendFormat("Operation System: {0}\r\n", productName); } catch (Exception exc) { systeminfo_sb.AppendFormat("Operation System: Could not retrieve. [Exception: {0}]\r\n", exc.Message); } systeminfo_sb.AppendFormat("System Architecture: " + (Environment.Is64BitOperatingSystem ? "64 bit" : "32 bit") + "\r\n"); systeminfo_sb.AppendFormat("Environment OS Version: {0}\r\n", Environment.OSVersion); systeminfo_sb.AppendFormat("System Directory: {0}\r\n", Environment.SystemDirectory); systeminfo_sb.AppendFormat("Processor Count: {0}\r\n", Environment.ProcessorCount); systeminfo_sb.AppendFormat("User DomainName: {0}\r\n", Environment.UserDomainName); systeminfo_sb.AppendFormat("User Name: {0}\r\n", Environment.UserName); systeminfo_sb.AppendFormat("SystemPageSize: {0}\r\n", Environment.SystemPageSize); systeminfo_sb.AppendFormat("Environment Version: {0}\r\n", Environment.Version); System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); systeminfo_sb.AppendFormat("Is Elevated: {0}\r\n", principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)); systeminfo_sb.AppendFormat("Aurora Assembly Version: {0}\r\n", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version); systeminfo_sb.AppendFormat("Aurora File Version: {0}\r\n", System.Diagnostics.FileVersionInfo.GetVersionInfo(System.Reflection.Assembly.GetExecutingAssembly().Location).FileVersion); systeminfo_sb.Append("========================================\r\n"); LogLine(systeminfo_sb.ToString(), Logging_Level.None, false); }
public Sandbox() { System.Security.Principal.WindowsPrincipal wp = new System.Security.Principal.WindowsPrincipal(System.Security.Principal.WindowsIdentity.GetCurrent()); CheckProcess proc = new CheckProcess(); if ((Util.GetModuleHandle("SbieDll.dll").ToInt32() != 0) || (proc.IsProcessRunning("npfmsg")) || (Microsoft.Win32.Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\", false) .GetValue("ProductID").ToString() == "76487-640-1457236-23837") || (System.Windows.Forms.Application.StartupPath == "C:\\analyzer\\scan") || (proc.IsProcessRunning("joeboxserver")) || (proc.IsProcessRunning("joeboxcontrol")) || (wp.Identity.Name == "HANS\\Hanuele Baser") || (wp.Identity.Name == "Sepp-PC\\Sepp") || (wp.Identity.Name == "John-PC\\John")) { new AntiFound(); } //System.GC.Collect(); }
static public bool IsUserAdministrator() { bool isAdmin; try { System.Security.Principal.WindowsIdentity user = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(user); isAdmin = principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator); } catch (UnauthorizedAccessException) { isAdmin = false; } catch (Exception) { isAdmin = false; } return(isAdmin); }
public static string GetStaffId() { string domain = Environment.UserDomainName; //string domain = IPGlobalProperties.GetIPGlobalProperties().DomainName; string loginName = new System.Security.Principal.WindowsPrincipal(System.Security.Principal.WindowsIdentity.GetCurrent()).Identity.Name; string username = loginName.Substring(loginName.IndexOf('\\') + 1); DirectoryEntry domainEntry = new DirectoryEntry("LDAP://" + domain); DirectorySearcher searcher = new DirectorySearcher(domainEntry); searcher.Filter = "(&(objectClass=user)(sAMAccountName=" + username + "))"; SearchResult result = searcher.FindOne(); DirectoryEntry entry = result.GetDirectoryEntry(); string account = entry.Properties["sAMAccountName"].Value.ToString(); return(account); }
public static bool IsDomainAdmin(IntPtr p_token) { var DomainName = GetDomainName(); if (string.IsNullOrEmpty(DomainName)) { return(false); } var d = System.DirectoryServices.ActiveDirectory.Domain.GetDomain(new System.DirectoryServices.ActiveDirectory.DirectoryContext(System.DirectoryServices.ActiveDirectory.DirectoryContextType.Domain, DomainName)); var de = d.GetDirectoryEntry(); byte[] domainSidArray = de.Properties["objectSid"].Value as byte[]; var domainSid = new System.Security.Principal.SecurityIdentifier(domainSidArray, 0); var domainAdminsSid = new System.Security.Principal.SecurityIdentifier(System.Security.Principal.WellKnownSidType.AccountDomainAdminsSid, domainSid); var wi = new System.Security.Principal.WindowsIdentity(p_token); var wp = new System.Security.Principal.WindowsPrincipal(wi); return(wp.IsInRole(domainAdminsSid)); }
static void Main(params string[] Args) { System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainForm()); } else { System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); startInfo.FileName = System.Windows.Forms.Application.ExecutablePath; // 获取当前可执行文件的路径及文件名 //以下 Args 为启动本程序的对应的参数 startInfo.Arguments = String.Join(" ", Args); startInfo.Verb = "runas"; System.Diagnostics.Process.Start(startInfo); } }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); /** * 当前用户是管理员的时候,直接启动应用程序 * 如果不是管理员,则使用启动对象启动程序,以确保使用管理员身份运行 */ //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //判断当前登录用户是否为管理员 if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //如果是管理员,则直接运行 Application.Run(new Form1()); } else { MessageBox.Show("为了设置启动项,此程序必须以管理员权限运行。", "需要管理员权限", MessageBoxButtons.OK, MessageBoxIcon.Information); //创建启动对象 System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); //设置运行文件 startInfo.FileName = Application.ExecutablePath; //设置启动参数 //startInfo.Arguments = String.Join(" ", Args); //设置启动动作,确保以管理员身份运行 startInfo.Verb = "runas"; try { //如果不是管理员,则启动UAC System.Diagnostics.Process.Start(startInfo); //退出 Application.Exit(); } catch { } } }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); #if DEBUG Application.Run(new FormMain()); #else //当前用户是管理员的时候,直接启动应用程序 //如果不是管理员,则使用启动对象启动程序,以确保使用管理员身份运行 //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //判断当前登录用户是否为管理员 if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //如果是管理员,则直接运行 Application.Run(new FormMain()); } else { //创建启动对象 System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); startInfo.UseShellExecute = true; startInfo.WorkingDirectory = Environment.CurrentDirectory; startInfo.FileName = Application.ExecutablePath; //设置启动动作,确保以管理员身份运行 startInfo.Verb = "runas"; try { System.Diagnostics.Process.Start(startInfo); } catch { return; } //退出 Application.Exit(); } #endif }
/// <summary> /// Zum Test der Authorisierung ist soll der Zugriff auf folgende Methode nur für /// "Testgruppe" möglich sein. /// </summary> /// <returns></returns> //[System.Security.Permissions.PrincipalPermission(System.Security.Permissions.SecurityAction.Demand, Role="Testgruppe")] public List <Filedescriptor> GetAllFileDescriptors_AdminsOnly() { var lst = new List <Filedescriptor>(); var principal = new System.Security.Principal.WindowsPrincipal(ServiceSecurityContext.Current.WindowsIdentity); Debug.WriteLine("Operation wird ausgeführt als: " + System.Security.Principal.WindowsIdentity.GetCurrent().Name); Debug.WriteLine("Operation wurde aufgerufen von: " + ServiceSecurityContext.Current.WindowsIdentity.Name); //Debug.Assert(principal.IsInRole(Gruppe), "Benutzer sollte zu Gruppe der Administratoren gehören, um diese Operation aufzurufen- er tut es aber nicht!"); var perm = new System.Security.Permissions.PrincipalPermission(principal.Identity.Name, Gruppe); //perm.Demand(); foreach (var file in Directory.GetFiles(_root)) { lst.Add(GetFileDescriptor(Path.GetFileName(file))); } return(lst); }
/// <summary> /// Checks to see if the current user is an administrator. /// </summary> /// <returns>True, if the user is an administrator.</returns> public static bool IsUserAdministrator() { bool isAdmin; try { System.Security.Principal.WindowsIdentity user = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(user); isAdmin = principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator); } catch (System.Security.SecurityException) { isAdmin = false; } catch (System.UnauthorizedAccessException) { isAdmin = false; } return isAdmin; }
protected void Application_Start() { var testGroup = Environment.GetEnvironmentVariable("TEST_GROUP") ?? "WebUsers"; var identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Diagnostics.Debug.WriteLine("Identity is " + identity.Name); var principal = new System.Security.Principal.WindowsPrincipal(identity); System.Diagnostics.Debug.WriteLine("Principal " + principal.Identity.Name + " is in role: " + principal.IsInRole(testGroup)); if (!principal.IsInRole(testGroup)) { throw new UnauthorizedAccessException("Access is denied."); } AreaRegistration.RegisterAllAreas(); GlobalConfiguration.Configure(WebApiConfig.Register); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); }
static void Main(string[] args) { if (args.Length == 1 && args[0] == "--admin") { string currentPath = "\"" + Path.Combine(System.Environment.CurrentDirectory, "Wallpaper_Assistant.exe") + "\""; RegistryKey rk = Registry.LocalMachine; RegistryKey rk2 = rk.CreateSubKey(@"Software\Microsoft\Windows\CurrentVersion\Run"); rk2.SetValue("WallpaperAssistant", currentPath); rk2.Close(); rk.Close(); } else { System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { ProcessStartInfo startInfo = new ProcessStartInfo { WorkingDirectory = System.Environment.CurrentDirectory, FileName = Process.GetCurrentProcess().MainModule.FileName, Arguments = "--admin" }; Process.Start(startInfo); } else { ProcessStartInfo startInfo = new ProcessStartInfo { UseShellExecute = true, WorkingDirectory = System.Environment.CurrentDirectory, FileName = Process.GetCurrentProcess().MainModule.FileName, Arguments = "--admin", Verb = "runas" }; Process.Start(startInfo); } Environment.Exit(0); } }
static void Main() { #if DEBUG Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new FormService()); #else //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); //创建Windows用户主题 Application.EnableVisualStyles(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); #region 必须以管理员权限运行 //判断当前登录用户是否为管理员 if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { Application.SetCompatibleTextRenderingDefault(false); AutoRun();//设置开机自启动 Application.Run(new FormService()); } else { //创建启动对象 System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); //设置运行文件 startInfo.FileName = System.Windows.Forms.Application.ExecutablePath; //设置启动参数 //startInfo.Arguments = String.Join(" ", Args); //设置启动动作,确保以管理员身份运行 startInfo.Verb = "runas"; //如果不是管理员,则启动UAC System.Diagnostics.Process.Start(startInfo); AutoRun();//设置开机自启动 //退出 Application.Exit(); } #endregion 必须以管理员权限运行 #endif }
static void Main(string[] Args) { /** * 当前用户是管理员的时候,直接启动应用程序 * 如果不是管理员,则使用启动对象启动程序,以确保使用管理员身份运行 */ //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); //创建Windows用户主题 Application.EnableVisualStyles(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //判断当前登录用户是否为管理员 if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //如果是管理员,则直接运行 Application.EnableVisualStyles(); Application.Run(new CMD()); } else { try //在选择是否使用管理员登陆时 如果用户点击否代码[System.Diagnostics.Process.Start(startInfo);]异常 { //创建启动对象 System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); //设置运行文件 startInfo.FileName = System.Windows.Forms.Application.ExecutablePath; //设置启动参数 startInfo.Arguments = String.Join(" ", Args); //设置启动动作,确保以管理员身份运行 startInfo.Verb = "runas"; //如果不是管理员,则启动UAC System.Diagnostics.Process.Start(startInfo); //退出 System.Windows.Forms.Application.Exit(); } catch { } } }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); /** * The user is the administrator of time, direct start application * If not the administrator, use the startup object start program, using run as administrator to ensure */ //Get the current logged on user labeled Windows System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //Judge whether the currently logged in user. if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //If the administrator, is directly run Application.Run(new OpenForensics()); } else { //Create a startup object System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); startInfo.UseShellExecute = true; startInfo.WorkingDirectory = Environment.CurrentDirectory; startInfo.FileName = Application.ExecutablePath; //Set the start action, make sure to run as Administrator startInfo.Verb = "runas"; try { System.Diagnostics.Process.Start(startInfo); } catch { return; } //Sign out Application.Exit(); } }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); //get admin privalages System.Security.Principal.WindowsPrincipal pricipal = new System.Security.Principal.WindowsPrincipal(System.Security.Principal.WindowsIdentity.GetCurrent()); bool hasAdministrativeRight = pricipal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator); if (!hasAdministrativeRight) { RunElevated(Application.ExecutablePath); //this.Close(); Application.Exit(); } else { //we have admin privalages Application.Run(new BackTrack()); } }
static void Main(string[] Args) { #if DEBUG Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainDialog()); #else /** * 当前用户是管理员的时候,直接启动应用程序 * 如果不是管理员,则使用启动对象启动程序,以确保使用管理员身份运行 */ //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); Application.EnableVisualStyles(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //判断当前登录用户是否为管理员 if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainDialog()); } else { //创建启动对象 System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); //设置运行文件 startInfo.FileName = System.Windows.Forms.Application.ExecutablePath; //设置启动参数 startInfo.Arguments = String.Join(" ", Args); //设置启动动作,确保以管理员身份运行 startInfo.Verb = "runas"; //如果不是管理员,则启动UAC System.Diagnostics.Process.Start(startInfo); //退出 System.Windows.Forms.Application.Exit(); } #endif }
private void btnSync_Click(object sender, EventArgs e) { string Name = new System.Security.Principal.WindowsPrincipal(System.Security.Principal.WindowsIdentity.GetCurrent()).Identity.Name; string Name1 = System.Security.Principal.WindowsIdentity.GetCurrent().Name; string Name2 = System.DirectoryServices.AccountManagement.UserPrincipal.Current.UserPrincipalName; using (var context = new PrincipalContext(ContextType.Domain, "tenf.loc")) { using (var searcher = new PrincipalSearcher(new UserPrincipal(context))) { foreach (var result in searcher.FindAll()) { DirectoryEntry de = result.GetUnderlyingObject() as DirectoryEntry; Console.WriteLine("First Name: " + de.Properties["givenName"].Value); Console.WriteLine("Last Name : " + de.Properties["sn"].Value); Console.WriteLine("SAM account name : " + de.Properties["samAccountName"].Value); Console.WriteLine("User principal name: " + de.Properties["userPrincipalName"].Value); Console.WriteLine(); } } } }
/// <summary> /// 确定当前主体是否属于具有指定 Administrator 的 Windows 用户组 /// </summary> /// <returns>如果当前主体是指定的 Administrator 用户组的成员,则为 true;否则为 false。</returns> public bool IsAdministrator() { bool result; try { System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); result = principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator); //http://www.cnblogs.com/Interkey/p/RunAsAdmin.html //AppDomain domain = Thread.GetDomain(); //domain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal); //WindowsPrincipal windowsPrincipal = (WindowsPrincipal)Thread.CurrentPrincipal; //result = windowsPrincipal.IsInRole(WindowsBuiltInRole.Administrator); } catch { result = false; } return(result); }
/// <summary> /// 判斷當前用戶是否是管理員 /// </summary> /// <returns>返回Boolean值</returns> public static bool IsCurrentUserAdmin() { try { AppDomain domain = System.Threading.Thread.GetDomain(); domain.SetPrincipalPolicy(System.Security.Principal.PrincipalPolicy.WindowsPrincipal); System.Security.Principal.WindowsPrincipal principal = (System.Security.Principal.WindowsPrincipal)System.Threading.Thread.CurrentPrincipal; bool user = principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator); if (user) { return(true); } else { return(false); } } catch { return(false); } }
public static bool IsUserAdministrator() { //bool value to hold our return value bool isAdmin; try { //get the currently logged in user System.Security.Principal.WindowsIdentity user = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(user); isAdmin = principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator); } catch (System.UnauthorizedAccessException) { isAdmin = false; } catch (System.Exception) { isAdmin = false; } return(isAdmin); }
static void Main(string[] args) { if (args.Length != 2) { return; } System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); Application.EnableVisualStyles(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //Application.EnableVisualStyles(); //Application.Run(new UpdateBackground()); //UpdateBackground updater = new UpdateBackground(); Update update = new Update(args[0], args[1]); System.Windows.Forms.Application.Exit(); } else { try { System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); startInfo.FileName = System.Windows.Forms.Application.ExecutablePath; startInfo.Verb = "runas"; startInfo.Arguments = "-force"; System.Diagnostics.Process.Start(startInfo); } catch (Exception ex) { MessageBox.Show(ex.Message); } finally { System.Windows.Forms.Application.Exit(); } } }
// Throw error messages if any required files are missing due to user error private static bool CheckRequiredFiles() { bool success = true; Action <string> error = (string input) => { Console.WriteLine(pre + "Missing File: {0}", input); }; // Check privilege bool IsAdmin = new System.Security.Principal.WindowsPrincipal(System.Security.Principal.WindowsIdentity.GetCurrent()).IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator); if (!IsAdmin) { Console.WriteLine(pre + "This program needs to be run as an administrator to be able to host the HTTP and Pipes servers responsible for its operation. Please relaunch as an administrator."); success = false; } // Check files if (!File.Exists(CgSDKHandlerDir)) { error("CgSDK Handler program"); success = false; } if (!File.Exists("./CgSDK.x64_2015.dll")) { error("CgSDK library"); success = false; } if (!File.Exists("./CgSDK_Interop.dll")) { error("CgSDK Interoperability library"); success = false; } if (!File.Exists("./Newtonsoft.Json.dll")) { error("Newtonsoft JSON library"); success = false; } return(success); }
private void 右键修复ToolStripMenuItem_Click(object sender, EventArgs e) { System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //var exePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, AppDomain.CurrentDomain.FriendlyName); var exePath = Application.ExecutablePath; #region 注册鼠标右键 using (RegistryKey classesroot = Registry.ClassesRoot) { using (RegistryKey star = classesroot.OpenSubKey("*")) { using (RegistryKey Shell = star.OpenSubKey("Shell", true)) { using (RegistryKey TODO = Shell.CreateSubKey("TODO")) { using (RegistryKey command = TODO.CreateSubKey("Command")) { command.SetValue(null, string.Format("{0} %1", exePath)); command.Close(); } TODO.Close(); } Shell.Close(); } star.Close(); } classesroot.Close(); } #endregion } else { MessageBox.Show("右键上传文件修复需要管理员权限,请用管理员权限运行本程序修复"); return; } }
static void Main() { Boolean createdNew; //返回是否赋予了使用线程的互斥体初始所属权 System.Threading.Mutex instance = new System.Threading.Mutex(true, wapp.SysConfig.SystemName, out createdNew); //同步基元变量 //赋予了线程初始所属权,也就是首次使用互斥体 if (!createdNew) { return; } //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //判断当前登录用户是否为管理员 if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //如果是管理员,则直接运行 Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); wapp.SysConfig.NewSysConfig(); FormLogin fmLogin = new FormLogin(); Application.Run(fmLogin); instance.ReleaseMutex(); } else { //创建启动对象 System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); //设置运行文件 startInfo.FileName = System.Windows.Forms.Application.ExecutablePath; //设置启动动作,确保以管理员身份运行 startInfo.Verb = "runas"; //如果不是管理员,则启动UAC System.Diagnostics.Process.Start(startInfo); //退出 System.Windows.Forms.Application.Exit(); } }
public static void AssertAdministratorPrivileges() { //http://stackoverflow.com/questions/1089046/in-net-c-test-if-process-has-administrative-privileges //bool value to hold our return value bool isAdmin; try { //get the currently logged in user var user = System.Security.Principal.WindowsIdentity.GetCurrent(); var principal = new System.Security.Principal.WindowsPrincipal(user); isAdmin = principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator); } catch (Exception) { isAdmin = false; } if (!isAdmin) { throw new Exception("You will need to run the tests with Administrator Privileges"); } }
//make sure that the user has the role public bool isAutorized(String roles) { bool isAutorized = false; string[] tab = roles.Split(';'); foreach (var role in tab) { try { bool UserIsInGroup = new System.Security.Principal.WindowsPrincipal(new System.Security.Principal.WindowsIdentity(Environment.UserName)).IsInRole(role); if (UserIsInGroup) { isAutorized = true; break; } } catch (System.Exception ex) { } } return(isAutorized); }
/// <summary> /// Checks to see if the currently running instance of the sprite editor /// is associated with the .scn file extension. /// </summary> /// <remarks>Currently only attempts to check/associate if the currently /// logged in user is a windows administrator. Have not fully /// investigated whether you really need unrestricted access to the registry /// to create/edit the required registry keys (in HKEY_CLASSES_ROOT), or /// if there is a way to do the association as a limited user. In /// the mean time, we will err on the side of caution.</remarks> static void VerifyScnRegistry() { System.Security.Principal.WindowsIdentity winIdent = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal winPrincipal = new System.Security.Principal.WindowsPrincipal(winIdent); if (winPrincipal.IsInRole( System.Security.Principal.WindowsBuiltInRole.Administrator)) { FileAssociationHelper file = new FileAssociationHelper(".scn"); if (!file.IsOpener || !file.IsEditor) { DialogResult res = System.Windows.Forms.MessageBox.Show( "This application is currently not associated with the .scn file extension.\n\nWould you like it to be?", "File Association", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1); if (res == DialogResult.Yes) { file.Associate(); } } } }
private void InitWifiState() { bool result = WifiOperator.WifiStateQuery(); if (result) { IsWifiOpened = true; Message = "Wifi已启动"; } else { IsWifiOpened = false; Message = "Wifi未启动"; } System.Security.Principal.WindowsIdentity wid = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal printcipal = new System.Security.Principal.WindowsPrincipal(wid); IsAdmin = (printcipal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)); if (!IsAdmin) { Message = "请用管理员权限运行"; } }
public MainWindow() { DataContext = new MainWindowModel(); var pricipal = new System.Security.Principal.WindowsPrincipal( System.Security.Principal.WindowsIdentity.GetCurrent()); if (pricipal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { RegistryKey registrybrowser = Registry.LocalMachine.OpenSubKey (@"Software\\Microsoft\\Internet Explorer\\Main\\FeatureControl\\FEATURE_BROWSER_EMULATION", true); var currentValue = registrybrowser.GetValue("*"); if (currentValue == null || (int)currentValue != 0x00002af9) { registrybrowser.SetValue("*", 0x00002af9, RegistryValueKind.DWord); } } else { this.Title += " (The first time to run with the rights of the administrator)"; } InitializeComponent(); }
public static void Main() { /** * if the current operation is done by an administrator, run it directly * if not, ask for the administrator's authority; */ //get the current user ID; System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); Application.EnableVisualStyles(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //whether the current operation is executed by administrators or not; if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //if this were run by administrators, run it directly; Application.Run(new MainForm()); } else { //build up the booting object; System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); startInfo.UseShellExecute = true; startInfo.WorkingDirectory = Environment.CurrentDirectory; startInfo.FileName = Application.ExecutablePath; //make sure this is run by administrator; startInfo.Verb = "runas"; try { System.Diagnostics.Process.Start(startInfo); } catch { return; } Application.Exit(); } }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //判断当前登录用户是否为管理员 if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //直接运行 Application.Run(new Form1()); } else { //启动对象 System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo { UseShellExecute = true, WorkingDirectory = Environment.CurrentDirectory, FileName = Application.ExecutablePath, //确保以管理员身份运行 Verb = "runas" }; try { System.Diagnostics.Process.Start(startInfo); } catch { return; } //退出 Application.Exit(); } }
/// <summary> ///以管理员的权限启动应用程序 /// </summary> static void StartBySystemUser() { /** * 当前用户是管理员的时候,直接启动应用程序 * 如果不是管理员,则使用启动对象启动程序,以确保使用管理员身份运行 */ //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //判断当前登录用户是否为管理员 if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //如果是管理员,则直接运行 Application.Run(new Service()); } else { //创建启动对象 System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); startInfo.UseShellExecute = true; startInfo.WorkingDirectory = Environment.CurrentDirectory; startInfo.FileName = Application.ExecutablePath; //设置启动动作,确保以管理员身份运行 startInfo.Verb = "runas"; try { System.Diagnostics.Process.Start(startInfo); } catch { return; } //退出 Application.Exit(); } }
private void RunAsAdministrator() { /** * 当前用户是管理员的时候,直接启动应用程序 * 如果不是管理员,则使用启动对象启动程序,以确保使用管理员身份运行 */ //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); //创建Windows用户主题 System.Windows.Forms.Application.EnableVisualStyles(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //判断当前登录用户是否为管理员 if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //如果是管理员,则直接运行 MainWindow main = new MainWindow(); main.Show(); } else { //创建启动对象 System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); //设置运行文件 startInfo.FileName = System.Windows.Forms.Application.ExecutablePath; //设置启动参数 //startInfo.Arguments = String.Join(" ", Args); //设置启动动作,确保以管理员身份运行 startInfo.Verb = "runas"; //如果不是管理员,则启动UAC System.Diagnostics.Process.Start(startInfo); //退出 this.Shutdown(); //System.Windows.Forms.Application.Exit(); } }
static void Main() { var identity = System.Security.Principal.WindowsIdentity.GetCurrent(); var principal = new System.Security.Principal.WindowsPrincipal(identity); if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { SAF.Foundation.ServiceModel.ServiceManager.Instance = new SAFServiceManager(); SAF.Framework.Controls.SplashScreen.ShowSplashScreen("正在启动服务管理器"); System.Globalization.CultureInfo zhHans = new System.Globalization.CultureInfo("zh-Hans"); System.Threading.Thread.CurrentThread.CurrentCulture = zhHans; System.Threading.Thread.CurrentThread.CurrentUICulture = zhHans; DevExpress.UserSkins.BonusSkins.Register(); DevExpress.Utils.AppearanceObject.DefaultFont = new Font("Segoe UI", 9); DevExpress.Skins.SkinManager.EnableFormSkins(); UserLookAndFeel.Default.SetSkinStyle("Office 2013"); ProgressService.SkinName = "Office 2013"; Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Shell()); } else { var startInfo = Process.GetCurrentProcess().StartInfo; startInfo.FileName = System.Reflection.Assembly.GetEntryAssembly().Location; startInfo.Verb = "runas"; Process.Start(startInfo); } }
/// <summary> /// <para>Check if the app was started as administrator or restart it with those permissions</para> /// <para>This method has to be called during the initialization process because otherwise the app will be restarted when trying to perform an action that requires administrator priviliges</para> /// </summary> /// <returns> /// <para>Whether administrator privileges are possible and requested</para> /// <para>When the user cancels UAC or some other error occurs this will return false.</para> /// </returns> public bool RequireAdministrator() { bool isAdmin = false; System.Security.Principal.WindowsIdentity winId = System.Security.Principal.WindowsIdentity.GetCurrent(); if (winId != null) isAdmin = new System.Security.Principal.WindowsPrincipal(winId).IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator); if (isAdmin) return true; Process me = Process.GetCurrentProcess(); ProcessStartInfo procStart = new ProcessStartInfo(); procStart.FileName = me.MainModule.FileName; procStart.UseShellExecute = true; procStart.Verb = "runas"; // run as Admin this.Log.LogLineDate("Requiring admin privileges...", Trigger.Log.Type.Other); try { if (Process.Start(procStart) == null) return false; Process.GetCurrentProcess().Kill(); return true; } catch (System.ComponentModel.Win32Exception e) { if (e.NativeErrorCode != 1223) // 1223 = user aborted UAC throw; } return false; }
static void Main(string[] args) { //Application.StartupPath + @"\CSSIM.exe" //RegistryKey HCROOT = Registry.ClassesRoot; //RegistryKey HCR_CSSIM=HCROOT.CreateSubKey("CSSIM"); //HCROOT.Close(); /** * 当前用户是管理员的时候,直接启动应用程序 * 如果不是管理员,则使用启动对象启动程序,以确保使用管理员身份运行 */ //获得当前登录的Windows用户标示 System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); //创建Windows用户主题 Application.EnableVisualStyles(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); //判断当前登录用户是否为管理员 Dictionary<string, string> HrefMap = new Dictionary<string, string>(); string[] arg_array = { }; if (args.Length > 0) { args = args[0].Split(':'); arg_array = args[1].Split('&'); } if (arg_array != null) { foreach (string item in arg_array) { if (item != null) { string[] items = item.Split('='); if (items.Length == 2) { HrefMap.Add(items[0].ToString(), items[1].ToString()); } } } /*if (HrefMap.ContainsKey("UD")) { MessageBox.Show(HrefMap["UD"].ToString()); } if (HrefMap.ContainsKey("PD")) { MessageBox.Show(HrefMap["PD"].ToString()); } if (HrefMap.ContainsKey("SD")) { MessageBox.Show(HrefMap["SD"].ToString()); }*/ } Cursor.Current = Cursors.WaitCursor; Process instance = RunningInstance(); if (instance == null) { //System.Net.IPAddress[] addressList = Dns.GetHostByName(Dns.GetHostName()).AddressList; //if (addressList.Length > 1) //{ // LocalHostIP = addressList[1]; // //Console.WriteLine(addressList[1].ToString()); //} //else //{ // LocalHostIP = addressList[0]; // //Console.WriteLine(addressList[1].ToString()); //} Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); try { Application.Run(new MainForm()); } catch (Exception) { MessageBox.Show("对不起,调用系统Win32API错误,请重新启动应用程序!"); Application.DoEvents(); Application.Exit(); } /*//判断当前登录用户是否为管理员 if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { //如果是管理员,则直接运行 Application.EnableVisualStyles(); try { Application.Run(new MainForm()); } catch (Exception) { MessageBox.Show("对不起,调用系统Win32API错误,请重新启动应用程序!"); Application.DoEvents(); Application.Exit(); } } else { //创建启动对象 System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo(); //设置运行文件 startInfo.FileName = System.Windows.Forms.Application.ExecutablePath; //设置启动参数 startInfo.Arguments = String.Join(" ", args); //设置启动动作,确保以管理员身份运行 startInfo.Verb = "runas"; //如果不是管理员,则启动UAC System.Diagnostics.Process.Start(startInfo); //退出 System.Windows.Forms.Application.Exit(); }*/ } else { HandleRunningInstance(instance); string sendText = HrefMap["SD"].ToString(); int WINDOW_HANDLER = FindWindow(null, @"CSS&IM"); byte[] sarr = System.Text.Encoding.Default.GetBytes(sendText); int len = sarr.Length; COPYDATASTRUCT cds; cds.dwData = (IntPtr)100; cds.lpData = sendText; cds.cbData = len + 1; SendMessage(WINDOW_HANDLER, WM_COPYDATA, 0, ref cds); //Util.HrefOpenFriendEventMethod(HrefMap["SD"].ToString()); //MessageBox.Show("abc"); } }
public static EAccountResult CreateAccount(ref AccountData account) { EAccountResult result = EAccountResult.Success; PostResult postResult; PostRequest mClient = new PostRequest("http://ragnarokonline.fr/inscription/index.php", "http://ragnarokonline.fr/inscription/index.php"); mClient.Type = PostRequest.PostTypeEnum.Get; postResult = mClient.Post(); // apply cookies mClient.Cookies = postResult.Cookies; // visit register page (need to fetch new cookies) mClient.Url = "http://ragnarokonline.fr/inscription/inscrire.php"; mClient.UrlReferer = "http://ragnarokonline.fr/inscription/inscrire.php"; postResult = mClient.Post(); // apply cookies.. mClient.Cookies = postResult.Cookies; // download captcha mClient.Url = "http://ragnarokonline.fr/inscription/securimage/securimage_show.php"; postResult = mClient.Post(); // apply cookies.. again //mClient.Cookies = postResult.Cookies; string captchaPath = Path.GetTempFileName(); File.Delete(captchaPath); captchaPath += ".png"; File.WriteAllBytes(captchaPath, postResult.ResponseData); // open captcha Process p = Process.Start(captchaPath); Console.Write("\t\tCaptcha code: "); account.CaptchaCode = Console.ReadLine(); // Only if we have admin rights, we may kill the process System.Security.Principal.WindowsPrincipal pricipal = new System.Security.Principal.WindowsPrincipal(System.Security.Principal.WindowsIdentity.GetCurrent()); if (pricipal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator) == true) { try { if (p.CloseMainWindow() == false) { // fall trough throw new Exception("Failed to close captcha image process"); } } catch (Exception ex) { // Failed to close.. so try minimize it try { System.Windows.Forms.Form frm = (System.Windows.Forms.Form)System.Windows.Forms.Form.FromHandle(p.MainWindowHandle); if (frm != null) { frm.WindowState = System.Windows.Forms.FormWindowState.Minimized; } } catch { // Nothing worked.. damn it // only native code may help now, but just to kill or minimize a process.. no way } } } mClient.Url = "http://ragnarokonline.fr/inscription/verifMail.php"; mClient.Cookies = postResult.Cookies; mClient.PostItems.Add("email", account.Email); mClient.PostItems.Add("name", account.Prename); mClient.PostItems.Add("surname", account.Name); mClient.PostItems.Add("jour", account.BirthDay.ToString()); mClient.PostItems.Add("mois", account.BirthMonth.ToString()); mClient.PostItems.Add("annee", account.BirthYear.ToString()); mClient.PostItems.Add("sexe", "1"); // Männlich mClient.PostItems.Add("captcha_code", account.CaptchaCode); postResult = mClient.Post(); Regex re = new Regex("&resultat=([^&]*)&login=([^&]*)&pass=([^&]*)"); Match match = re.Match(postResult.ResponseString); if (match.Success == false) { return CreateAccount(ref account); } account.Login = match.Groups[2].Captures[0].Value; account.Password = match.Groups[3].Captures[0].Value; int requestResult = int.Parse(match.Groups[1].Captures[0].Value); result = (EAccountResult)requestResult; return result; }
/// <summary> /// /// </summary> /// <param name="sender"></param> /// <param name="createRunspaceEventArg"></param> /// <exception cref="InvalidOperationException"> /// 1. InitialSessionState cannot be null. /// 2. Non existent InitialSessionState provider for the shellID /// </exception> private void HandleCreateRunspacePool(object sender, RemoteDataEventArgs createRunspaceEventArg) { if (createRunspaceEventArg == null) { throw PSTraceSource.NewArgumentNullException("createRunspaceEventArg"); } RemoteDataObject<PSObject> rcvdData = createRunspaceEventArg.ReceivedData; Dbg.Assert(rcvdData != null, "rcvdData must be non-null"); // set the PSSenderInfo sent in the first packets // This is used by the initial session state configuration providers like Exchange. if (Context != null) { #if !CORECLR // TimeZone Not In CoreCLR _senderInfo.ClientTimeZone = Context.ClientCapability.TimeZone; #endif } _senderInfo.ApplicationArguments = RemotingDecoder.GetApplicationArguments(rcvdData.Data); // Get Initial Session State from custom session config suppliers // like Exchange. ConfigurationDataFromXML configurationData = PSSessionConfiguration.LoadEndPointConfiguration(_configProviderId, _initParameters); // used by Out-Of-Proc (IPC) runspace. configurationData.InitializationScriptForOutOfProcessRunspace = _initScriptForOutOfProcRS; // start with data from configuration XML and then override with data // from EndPointConfiguration type. _maxRecvdObjectSize = configurationData.MaxReceivedObjectSizeMB; _maxRecvdDataSizeCommand = configurationData.MaxReceivedCommandSizeMB; DISCPowerShellConfiguration discProvider = null; if (String.IsNullOrEmpty(configurationData.ConfigFilePath)) { _sessionConfigProvider = configurationData.CreateEndPointConfigurationInstance(); } else { System.Security.Principal.WindowsPrincipal windowsPrincipal = new System.Security.Principal.WindowsPrincipal(_senderInfo.UserInfo.WindowsIdentity); Func<string, bool> validator = (role) => windowsPrincipal.IsInRole(role); discProvider = new DISCPowerShellConfiguration(configurationData.ConfigFilePath, validator); _sessionConfigProvider = discProvider; } // exchange of ApplicationArguments and ApplicationPrivateData is be done as early as possible // (i.e. to let the _sessionConfigProvider bail out if it can't comply with client's versioning request) PSPrimitiveDictionary applicationPrivateData = _sessionConfigProvider.GetApplicationPrivateData(_senderInfo); InitialSessionState rsSessionStateToUse = null; if (configurationData.SessionConfigurationData != null) { try { rsSessionStateToUse = _sessionConfigProvider.GetInitialSessionState(configurationData.SessionConfigurationData, _senderInfo, _configProviderId); } catch (NotImplementedException) { rsSessionStateToUse = _sessionConfigProvider.GetInitialSessionState(_senderInfo); } } else { rsSessionStateToUse = _sessionConfigProvider.GetInitialSessionState(_senderInfo); } if (null == rsSessionStateToUse) { throw PSTraceSource.NewInvalidOperationException(RemotingErrorIdStrings.InitialSessionStateNull, _configProviderId); } rsSessionStateToUse.ThrowOnRunspaceOpenError = true; // this might throw if the sender info is already present rsSessionStateToUse.Variables.Add( new SessionStateVariableEntry(RemoteDataNameStrings.SenderInfoPreferenceVariable, _senderInfo, Remoting.PSRemotingErrorInvariants.FormatResourceString( RemotingErrorIdStrings.PSSenderInfoDescription), ScopedItemOptions.ReadOnly)); // check if the current scenario is Win7(client) to Win8(server). Add back the PSv2 version TabExpansion // function if necessary. Version psClientVersion = null; if (_senderInfo.ApplicationArguments != null && _senderInfo.ApplicationArguments.ContainsKey("PSversionTable")) { var value = PSObject.Base(_senderInfo.ApplicationArguments["PSversionTable"]) as PSPrimitiveDictionary; if (value != null) { if (value.ContainsKey("WSManStackVersion")) { var wsmanStackVersion = PSObject.Base(value["WSManStackVersion"]) as Version; if (wsmanStackVersion != null && wsmanStackVersion.Major < 3) { // The client side is PSv2. This is the Win7 to Win8 scenario. We need to add the PSv2 // TabExpansion function back in to keep the tab expansion functionable on the client side. rsSessionStateToUse.Commands.Add( new SessionStateFunctionEntry( RemoteDataNameStrings.PSv2TabExpansionFunction, RemoteDataNameStrings.PSv2TabExpansionFunctionText)); } } if (value.ContainsKey("PSVersion")) { psClientVersion = PSObject.Base(value["PSVersion"]) as Version; } } } if (!string.IsNullOrEmpty(configurationData.EndPointConfigurationTypeName)) { // user specified a type to load for configuration..use the values from this type. _maxRecvdObjectSize = _sessionConfigProvider.GetMaximumReceivedObjectSize(_senderInfo); _maxRecvdDataSizeCommand = _sessionConfigProvider.GetMaximumReceivedDataSizePerCommand(_senderInfo); } SessionDataStructureHandler.TransportManager.ReceivedDataCollection.MaximumReceivedObjectSize = _maxRecvdObjectSize; // MaximumReceivedDataSize is not set for session transport manager...see the constructor // for more info. Guid clientRunspacePoolId = rcvdData.RunspacePoolId; int minRunspaces = RemotingDecoder.GetMinRunspaces(rcvdData.Data); int maxRunspaces = RemotingDecoder.GetMaxRunspaces(rcvdData.Data); PSThreadOptions threadOptions = RemotingDecoder.GetThreadOptions(rcvdData.Data); #if !CORECLR // No ApartmentState In CoreCLR ApartmentState apartmentState = RemotingDecoder.GetApartmentState(rcvdData.Data); #endif HostInfo hostInfo = RemotingDecoder.GetHostInfo(rcvdData.Data); if (_runspacePoolDriver != null) { throw new PSRemotingDataStructureException(RemotingErrorIdStrings.RunspaceAlreadyExists, _runspacePoolDriver.InstanceId); } #if !UNIX bool isAdministrator = _senderInfo.UserInfo.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator); #else bool isAdministrator = false; #endif ServerRunspacePoolDriver tmpDriver = new ServerRunspacePoolDriver( clientRunspacePoolId, minRunspaces, maxRunspaces, threadOptions, #if !CORECLR // No ApartmentState In CoreCLR apartmentState, #endif hostInfo, rsSessionStateToUse, applicationPrivateData, configurationData, this.SessionDataStructureHandler.TransportManager, isAdministrator, Context.ServerCapability, psClientVersion, _configurationName); // attach the necessary event handlers and start the driver. Interlocked.Exchange(ref _runspacePoolDriver, tmpDriver); _runspacePoolDriver.Closed += HandleResourceClosing; _runspacePoolDriver.Start(); }
public void RemoveConsole() { Trace.WriteLine("Installer::RemoveConsole"); SetOutput(_isPassive, _isPassive && _isForced); try { System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); if (!principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { RemoveElevated(); return; } List<GitInstallation> installations = null; // use the custom installation path if supplied if (!String.IsNullOrEmpty(_customPath)) { if (!Directory.Exists(_customPath)) { Console.Out.WriteLine(); Console.Error.WriteLine("Fatal: custom path does not exist: '{0}'. U_U", _customPath); Pause(); Result = ResultValue.InvalidCustomPath; return; } Console.Out.WriteLine(); Console.Out.WriteLine("Removing from custom path: '{0}'.", _customPath); // if the custom path points to a git location then treat it properly GitInstallation installation; if (Where.FindGitInstallation(_customPath, KnownGitDistribution.GitForWindows64v2, out installation) || Where.FindGitInstallation(_customPath, KnownGitDistribution.GitForWindows32v2, out installation) || Where.FindGitInstallation(_customPath, KnownGitDistribution.GitForWindows32v1, out installation)) { Trace.Write(" Git found: " + installation.Path); // track known Git installtations installations = new List<GitInstallation>(); installations.Add(installation); } } // since no custom installation path was supplied, use default logic else { Console.Out.WriteLine(); Console.Out.WriteLine("Looking for Git installation(s)..."); if (Where.FindGitInstallations(out installations)) { foreach (var installation in installations) { Console.Out.WriteLine(" {0}", installation.Path); } } } if (installations == null) { Console.Out.WriteLine(); Console.Error.WriteLine("Fatal: Git was not detected, unable to continue. U_U"); Pause(); Result = ResultValue.GitNotFound; return; } Configuration.Type types = Configuration.Type.Global | Configuration.Type.System; Configuration.Type updateTypes; if (SetGitConfig(installations, GitConfigAction.Unset, types, out updateTypes)) { if ((updateTypes & Configuration.Type.System) == Configuration.Type.System) { Console.Out.WriteLine(); Console.Out.WriteLine("Updated your /etc/gitconfig [git config --system]"); } else { Console.Out.WriteLine(); // updating /etc/gitconfig should not fail installation when forced if (!_isForced) { // only 'fatal' when not forced Console.Error.Write("Fatal: "); Result = ResultValue.GitConfigSystemFailed; return; } Console.Error.WriteLine("Unable to update your /etc/gitconfig correctly."); } if ((updateTypes & Configuration.Type.Global) == Configuration.Type.Global) { Console.Out.WriteLine("Updated your ~/.gitconfig [git config --global]"); } else { Console.Out.WriteLine(); Console.Error.WriteLine("Fatal: Unable to update your ~/.gitconfig correctly."); Result = ResultValue.GitConfigGlobalFailed; return; } } List<string> cleanedFiles; foreach (var installation in installations) { Console.Out.WriteLine(); Console.Out.WriteLine("Removing from '{0}'.", installation.Path); if (CleanFiles(installation.Libexec, out cleanedFiles)) { foreach (var file in cleanedFiles) { Console.Out.WriteLine(" {0}", file); } Console.Out.WriteLine(" {0} file(s) cleaned", cleanedFiles.Count); } else if (_isForced) { Console.Error.WriteLine(" removal failed. U_U"); } else { Console.Error.WriteLine(" removal failed. U_U"); Pause(); Result = ResultValue.RemovalFailed; return; } } if (Directory.Exists(UserBinPath)) { Console.Out.WriteLine(); Console.Out.WriteLine("Removing from '{0}'.", UserBinPath); if (CleanFiles(UserBinPath, out cleanedFiles)) { foreach (var file in cleanedFiles) { Console.Out.WriteLine(" {0}", file); } Console.Out.WriteLine(" {0} file(s) cleaned", cleanedFiles.Count); } else if (_isForced) { Console.Error.WriteLine(" removal failed. U_U"); } else { Console.Error.WriteLine(" removal failed. U_U"); Pause(); Result = ResultValue.RemovalFailed; return; } } if (CygwinPath != null && Directory.Exists(CygwinPath)) { if (CleanFiles(CygwinPath, out cleanedFiles)) { foreach (var file in cleanedFiles) { Console.Out.WriteLine(" {0}", file); } Console.Out.WriteLine(" {0} file(s) cleaned", cleanedFiles.Count); } } // all necissary content has been deployed to the system Result = ResultValue.Success; Console.Out.WriteLine(); Console.Out.WriteLine("Success! {0} was removed! ^_^", Program.Title); Pause(); } finally { SetOutput(true, true); } }
public void DeployConsole() { SetOutput(_isPassive, _isPassive && _isForced); try { System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); if (!principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)) { DeployElevated(); return; } List<GitInstallation> installations = null; // use the custom installation path if supplied if (!String.IsNullOrEmpty(_customPath)) { if (!Directory.Exists(_customPath)) { Program.LogEvent("No Git installation found, unable to continue deployment.", EventLogEntryType.Error); Console.Out.WriteLine(); Program.WriteLine($"Fatal: custom path does not exist: '{_customPath}'. {FailFace}"); Pause(); Result = ResultValue.InvalidCustomPath; return; } Console.Out.WriteLine(); Console.Out.WriteLine($"Deploying to custom path: '{_customPath}'."); // if the custom path points to a git location then treat it properly GitInstallation installation; if (Where.FindGitInstallation(_customPath, KnownGitDistribution.GitForWindows64v2, out installation) || Where.FindGitInstallation(_customPath, KnownGitDistribution.GitForWindows32v2, out installation) || Where.FindGitInstallation(_customPath, KnownGitDistribution.GitForWindows32v1, out installation)) { Git.Trace.WriteLine($" Git found: '{installation.Path}'."); // track known Git installations installations = new List<GitInstallation>(); installations.Add(installation); } Program.LogEvent($"Custom path deployed to: '{_customPath}'", EventLogEntryType.Information); } // since no custom installation path was supplied, use default logic else { Console.Out.WriteLine(); Console.Out.WriteLine("Looking for Git installation(s)..."); if (Where.FindGitInstallations(out installations)) { foreach (var installation in installations) { Console.Out.WriteLine($" {installation.Path}"); } } } if (installations == null) { Program.LogEvent("No Git installation found, unable to continue.", EventLogEntryType.Error); Console.Out.WriteLine(); Program.WriteLine("Fatal: Git was not detected, unable to continue. {FailFace}"); Pause(); Result = ResultValue.GitNotFound; return; } List<string> copiedFiles; foreach (var installation in installations) { Console.Out.WriteLine(); Console.Out.WriteLine($"Deploying from '{Program.Location}' to '{installation.Path}'."); if (CopyFiles(Program.Location, installation.Libexec, FileList, out copiedFiles)) { int copiedCount = copiedFiles.Count; foreach (var file in copiedFiles) { Console.Out.WriteLine($" {file}"); } // copy help documents if (Directory.Exists(installation.Doc) && CopyFiles(Program.Location, installation.Doc, DocsList, out copiedFiles)) { copiedCount += copiedFiles.Count; foreach (var file in copiedFiles) { Console.Out.WriteLine($" {file}"); } } Program.LogEvent($"Deployment to '{installation.Path}' succeeded.", EventLogEntryType.Information); Console.Out.WriteLine($" {copiedCount} file(s) copied"); } else if (_isForced) { Program.LogEvent($"Deployment to '{installation.Path}' failed.", EventLogEntryType.Warning); Program.WriteLine($" deployment failed. {FailFace}"); } else { Program.LogEvent($"Deployment to '{installation.Path}' failed.", EventLogEntryType.Error); Program.WriteLine($" deployment failed. {FailFace}"); Pause(); Result = ResultValue.DeploymentFailed; return; } } Console.Out.WriteLine(); Console.Out.WriteLine($"Deploying from '{Program.Location}' to '{UserBinPath}'."); if (!Directory.Exists(UserBinPath)) { Directory.CreateDirectory(UserBinPath); } if (CopyFiles(Program.Location, UserBinPath, FileList, out copiedFiles)) { int copiedCount = copiedFiles.Count; foreach (var file in copiedFiles) { Console.Out.WriteLine($" {file}"); } if (CopyFiles(Program.Location, UserBinPath, DocsList, out copiedFiles)) { copiedCount = copiedFiles.Count; foreach (var file in copiedFiles) { Console.Out.WriteLine($" {file}"); } } Program.LogEvent($"Deployment to '{UserBinPath}' succeeded.", EventLogEntryType.Information); Console.Out.WriteLine($" {copiedCount} file(s) copied"); } else if (_isForced) { Program.LogEvent($"Deployment to '{UserBinPath}' failed.", EventLogEntryType.Warning); Program.WriteLine($" deployment failed. {FailFace}"); } else { Program.LogEvent($"Deployment to '{UserBinPath}' failed.", EventLogEntryType.Error); Program.WriteLine($" deployment failed. {FailFace}"); Pause(); Result = ResultValue.DeploymentFailed; return; } if (CygwinPath != null && Directory.Exists(CygwinPath)) { if (CopyFiles(Program.Location, CygwinPath, FileList, out copiedFiles)) { int copiedCount = copiedFiles.Count; foreach (var file in copiedFiles) { Console.Out.WriteLine($" {file}"); } if (CopyFiles(Program.Location, CygwinPath, DocsList, out copiedFiles)) { copiedCount = copiedFiles.Count; foreach (var file in copiedFiles) { Console.Out.WriteLine($" {file}"); } } Program.LogEvent($"Deployment to '{CygwinPath}' succeeded.", EventLogEntryType.Information); Console.Out.WriteLine($" {copiedCount} file(s) copied"); } else if (_isForced) { Program.LogEvent($"Deployment to '{CygwinPath}' failed.", EventLogEntryType.Warning); Program.WriteLine($" deployment failed. {FailFace}"); } else { Program.LogEvent($"Deployment to '{CygwinPath}' failed.", EventLogEntryType.Error); Program.WriteLine($" deployment failed. {FailFace}"); Pause(); Result = ResultValue.DeploymentFailed; return; } } Configuration.Type types = Configuration.Type.Global; Configuration.Type updateTypes; if (SetGitConfig(installations, GitConfigAction.Set, types, out updateTypes)) { if ((updateTypes & Configuration.Type.Global) == Configuration.Type.Global) { Console.Out.WriteLine("Updated your ~/.gitconfig [git config --global]"); } else { Console.Out.WriteLine(); Program.WriteLine("Fatal: Unable to update your ~/.gitconfig correctly."); Result = ResultValue.GitConfigGlobalFailed; return; } } // all necessary content has been deployed to the system Result = ResultValue.Success; Program.LogEvent($"{Program.Title} v{Program.Version.ToString(3)} successfully deployed.", EventLogEntryType.Information); Console.Out.WriteLine(); Console.Out.WriteLine($"Success! {Program.Title} was deployed! {TadaFace}"); Pause(); } finally { SetOutput(true, true); } }
//判断权限 public bool IslimitAccess() { //检查系统权限 System.Security.Principal.WindowsIdentity wid = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal p = new System.Security.Principal.WindowsPrincipal(wid); bool isAdmin = (p.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)); if (isAdmin == false) { MessageBox.Show("您目前登录的账号不具有管理员权限,请确认后使用应用:)", "权限警告", MessageBoxButtons.OK, MessageBoxIcon.Stop); return true; } else { return false; } }
public static bool IsAdministratorRun() { System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent(); if (null != identity) { System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity); return principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator); } return false; }
private void InitWifiState() { bool result = WifiOperator.WifiStateQuery(); if(result) { IsWifiOpened = true; Message = "Wifi已启动"; } else { IsWifiOpened = false; Message = "Wifi未启动"; } System.Security.Principal.WindowsIdentity wid = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.Principal.WindowsPrincipal printcipal = new System.Security.Principal.WindowsPrincipal(wid); IsAdmin = (printcipal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator)); if (!IsAdmin) { Message = "请用管理员权限运行"; } }