Effekt beim Speichern einer Datei ohne Administrator-Rechte

  • C#

Es gibt 5 Antworten in diesem Thema. Der letzte Beitrag () ist von RodFromGermany.

    Effekt beim Speichern einer Datei ohne Administrator-Rechte

    Moin Leute.
    Zur Konfiguration eines Geräts nutze ich ein spezielles Programm, normalerweise arbeitet das nicht mit Administrator-Rechten und alles funktioniert prächtig.
    Aus irgend einem Grund startete ich dieses Programm mit Administrator-Rechten und speicherte die Konfiguration.
    Das Geräteprogramm, das nicht über Administrator-Rechte verfügt, konnte danach nicht mehr auf die Konfigurationsdatei zugreifen, es kam eine UnauthorizedAccessException.
    Ich sah mir die Eigenschaften der Datei im Explorer an und folgendes kam heraus:
    linls ist die Sicherheitskopie der ursprünglichen Datei, rechts ist die neu geschriebene Datei:
    vorher: nachher:

    Beim Schreiben hat das System den User (24DUK\User) aus den Benutzernamen entfernt.
    Hat jemand von Euch eine Idee, wie dieses Problem zu umgehen ist?
    Ansonsten muss ich bei Start mit Admin-Rechten das Schreiben verhindern oder zumindest warnen.
    Danke.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    @nafets Danke, die Idee ist gut, aber mein Problem löst sie leider nicht.
    Herangehensweise:
    Ich starte das Testprogramm mit Administrator-Rechten und wechsle die Identität.
    Wenn ich mich als WindowsIdentity.GetAnonymous() einlogge, hat diese Identität immer noch Administrator-Rechte.
    ====
    Momentan überwache ich die Administrator-Rechte beim Schreiben und warne den User entsprechend.
    ========

    Es geht doch.
    Ich habe einen weiteren Standard-User Namens "Test" angelegt.
    Logge ich mich als dieser ein, hat dessen Identität keine Administrator-Rechte.
    Nun muss ich noch testen, ob ich danach als "ich" Zugriff auf seine geschriebene Datei habe.

    Allerdings ist ein weiterer User weder eine Lösung noch ein Arbeitsdrumherum.
    Die Verwendung eines anderen Users scheidet auch aus, da dessen Login-Daten benötigt werden, und das ist ein NoGo.

    Bleibt nur die Überwachung der Administrator-Rechte beim Schreiben der Datei.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „RodFromGermany“ ()

    Ich will Euch natürlich meinen Code nicht vorenthalten:
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Runtime.InteropServices;
    3. using System.Security.Permissions;
    4. using System.Security.Principal;
    6. namespace TestImpersonate
    7. {
    8. internal class ImpersonationDemo
    9. {
    10. #region API Code
    12. private const int LOGON32_PROVIDER_DEFAULT = 0;
    14. /// <summary>
    15. /// This parameter causes LogonUser to create a primary token.
    16. /// </summary>
    17. private const int LOGON32_LOGON_INTERACTIVE = 2;
    19. [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
    20. public static extern bool LogonUser(string userName, string domain, string password, int logonType, int logonProvider, out SafeTokenHandle token);
    22. [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
    23. public extern static bool CloseHandle(IntPtr handle);
    25. #endregion API Code
    27. // Test harness.
    28. // If you incorporate this code into a DLL, be sure to demand FullTrust.
    29. [PermissionSetAttribute(SecurityAction.Demand, Name = "FullTrust")]
    30. public static bool DoIt(string userName, string domainName, string password)
    31. {
    32. try
    33. {
    34. SafeTokenHandle safeTokenHandle;
    35. // Call LogonUser to obtain a handle to an access token.
    36. bool retVal = ImpersonationDemo.LogonUser(userName, domainName, password, ImpersonationDemo.LOGON32_LOGON_INTERACTIVE, ImpersonationDemo.LOGON32_PROVIDER_DEFAULT, out safeTokenHandle);
    38. Console.WriteLine("LogonUser called.");
    40. if (!retVal)
    41. {
    42. int ret = Marshal.GetLastWin32Error();
    43. Console.WriteLine("LogonUser failed with error code : {0}", ret);
    44. //throw new System.ComponentModel.Win32Exception(ret);
    45. return false;
    46. }
    48. using (safeTokenHandle)
    49. {
    50. Console.WriteLine("Did LogonUser Succeed? " + (retVal ? "Yes" : "No"));
    51. Console.WriteLine("Value of Windows NT token: " + safeTokenHandle);
    53. // Check the identity.
    54. Console.WriteLine("Before impersonation: " + WindowsIdentity.GetCurrent().Name);
    56. // Use the token handle returned by LogonUser.
    57. IntPtr token = safeTokenHandle.DangerousGetHandle();
    58. using (WindowsImpersonationContext impersonatedUser = WindowsIdentity.Impersonate(token))
    59. {
    60. // Check the identity.
    61. Console.WriteLine("After impersonation: " + WindowsIdentity.GetCurrent().Name);
    63. // TODO: Hier erfolgt die Arbeit im fremden Kontext
    64. ImpersonationDemo.DoOtherWork();
    65. }
    67. // Releasing the context object stops the impersonation
    68. // Check the identity.
    69. Console.WriteLine("After closing the context: " + WindowsIdentity.GetCurrent().Name);
    70. return true;
    71. }
    72. }
    73. catch (Exception ex)
    74. {
    75. Console.WriteLine("Exception occurred. " + ex.Message);
    76. return false;
    77. }
    78. }
    80. internal static void DoIt()
    81. {
    82. // Warnung CS0162: Unerreichbarer Code wurde entdeckt.
    83. #pragma warning disable 162
    84. IntPtr token;
    85. if (true)
    86. {
    87. token = WindowsIdentity.GetCurrent().Token;
    88. }
    89. else
    90. {
    91. token = WindowsIdentity.GetAnonymous().Token;
    92. }
    93. #pragma warning restore 162
    95. // Check the identity.
    96. Console.WriteLine("Before impersonation: " + WindowsIdentity.GetCurrent().Name);
    97. using (WindowsImpersonationContext impersonatedUser = WindowsIdentity.Impersonate(token))
    98. {
    99. // Check the identity.
    100. Console.WriteLine("After impersonation: " + WindowsIdentity.GetCurrent().Name);
    102. ImpersonationDemo.DoOtherWork();
    103. }
    105. // Releasing the context object stops the impersonation
    106. // Check the identity.
    107. Console.WriteLine("After closing the context: " + WindowsIdentity.GetCurrent().Name);
    108. }
    110. private static void DoOtherWork()
    111. {
    112. // TODO: Hier erfolgt die Arbeit im fremden Kontext
    113. if (ImpersonationDemo.CheckAdministrator())
    114. {
    115. Console.WriteLine("Administrator");
    116. }
    117. else
    118. {
    119. Console.WriteLine("kein Administrator");
    120. }
    121. }
    123. /// <summary>
    124. /// Abfrage, ob this Programm mit Administratorrechten läuft
    125. /// </summary>
    126. /// <returns>Administrator</returns>
    127. internal static bool CheckAdministrator()
    128. {
    129. WindowsPrincipal principal = new WindowsPrincipal(WindowsIdentity.GetCurrent());
    130. return principal.IsInRole(WindowsBuiltInRole.Administrator);
    131. }
    132. }
    133. }
    Aufruf mit

    C#-Quellcode

    1. DoIt(userName, domainName, password);
    2. // bzw.
    3. DoIt();
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Wenn du eh schon Administrator Rechte hast, könntest du natürlich auch direkt die Berechtigungen der Datei nach dem Schreiben einfach anpassen:

    C#-Quellcode

    1. FileInfo fi = new FileInfo("yourFile");
    2. FileSecurity fiSecurity = fi.GetAccessControl();
    3. fiSecurity.AddAccessRule(new FileSystemAccessRule(newSecurityIdentifier(WellKnownSidType.WorldSid, null), FileSystemRights.FullControl, AccressControlType.Allow));
    4. fi.SetAccessControl(fiSecurity);

    Anstatt hier die SID für "Jeder" zu benutzen, müsstest du natürlich die SID des Users verwenden.

    Nachtrag 2:
    Gas ganze ist ja noch viel unübersichtlicher.
    Das ganze passiert nur, wenn ich die Daten in das Verzeichnis C:\ProgramData\... speichere.
    In C:\Temp\... gibt es da keine Probleme.
    Also:
    In ein "öffentliches" Verzeichnis speichern und dann nach C:\ProgramData\... kopieren.
    Mal sehen.
    ====
    Und die UnauthorizedAccessException gedenke ich zu umgehen, indem ich die Datei über einem ReadOnly-Stream einlese, Notpad und Notpad++ können das ja auch.
    ========

    @EaranMaleasi Ich seh es mir mal an.
    Hat wunderbar funktioniert, ich pack das ganze mal zu den Tipps und Tricks, Link folgt nach Freigabe.
    Hier ist der Link:
    Probleme beim Speichern von Dateien ohne Administrator-Rechte


    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „RodFromGermany“ ()

Facebook
Telefonspende