Wie verstecke ich einen Prozess im Task-Manager in C #?

Habe ich eine Anforderung, um zu verbergen, einen Prozess im Task-Manager. Es ist für Intranet-Szenario. So, alles ist legitim. 🙂

Bitte fühlen Sie sich frei zu teilen-code, den Sie haben (vorzugsweise in C#) oder irgendwelche anderen Techniken oder Probleme mit dieser Strecke.

Update1: die Meisten Benutzer haben admin-Rechte, um zu laufen, einige ältere apps. Also, der Vorschlag war, es zu verbergen, die im task-manager. Wenn es andere Ansätze, um zu verhindern, dass Benutzer von der Tötung der Prozess, das wäre toll.

Update2: Entfernen der Referenz zu rootkit. Irgendwie hat dieser post Aussehen negativ.

InformationsquelleAutor der Frage Gulzar Nazim | 2008-10-09

  1. 42

    Gibt es keinen unterstützten Weg um dies zu erreichen. Der Prozess-Liste gelesen werden können auf jede Berechtigungsstufe. Wenn Sie hoffen, um zu verbergen, ein Prozess von noch Administratoren, dann ist das doppelt nicht unterstützt.

    Zu bekommen dies funktioniert, müssen Sie schreiben ein kernel-Modus-rootkit zum abfangen von aufrufen zu NtQuerySystemInformationso dass die SystemProcessInformation info-Klasse schlägt fehl, um Ihre versteckten Prozess.

    Abfangen von Systemaufrufen ist sehr schwer zu tun, sicher, und die 64-bit-Windows-Kernel gehen aus dem Weg zu verhindern, dass dies möglich war: der Versuch, ändern Sie die syscall Tabelle, Ergebnisse in einem Augenblick blauen Bildschirm. Es wird sehr schwierig sein, auf diesen Plattformen

    Hier ist ein Beispiel für ein rootkit, das versucht, etwas ähnliches zu tun (und hat mehrere schwerwiegende Probleme).

    InformationsquelleAutor der Antwort Chris Smith

  2. 67

    Versuchen Sie nicht, um ihn zu stoppen, getötet zu werden - du wirst doch nicht um es zu verwalten. Stattdessen machen es regelmäßig zu Hause anrufen, um einen webservice. Wenn der webservice bemerkt ein client "gehen silent" es kann die ping-Maschine zu sehen, wenn es nur ein reboot Problem, und senden Sie eine E-Mail an einen manager (oder wer auch immer) zu disziplinieren, wer hat getötet der Prozess.

    InformationsquelleAutor der Antwort Jon Skeet

  3. 18

    Wenn Sie verhindern möchten, dass Benutzer von der Tötung der Prozess von der task-manager, können Sie nur verwenden Sie eine Sicherheitsbeschreibung für den Prozess zu verweigern, zu beenden, den Zugang zu jeder. Administratoren, technisch kann immer noch töten, den Prozess durch die übernahme der Prozess-und zurücksetzen der DACL, aber es gibt keine Schnittstelle, um entweder diese Dinge aus dem Task-Manager. Process Explorer kann eine Schnittstelle aber.

    Wenn ein Prozess gestartet wird, verwenden Sie SetKernelObjectSecurity mit DACL_SECURITY_INFORMATION mit dem aktuellen Prozess zu behandeln. Legen Sie eine DACL mit null-ACLs. Dies wird deny all " - Zugang für jeden, einschließlich diejenigen, die versuchen, bis zum Ende Ihres Prozesses mit dem task-manager.

    Hier ist ein Beispiel, dass auch änderungen der Prozess-Besitzer:

    SECURITY_DESCRIPTOR sd;
ACL dacl;
SID_IDENTIFIER_AUTHORITY ntauth = SECURITY_NT_AUTHORITY;
PSID owner;

assert(InitializeAcl(&dacl, sizeof dacl, ACL_REVISION));

assert(AllocateAndInitializeSid(&ntauth, 1, SECURITY_LOCAL_SYSTEM_RID, 0,0,0,0,0,0,0, &owner));

assert(InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION));

assert(SetSecurityDescriptorDacl(&sd, TRUE, &dacl, FALSE));

assert(SetSecurityDescriptorOwner(&sd, owner, FALSE));

assert(SetKernelObjectSecurity(GetCurrentProcess(), DACL_SECURITY_INFORMATION | OWNER_SECURITY_INFORMATION, &sd));

assert(FreeSid(owner) == NULL);

    Leider, es scheint nicht wirksam zu sein. Ich kann immer noch schließen Sie den Prozess (obwohl Sie nicht als Benutzer mit eingeschränkten rechten). Vielleicht ist der Task-Manager ist die Eigenverantwortung aufrufen oder einige andere Privileg, den Prozess zu beenden? Ich glaube mich zu erinnern diese arbeiten, die in früheren Versionen von Windows (ich wurde getestet, 2003), aber ich könnte falsch sein.

    InformationsquelleAutor der Antwort Chris Smith

  4. 10

    Ich hoffe, dass Sie nicht in der Lage wäre.

    Update: angesichts der Szenario, ich denke, dass Sie wahrscheinlich am besten aus, läuft es unter einem anderen admin-Konto. Das kann helfen, aufmerksam auf die Tatsache, dass Sie nicht töten sollen den Prozess.

    InformationsquelleAutor der Antwort Marcin

  5. 6

    Alternativ könnten Sie schreiben, eine kleine "checker" - Dienstprogramm, das überprüft, ob die app läuft, wenn es nicht automatisch startet. Dann fügen Sie code, um die app zu überprüfen, für den "checker" - Dienstprogramm, das die gleichen. Auf diese Weise, wenn man gekündigt ist, dann die andere fängt es wieder auf. Ich habe mir scheinen die Viren tun dies, und es scheint zu funktionieren ziemlich effektiv.

    InformationsquelleAutor der Antwort Chris Pietschmann

  6. 4

    Wenn Sie einfach brauchen, um zu verschleiern, den Prozess und nicht verbergen vollständig, können Sie es umbenennen winlogon.exe oder svchost.exe und es wird wahrscheinlich ignoriert werden, indem der Benutzer. Aber wie Sergio schon erwähnt, dass "Sicherheit durch Verschleierung" und es hat einen schlechten Ruf für einen Grund.

    Verhindern, dass Benutzer aus der Tötung ein Prozess ist eine weitere Schwierigkeit, wenn Sie die richtige Berechtigungen. Die einzige Methode die ich kenne haben mehrere Prozesse, die beobachten sich gegenseitig und starten Sie alle überwachten Prozess, der getötet wird. Wieder, dies ist hinunter ein schattiger Weg.

    InformationsquelleAutor der Antwort Ben Hoffstein

  7. 3

    Gibt es keine einfache oder unterstützte Weg, dies zu tun. Auch wenn Sie schrieb ein rootkit, es zu tun, dann könnte sehr leicht kaputt zu bekommen von einem zukünftigen update, das gemacht wurde, dass Loch zu Stopfen. Ich würde überdenken, ob das ist etwas, was Sie wollen.

    InformationsquelleAutor der Antwort StubbornMule

  8. 3

    Als oben genannten Personen, ist die beste Methode 2 Aufgaben, die überwachung jedes andere,
    Ich verstehe Sie nicht wollen, um Verschwendung von CPU, so dass der beste Weg ist, um ein event etablieren, zwischen den Aufgaben, die ausgelöst wird, wenn man schließt.

    Ich bin mir nicht ganz sicher, wie die Haken, aber dann brauchen Sie sich nicht mit einer while-Schleife, die nicht Abfall CPU.

    InformationsquelleAutor der Antwort eitama

  9. 3

    Einen Treiber schreiben - Sie können ObRegisterCallbacks zu registrieren process-Objekt Zugriff auf Benachrichtigung. Zurück STATUS_ACCESS_DENIED wenn DesiredAccess enthält Zugriffsrechte, die Ihnen nicht gefällt, wie Beendigung des Prozesses oder schreiben auf Speicher verarbeiten.

    http://msdn.microsoft.com/en-us/library/windows/hardware/ff558692(v=vs. 85).aspx

    InformationsquelleAutor der Antwort Uriel G.

  10. 3

    Nicht sicher, warum dies nicht vorgeschlagen worden, aber heres meine erste Antwort auf dieser Seite.
    statt dass der Nutzer vor der Tötung eines Prozesses. (Erfordert rootkit hook.)
    Sie können einfach deaktivieren Sie den task-manager verwendet werden, die mit einem registry-Eingang.

    public static void ToggleTaskManager(bool toggle)
{
    Microsoft.Win32.RegistryKey HKCU = Microsoft.Win32.Registry.LocalMachine;
    Microsoft.Win32.RegistryKey key = HKCU.CreateSubKey(@"Software\Microsoft\Windows\CurrentVersion\Policies\System");
    key.SetValue("DisableTaskMgr", toggle ? 0 : 1, Microsoft.Win32.RegistryValueKind.DWord);
}

    InformationsquelleAutor der Antwort Cacoon

  11. 2

    Haben, die Sie bei uns schriftlich einen service? Diese Weise der Dienst als " lokales system, und die Anwendung läuft unter dem user-Kontext, und der service kann dafür sorgen, dass die Dinge noch getan werden, als benötigt werden, und die Anwendung ist nur eine Schnittstelle zu diesem Dienst. Töten würde die Anwendung nur der Benutzer nicht zu sehen, Mitteilungen, system-tray-icon, etc, aber der service ist immer noch seine Arbeit verrichtet.

    InformationsquelleAutor der Antwort Rick

  12. 2

    Viele Menschen könnten wissen, wie es zu tun, aber eben nicht hier posten. Es ist sehr gefährlich, post, schädlichen code auf dem internet. Wer weiß, könnten Sie in Gefahr sein. Bitten Sie einige computer-Ingenieur. Ich gebe Ihnen die Struktur des Programms, obwohl.

    Nur injizieren Sie Ihr Programm mit der dll in explorer.exe.

    Ihrem Prozess nicht nur show, weil es ist nicht als Programm, sondern wird, lief in einem Programm (explorer.exe). Der Benutzer will einfach nicht sehen, selbst wenn er mit jeder Art von task-manager.

    InformationsquelleAutor der Antwort ABCDWHAT

  13. 1

    Was Sie gerade bitten Sie den Benutzer, nicht den Prozess zu beenden ? Wie viel Zeit werden Sie damit verbringen, es zu tun, für ein Verhalten, das eindeutig kindisch von den Angestellten in der gleichen Firma.

    InformationsquelleAutor der Antwort pmlarocque

  14. 1

    Sah ich @Chris Smith Antwort, und ich beschloss, es zu konvertieren, um C#.

    Hier ist der code, übernommen aus hierfür eine einfache Windows forms-Anwendung:

    C# - Variante: 

       using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Runtime.InteropServices;
    using System.Security.AccessControl;
    using System.Security.Principal;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;

namespace Hide2
{
    public partial class Form1 : Form
    {
        [DllImport("advapi32.dll", SetLastError = true)]
        static extern bool GetKernelObjectSecurity(IntPtr Handle, int securityInformation, [Out] byte[] pSecurityDescriptor,
        uint nLength, out uint lpnLengthNeeded);

        public static RawSecurityDescriptor GetProcessSecurityDescriptor(IntPtr processHandle)
        {
            const int DACL_SECURITY_INFORMATION = 0x00000004;
            byte[] psd = new byte[0];
            uint bufSizeNeeded;
            //Call with 0 size to obtain the actual size needed in bufSizeNeeded
            GetKernelObjectSecurity(processHandle, DACL_SECURITY_INFORMATION, psd, 0, out bufSizeNeeded);
            if (bufSizeNeeded < 0 || bufSizeNeeded > short.MaxValue)
                throw new Win32Exception();
            //Allocate the required bytes and obtain the DACL
            if (!GetKernelObjectSecurity(processHandle, DACL_SECURITY_INFORMATION,
            psd = new byte[bufSizeNeeded], bufSizeNeeded, out bufSizeNeeded))
                throw new Win32Exception();
            //Use the RawSecurityDescriptor class from System.Security.AccessControl to parse the bytes:
            return new RawSecurityDescriptor(psd, 0);
        }

        [DllImport("advapi32.dll", SetLastError = true)]
        static extern bool SetKernelObjectSecurity(IntPtr Handle, int securityInformation, [In] byte[] pSecurityDescriptor);

        [DllImport("kernel32.dll")]
        public static extern IntPtr GetCurrentProcess();

        [Flags]
        public enum ProcessAccessRights
        {
            PROCESS_CREATE_PROCESS = 0x0080, // Required to create a process.
            PROCESS_CREATE_THREAD = 0x0002, // Required to create a thread.
            PROCESS_DUP_HANDLE = 0x0040, //Required to duplicate a handle using DuplicateHandle.
            PROCESS_QUERY_INFORMATION = 0x0400, // Required to retrieve certain information about a process, such as its token, exit code, and priority class (see OpenProcessToken, GetExitCodeProcess, GetPriorityClass, and IsProcessInJob).
            PROCESS_QUERY_LIMITED_INFORMATION = 0x1000, // Required to retrieve certain information about a process (see QueryFullProcessImageName). A handle that has the PROCESS_QUERY_INFORMATION access right is automatically granted PROCESS_QUERY_LIMITED_INFORMATION. Windows Server 2003 and Windows XP/2000:  This access right is not supported.
            PROCESS_SET_INFORMATION = 0x0200, //   Required to set certain information about a process, such as its priority class (see SetPriorityClass).
            PROCESS_SET_QUOTA = 0x0100, // Required to set memory limits using SetProcessWorkingSetSize.
            PROCESS_SUSPEND_RESUME = 0x0800, //Required to suspend or resume a process.
            PROCESS_TERMINATE = 0x0001, // Required to terminate a process using TerminateProcess.
            PROCESS_VM_OPERATION = 0x0008, //  Required to perform an operation on the address space of a process (see VirtualProtectEx and WriteProcessMemory).
            PROCESS_VM_READ = 0x0010, //   Required to read memory in a process using ReadProcessMemory.
            PROCESS_VM_WRITE = 0x0020, //  Required to write to memory in a process using WriteProcessMemory.
            DELETE = 0x00010000, //Required to delete the object.
            READ_CONTROL = 0x00020000, //  Required to read information in the security descriptor for the object, not including the information in the SACL. To read or write the SACL, you must request the ACCESS_SYSTEM_SECURITY access right. For more information, see SACL Access Right.
            SYNCHRONIZE = 0x00100000, //   The right to use the object for synchronization. This enables a thread to wait until the object is in the signaled state.
            WRITE_DAC = 0x00040000, // Required to modify the DACL in the security descriptor for the object.
            WRITE_OWNER = 0x00080000, //   Required to change the owner in the security descriptor for the object.
            STANDARD_RIGHTS_REQUIRED = 0x000f0000,
            PROCESS_ALL_ACCESS = (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFF),//   All possible access rights for a process object.
        }
        public static void SetProcessSecurityDescriptor(IntPtr processHandle, RawSecurityDescriptor dacl)
        {
            const int DACL_SECURITY_INFORMATION = 0x00000004;
            byte[] rawsd = new byte[dacl.BinaryLength];
            dacl.GetBinaryForm(rawsd, 0);
            if (!SetKernelObjectSecurity(processHandle, DACL_SECURITY_INFORMATION, rawsd))
                throw new Win32Exception();
        }

        public Form1()
        {
            InitializeComponent();

            //Get the current process handle
            IntPtr hProcess = GetCurrentProcess();
            //Read the DACL
            var dacl = GetProcessSecurityDescriptor(hProcess);
            //Insert the new ACE
            dacl.DiscretionaryAcl.InsertAce(
            0,
            new CommonAce(
            AceFlags.None,
            AceQualifier.AccessDenied,
            (int)ProcessAccessRights.PROCESS_ALL_ACCESS,
            new SecurityIdentifier(WellKnownSidType.WorldSid, null),
            false,
            null)
            );
            //Save the DACL
            SetProcessSecurityDescriptor(hProcess, dacl);
        }
    }
}

    Es nach dem ausführen als eingeschränkter Benutzer, kann ich nicht töten, es aus der task-manager, nur als administrator.

    Ich verließ die X - Taste, um in der Lage sein, um es zu schließen, ohne ein admin, aber es ist auch möglich, um es zu entfernen.

    Das Ergebnis:

    Wie verstecke ich einen Prozess im Task-Manager in C #?

    Powershell-Variante: 

    $source = @"
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Security.AccessControl;
using System.Security.Principal;

namespace Hide2
{
    public class myForm
    {
        [DllImport("advapi32.dll", SetLastError = true)]
        static extern bool GetKernelObjectSecurity(IntPtr Handle, int securityInformation, [Out] byte[] pSecurityDescriptor,
        uint nLength, out uint lpnLengthNeeded);

        public static RawSecurityDescriptor GetProcessSecurityDescriptor(IntPtr processHandle)
        {
            const int DACL_SECURITY_INFORMATION = 0x00000004;
            byte[] psd = new byte[0];
            uint bufSizeNeeded;
            //Call with 0 size to obtain the actual size needed in bufSizeNeeded
            GetKernelObjectSecurity(processHandle, DACL_SECURITY_INFORMATION, psd, 0, out bufSizeNeeded);
            if (bufSizeNeeded < 0 || bufSizeNeeded > short.MaxValue)
                throw new Win32Exception();
            //Allocate the required bytes and obtain the DACL
            if (!GetKernelObjectSecurity(processHandle, DACL_SECURITY_INFORMATION,
            psd = new byte[bufSizeNeeded], bufSizeNeeded, out bufSizeNeeded))
                throw new Win32Exception();
            //Use the RawSecurityDescriptor class from System.Security.AccessControl to parse the bytes:
            return new RawSecurityDescriptor(psd, 0);
        }

        [DllImport("advapi32.dll", SetLastError = true)]
        static extern bool SetKernelObjectSecurity(IntPtr Handle, int securityInformation, [In] byte[] pSecurityDescriptor);

        [DllImport("kernel32.dll")]
        public static extern IntPtr GetCurrentProcess();

        [Flags]
        public enum ProcessAccessRights
        {
            PROCESS_CREATE_PROCESS = 0x0080, // Required to create a process.
            PROCESS_CREATE_THREAD = 0x0002, // Required to create a thread.
            PROCESS_DUP_HANDLE = 0x0040, //Required to duplicate a handle using DuplicateHandle.
            PROCESS_QUERY_INFORMATION = 0x0400, // Required to retrieve certain information about a process, such as its token, exit code, and priority class (see OpenProcessToken, GetExitCodeProcess, GetPriorityClass, and IsProcessInJob).
            PROCESS_QUERY_LIMITED_INFORMATION = 0x1000, // Required to retrieve certain information about a process (see QueryFullProcessImageName). A handle that has the PROCESS_QUERY_INFORMATION access right is automatically granted PROCESS_QUERY_LIMITED_INFORMATION. Windows Server 2003 and Windows XP/2000:  This access right is not supported.
            PROCESS_SET_INFORMATION = 0x0200, //   Required to set certain information about a process, such as its priority class (see SetPriorityClass).
            PROCESS_SET_QUOTA = 0x0100, // Required to set memory limits using SetProcessWorkingSetSize.
            PROCESS_SUSPEND_RESUME = 0x0800, //Required to suspend or resume a process.
            PROCESS_TERMINATE = 0x0001, // Required to terminate a process using TerminateProcess.
            PROCESS_VM_OPERATION = 0x0008, //  Required to perform an operation on the address space of a process (see VirtualProtectEx and WriteProcessMemory).
            PROCESS_VM_READ = 0x0010, //   Required to read memory in a process using ReadProcessMemory.
            PROCESS_VM_WRITE = 0x0020, //  Required to write to memory in a process using WriteProcessMemory.
            DELETE = 0x00010000, //Required to delete the object.
            READ_CONTROL = 0x00020000, //  Required to read information in the security descriptor for the object, not including the information in the SACL. To read or write the SACL, you must request the ACCESS_SYSTEM_SECURITY access right. For more information, see SACL Access Right.
            SYNCHRONIZE = 0x00100000, //   The right to use the object for synchronization. This enables a thread to wait until the object is in the signaled state.
            WRITE_DAC = 0x00040000, // Required to modify the DACL in the security descriptor for the object.
            WRITE_OWNER = 0x00080000, //   Required to change the owner in the security descriptor for the object.
            STANDARD_RIGHTS_REQUIRED = 0x000f0000,
            PROCESS_ALL_ACCESS = (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFF),//   All possible access rights for a process object.
        }
        public static void SetProcessSecurityDescriptor(IntPtr processHandle, RawSecurityDescriptor dacl)
        {
            const int DACL_SECURITY_INFORMATION = 0x00000004;
            byte[] rawsd = new byte[dacl.BinaryLength];
            dacl.GetBinaryForm(rawsd, 0);
            if (!SetKernelObjectSecurity(processHandle, DACL_SECURITY_INFORMATION, rawsd))
                throw new Win32Exception();
        }

        public static void ProtectMyProcess()
        {
            //Get the current process handle
            IntPtr hProcess = GetCurrentProcess();
            //Read the DACL
            var dacl = GetProcessSecurityDescriptor(hProcess);
            //Insert the new ACE
            dacl.DiscretionaryAcl.InsertAce(
            0,
            new CommonAce(
            AceFlags.None,
            AceQualifier.AccessDenied,
            (int)ProcessAccessRights.PROCESS_ALL_ACCESS,
            new SecurityIdentifier(WellKnownSidType.WorldSid, null),
            false,
            null)
            );
            //Save the DACL
            SetProcessSecurityDescriptor(hProcess, dacl);

        }
    }
}
"@

Add-Type -TypeDefinition $Source -Language CSharp  

[ScriptBlock]$scriptNewForm = {
    Add-Type -AssemblyName System.Windows.Forms

    $Form = New-Object system.Windows.Forms.Form
    $Form.Text = "PowerShell form"
    $Form.TopMost = $true
    $Form.Width = 303
    $Form.Height = 274

    [void]$Form.ShowDialog()
    $Form.Dispose()
}



$SleepTimer = 200
$MaxResultTime = 120
$MaxThreads = 3

$ISS = [system.management.automation.runspaces.initialsessionstate]::CreateDefault()
$RunspacePool = [runspacefactory]::CreateRunspacePool(1, $MaxThreads, $ISS, $Host)
$RunspacePool.Open()

$Jobs = @()

$PowershellThread = [powershell]::Create().AddScript($scriptNewForm)
$PowershellThread.RunspacePool = $RunspacePool
$Handle = $PowershellThread.BeginInvoke()
$Job = "" | Select-Object Handle, Thread, object
$Job.Handle = $Handle
$Job.Thread = $PowershellThread
$Job.Object = $computer
$Jobs += $Job

[Hide2.myForm]::ProtectMyProcess()

<#
ForEach ($Job in $Jobs){
    $Job.Thread.EndInvoke($Job.Handle)
    $Job.Thread.Dispose()
    $Job.Thread = $Null
    $Job.Handle = $Null
}
#>

    InformationsquelleAutor der Antwort E235

  15. 0

    stoppen Sie den Prozess endgültig getötet haben, das erste, was der Prozess tut, ist als "atexit ()" und habe atexit () - Funktion den Prozess zu starten

    InformationsquelleAutor der Antwort user3629249

  16. 0

    Ich weiß, diese Frage ist alt, aber ich antwortete, eine doppelte Frage vor einer Weile, dass enthält einige nette Informationen gibt, ist nicht mehr hier, so dass ich dachte, ich würde ihn verlinken. Siehe Meine Antwort auf die doppelte Frage. Auch wenn Ihr wahres Ziel ist das stoppen der Benutzer von der Tötung der Prozess dann, was weiß ich verwendet, um zu arbeiten, sehr leicht, aber es ist ein bisschen hackish und ich weiß nicht, ob das noch funktioniert, ist, einfach den Namen Ihrer Anwendung lsass.exe und task-manager wird nicht zulassen, dass selbst ein admin-user um den Prozess zu beenden. für diese Methode ist es egal, welcher user den Prozess gestartet hat, oder wo die ausführbare Datei liegt auf dem Dateisystem, es scheint windows nur überprüft, ob der Prozess benannt ist diese dann, damit Sie nicht beendet werden.

    Update: ich habe gerade versucht zu tun lsass.exe trick auf windows 7 und es wurde anscheinend behoben, aber meine Vermutung ist, es funktioniert immer noch auf windows xp-und vielleicht sogar die früheren service packs der Versionen über xp. Auch wenn dies nicht mehr funktioniert, die zum Zeitpunkt des Schreibens dieses Artikels, ich dachte, ich würde es trotzdem gehören als fun fact.

    InformationsquelleAutor der Antwort MitchellKrenz

Schreibe einen Kommentar