Windows Tresor per GPO leeren?

for /f "tokens=1,* delims=: " %%a in ('cmdkey /list ^| findstr /i "Ziel:"') do @cmdkey /delete:"%%b"  

cmdkey /list | ?{$_ -match 'Ziel: (.*)'} | %{cmdkey /delete:"$($matches[1])"}  

$code = @"  
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.InteropServices;

public static class CredentialManager
{
    public static Credential ReadCredential(string applicationName, CredentialType credType)
    {
        IntPtr nCredPtr;
        bool read = CredRead(applicationName, credType, 0, out nCredPtr);
        if (read)
        {
                CREDENTIAL cred = (CREDENTIAL)Marshal.PtrToStructure(nCredPtr, typeof(CREDENTIAL));
                return ReadCredential(cred);
        }

        return null;
    }

    private static Credential ReadCredential(CREDENTIAL credential)
    {
        string applicationName = Marshal.PtrToStringUni(credential.TargetName);
        string userName = Marshal.PtrToStringUni(credential.UserName);
        string secret = null;
        if (credential.CredentialBlob != IntPtr.Zero)
        {
            secret = Marshal.PtrToStringUni(credential.CredentialBlob, (int)credential.CredentialBlobSize / 2);
        }

        return new Credential(credential.Type, applicationName, userName, secret);
    }

   
    public static IReadOnlyList<Credential> EnumerateCredentials()
    {
        List<Credential> result = new List<Credential>();

        int count;
        IntPtr pCredentials;
        bool ret = CredEnumerate(null, 0, out count, out pCredentials);
        if (count > 0) { 
            if (ret)
            {
                for (int n = 0; n < count; n++)
                {
                    IntPtr credential = Marshal.ReadIntPtr(pCredentials, n * Marshal.SizeOf(typeof(IntPtr)));
                    result.Add(ReadCredential((CREDENTIAL)Marshal.PtrToStructure(credential, typeof(CREDENTIAL))));
                }
            }
            else
            {
                int lastError = Marshal.GetLastWin32Error();
                throw new Win32Exception(lastError);
            }
            return result;
        }
        return result;
    }

    public static bool DeleteCredential(string Applicationname,CredentialType credType)
    {
        Credential cred = ReadCredential(Applicationname, credType);
        if (cred != null)
        {
            bool result = CredDelete(cred.ApplicationName, cred.CredentialType, 0);
            if (!result)
            {
                int lastError = Marshal.GetLastWin32Error();
                throw new Win32Exception(lastError);
            }
            return result;
        }
        else
        {
            throw new Exception();
        }
    }
    
    public static void DeleteAllCredentials() {
        IReadOnlyList<Credential> all = EnumerateCredentials();
        if (all.Count > 0) {
            foreach (Credential cred in all) {
                DeleteCredential(cred.ApplicationName, cred.CredentialType);
            }
        }
    }

    [DllImport("Advapi32.dll", EntryPoint = "CredReadW", CharSet = CharSet.Unicode, SetLastError = true)]  
    static extern bool CredRead(string target, CredentialType type, int reservedFlag, out IntPtr credentialPtr);

    [DllImport("advapi32", SetLastError = true, CharSet = CharSet.Unicode)]  
    static extern bool CredEnumerate(string filter, int flag, out int count, out IntPtr pCredentials);

    [DllImport("Advapi32.dll", EntryPoint = "CredFree", SetLastError = true)]  
    static extern bool CredFree([In] IntPtr cred);

    [DllImport("advapi32.dll", EntryPoint = "CredDeleteW", CharSet = CharSet.Unicode, SetLastError = true)]  
    private static extern bool CredDelete(string target, CredentialType type, int flags);


    private enum CredentialPersistence : uint
    {
        Session = 1,
        LocalMachine,
        Enterprise
    }

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    private struct CREDENTIAL
    {
        public uint Flags;
        public CredentialType Type;
        public IntPtr TargetName;
        public IntPtr Comment;
        public System.Runtime.InteropServices.ComTypes.FILETIME LastWritten;
        public uint CredentialBlobSize;
        public IntPtr CredentialBlob;
        public uint Persist;
        public uint AttributeCount;
        public IntPtr Attributes;
        public IntPtr TargetAlias;
        public IntPtr UserName;
    }
}

public enum CredentialType
{
    Generic = 1,
    DomainPassword,
    DomainCertificate,
    DomainVisiblePassword,
    GenericCertificate,
    DomainExtended,
    Maximum,
    MaximumEx = Maximum + 1000,
}

public class Credential
{
    private readonly string _applicationName;
    private readonly string _userName;
    private readonly string _password;
    private readonly CredentialType _credentialType;

    public CredentialType CredentialType
    {
        get { return _credentialType; }
    }

    public string ApplicationName
    {
        get { return _applicationName; }
    }

    public string UserName
    {
        get { return _userName; }
    }

    public string Password
    {
        get { return _password; }
    }

    public Credential(CredentialType credentialType, string applicationName, string userName, string password)
    {
        _applicationName = applicationName;
        _userName = userName;
        _password = password;
        _credentialType = credentialType;
    }

    public override string ToString()
    {
        return string.Format("CredentialType: {0}, ApplicationName: {1}, UserName: {2}, Password: {3}", CredentialType, ApplicationName, UserName, Password);  
    }
}

"@  
Add-Type -TypeDefinition $code
[CredentialManager]::DeleteAllCredentials()

$showWindowAsync = Add-Type –memberDefinition @"   
[DllImport("user32.dll")]   
public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow); 
"@ -name "Win32ShowWindowAsync" -namespace Win32Functions –passThru  
[void]$showWindowAsync::ShowWindowAsync((Get-Process –id $pid).MainWindowHandle, 0) 

# und hier der Rest