This script will add a list of credentials to the Windows Credential Manager and then map some drives. It will also then change your default documents location to a network UNC path.
To use just change your network locations in the drive mapping section at the end and update the usernames and passwords.
function add-creds {
<#
.Synopsis
Provides access to Windows CredMan basic functionality for client scripts
****************** IMPORTANT ******************
*
* If you use this script from the PS console, you
* should ALWAYS pass the Target, User and Password
* parameters using single quotes:
*
* add-creds -AddCred -Target 'http://server' -User 'JoeSchmuckatelli' -Pass 'P@55w0rd!'
*
* to prevent PS misinterpreting special characters
* you might use as PS reserved characters
*
****************** IMPORTANT ******************
.Description
Provides the following API when dot-sourced
Del-Cred
Enum-Creds
Read-Cred
Write-Cred
Supports the following cmd-line actions
AddCred (requires -User, -Pass; -Target is optional)
DelCred (requires -Target)
GetCred (requires -Target)
RunTests (no cmd-line opts)
ShoCred (optional -All parameter to dump cred objects to console)
.INPUTS
See function-level notes
.OUTPUTS
Cmd-line usage: console output relative to success or failure state
Dot-sourced usage:
** Successful Action **
* Del-Cred : Int = 0
* Enum-Cred : PsUtils.CredMan+Credential[]
* Read-Cred : PsUtils.CredMan+Credential
* Write-Cred : Int = 0
** Failure **
* All API : Management.Automation.ErrorRecord
.NOTES
Author: Jim Harrison (jim@isatools.org)
Date : 2012/05/20
Vers : 1.5
Updates:
2012/10/13
- Fixed a bug where the script would only read, write or delete GENERIC
credentials types.
- Added #region blocks to clarify internal functionality
- Added 'CredType' param to specify what sort of credential is to be read,
created or deleted (not used for -ShoCred or Enum-Creds)
- Added 'CredPersist' param to specify how the credential is to be stored;
only used in Write-Cred
- Added 'All' param for -ShoCreds to differentiate between creds summary
list and detailed creds dump
- Added CRED_FLAGS enum to make the credential struct flags values clearer
- Improved parameter validation
- Expanded internal help (used with Get-Help cmdlet)
- Cmd-line functions better illustrate how to interpret the results when
dot-sourcing the script
.PARAMETER AddCred
Specifies that you wish to add a new credential or update an existing credentials
-Target, -User and -Pass parameters are required for this action
.PARAMETER Comment
Specifies the information you wish to place in the credentials comment field
.PARAMETER CredPersist
Specifies the credentials storage persistence you wish to use
Valid values are: "SESSION", "LOCAL_MACHINE", "ENTERPRISE"
NOTE: if not specified, defaults to "ENTERPRISE"
.PARAMETER CredType
Specifies the type of credential object you want to store
Valid values are: "GENERIC", "DOMAIN_PASSWORD", "DOMAIN_CERTIFICATE",
"DOMAIN_VISIBLE_PASSWORD", "GENERIC_CERTIFICATE", "DOMAIN_EXTENDED",
"MAXIMUM", "MAXIMUM_EX"
NOTE: if not specified, defaults to "GENERIC"
****************** IMPORTANT ******************
*
* I STRONGLY recommend that you become familiar
* with http://msdn.microsoft.com/en-us/library/windows/desktop/aa374788(v=vs.85).aspx
* before you create new credentials with -CredType other than "GENERIC"
*
****************** IMPORTANT ******************
.PARAMETER DelCred
Specifies that you wish to remove an existing credential
-CredType may be required to remove the correct credential if more than one is
specified for a target
.PARAMETER GetCred
Specifies that you wish to retrieve an existing credential
-CredType may be required to access the correct credential if more than one is
specified for a target
.PARAMETER Pass
Specifies the credentials password
.PARAMETER RunTests
Specifies that you wish to run built-in Win32 CredMan functionality tests
.PARAMETER ShoCred
Specifies that you wish to retrieve all credential stored for the interactive user
-All parameter may be used to indicate that you wish to view all credentials properties
(default display is a summary list)
.PARAMETER Target
Specifies the authentication target for the specified credentials
If not specified, the -User information is used
.PARAMETER User
Specifies the credentials username
.LINK
http://msdn.microsoft.com/en-us/library/windows/desktop/aa374788(v=vs.85).aspx
http://stackoverflow.com/questions/7162604/get-cached-credentials-in-powershell-from-windows-7-credential-manager
http://msdn.microsoft.com/en-us/library/windows/desktop/aa374788(v=vs.85).aspx
http://blogs.msdn.com/b/peerchan/archive/2005/11/01/487834.aspx
.EXAMPLE
add-creds -AddCred -Target 'http://aserver' -User 'UserName' -Password 'P@55w0rd!' -Comment 'cuziwanna'
Stores the credential for 'UserName' with a password of 'P@55w0rd!' for authentication against 'http://aserver' and adds a comment of 'cuziwanna'
.EXAMPLE
add-creds -DelCred -Target 'http://aserver' -CredType 'DOMAIN_PASSWORD'
Removes the credential used for the target 'http://aserver' as credentials type 'DOMAIN_PASSWORD'
.EXAMPLE
add-creds -GetCred -Target 'http://aserver'
Retreives the credential used for the target 'http://aserver'
.EXAMPLE
add-creds -ShoCred
Retrieves a summary list of all credentials stored for the interactive user
.EXAMPLE
add-creds -ShoCred -All
Retrieves a detailed list of all credentials stored for the interactive user
#>
#requires -version 2
Param
(
[Parameter(Mandatory=$false)][Switch] $AddCred,
[Parameter(Mandatory=$false)][Switch] $DelCred,
[Parameter(Mandatory=$false)][Switch] $GetCred,
[Parameter(Mandatory=$false)][Switch] $ShoCred,
[Parameter(Mandatory=$false)][Switch] $RunTests,
[Parameter(Mandatory=$false)][ValidateLength(1,32767) <# CRED_MAX_GENERIC_TARGET_NAME_LENGTH #>][String] $Target,
[Parameter(Mandatory=$false)][ValidateLength(1,512) <# CRED_MAX_USERNAME_LENGTH #>][String] $User,
[Parameter(Mandatory=$false)][ValidateLength(1,512) <# CRED_MAX_CREDENTIAL_BLOB_SIZE #>][String] $Pass,
[Parameter(Mandatory=$false)][ValidateLength(1,256) <# CRED_MAX_STRING_LENGTH #>][String] $Comment,
[Parameter(Mandatory=$false)][Switch] $All,
[Parameter(Mandatory=$false)][ValidateSet("GENERIC",
"DOMAIN_PASSWORD",
"DOMAIN_CERTIFICATE",
"DOMAIN_VISIBLE_PASSWORD",
"GENERIC_CERTIFICATE",
"DOMAIN_EXTENDED",
"MAXIMUM",
"MAXIMUM_EX")][String] $CredType = "GENERIC",
[Parameter(Mandatory=$false)][ValidateSet("SESSION",
"LOCAL_MACHINE",
"ENTERPRISE")][String] $CredPersist = "ENTERPRISE"
)
#region Pinvoke
#region Inline C#
[String] $PsCredmanUtils = @"
using System;
using System.Runtime.InteropServices;
namespace PsUtils
{
public class CredMan
{
#region Imports
// DllImport derives from System.Runtime.InteropServices
[DllImport("Advapi32.dll", SetLastError = true, EntryPoint = "CredDeleteW", CharSet = CharSet.Unicode)]
private static extern bool CredDeleteW([In] string target, [In] CRED_TYPE type, [In] int reservedFlag);
[DllImport("Advapi32.dll", SetLastError = true, EntryPoint = "CredEnumerateW", CharSet = CharSet.Unicode)]
private static extern bool CredEnumerateW([In] string Filter, [In] int Flags, out int Count, out IntPtr CredentialPtr);
[DllImport("Advapi32.dll", SetLastError = true, EntryPoint = "CredFree")]
private static extern void CredFree([In] IntPtr cred);
[DllImport("Advapi32.dll", SetLastError = true, EntryPoint = "CredReadW", CharSet = CharSet.Unicode)]
private static extern bool CredReadW([In] string target, [In] CRED_TYPE type, [In] int reservedFlag, out IntPtr CredentialPtr);
[DllImport("Advapi32.dll", SetLastError = true, EntryPoint = "CredWriteW", CharSet = CharSet.Unicode)]
private static extern bool CredWriteW([In] ref Credential userCredential, [In] UInt32 flags);
#endregion
#region Fields
public enum CRED_FLAGS : uint
{
NONE = 0x0,
PROMPT_NOW = 0x2,
USERNAME_TARGET = 0x4
}
public enum CRED_ERRORS : uint
{
ERROR_SUCCESS = 0x0,
ERROR_INVALID_PARAMETER = 0x80070057,
ERROR_INVALID_FLAGS = 0x800703EC,
ERROR_NOT_FOUND = 0x80070490,
ERROR_NO_SUCH_LOGON_SESSION = 0x80070520,
ERROR_BAD_USERNAME = 0x8007089A
}
public enum CRED_PERSIST : uint
{
SESSION = 1,
LOCAL_MACHINE = 2,
ENTERPRISE = 3
}
public enum CRED_TYPE : uint
{
GENERIC = 1,
DOMAIN_PASSWORD = 2,
DOMAIN_CERTIFICATE = 3,
DOMAIN_VISIBLE_PASSWORD = 4,
GENERIC_CERTIFICATE = 5,
DOMAIN_EXTENDED = 6,
MAXIMUM = 7, // Maximum supported cred type
MAXIMUM_EX = (MAXIMUM + 1000), // Allow new applications to run on old OSes
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct Credential
{
public CRED_FLAGS Flags;
public CRED_TYPE Type;
public string TargetName;
public string Comment;
public DateTime LastWritten;
public UInt32 CredentialBlobSize;
public string CredentialBlob;
public CRED_PERSIST Persist;
public UInt32 AttributeCount;
public IntPtr Attributes;
public string TargetAlias;
public string UserName;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
private struct NativeCredential
{
public CRED_FLAGS Flags;
public CRED_TYPE Type;
public IntPtr TargetName;
public IntPtr Comment;
public System.Runtime.InteropServices.ComTypes.FILETIME LastWritten;
public UInt32 CredentialBlobSize;
public IntPtr CredentialBlob;
public UInt32 Persist;
public UInt32 AttributeCount;
public IntPtr Attributes;
public IntPtr TargetAlias;
public IntPtr UserName;
}
#endregion
#region Child Class
private class CriticalCredentialHandle : Microsoft.Win32.SafeHandles.CriticalHandleZeroOrMinusOneIsInvalid
{
public CriticalCredentialHandle(IntPtr preexistingHandle)
{
SetHandle(preexistingHandle);
}
private Credential XlateNativeCred(IntPtr pCred)
{
NativeCredential ncred = (NativeCredential)Marshal.PtrToStructure(pCred, typeof(NativeCredential));
Credential cred = new Credential();
cred.Type = ncred.Type;
cred.Flags = ncred.Flags;
cred.Persist = (CRED_PERSIST)ncred.Persist;
long LastWritten = ncred.LastWritten.dwHighDateTime;
LastWritten = (LastWritten << 32) + ncred.LastWritten.dwLowDateTime;
cred.LastWritten = DateTime.FromFileTime(LastWritten);
cred.UserName = Marshal.PtrToStringUni(ncred.UserName);
cred.TargetName = Marshal.PtrToStringUni(ncred.TargetName);
cred.TargetAlias = Marshal.PtrToStringUni(ncred.TargetAlias);
cred.Comment = Marshal.PtrToStringUni(ncred.Comment);
cred.CredentialBlobSize = ncred.CredentialBlobSize;
if (0 < ncred.CredentialBlobSize)
{
cred.CredentialBlob = Marshal.PtrToStringUni(ncred.CredentialBlob, (int)ncred.CredentialBlobSize / 2);
}
return cred;
}
public Credential GetCredential()
{
if (IsInvalid)
{
throw new InvalidOperationException("Invalid CriticalHandle!");
}
Credential cred = XlateNativeCred(handle);
return cred;
}
public Credential[] GetCredentials(int count)
{
if (IsInvalid)
{
throw new InvalidOperationException("Invalid CriticalHandle!");
}
Credential[] Credentials = new Credential[count];
IntPtr pTemp = IntPtr.Zero;
for (int inx = 0; inx < count; inx++)
{
pTemp = Marshal.ReadIntPtr(handle, inx * IntPtr.Size);
Credential cred = XlateNativeCred(pTemp);
Credentials[inx] = cred;
}
return Credentials;
}
override protected bool ReleaseHandle()
{
if (IsInvalid)
{
return false;
}
CredFree(handle);
SetHandleAsInvalid();
return true;
}
}
#endregion
#region Custom API
public static int CredDelete(string target, CRED_TYPE type)
{
if (!CredDeleteW(target, type, 0))
{
return Marshal.GetHRForLastWin32Error();
}
return 0;
}
public static int CredEnum(string Filter, out Credential[] Credentials)
{
int count = 0;
int Flags = 0x0;
if (string.IsNullOrEmpty(Filter) ||
"*" == Filter)
{
Filter = null;
if (6 <= Environment.OSVersion.Version.Major)
{
Flags = 0x1; //CRED_ENUMERATE_ALL_CREDENTIALS; only valid is OS >= Vista
}
}
IntPtr pCredentials = IntPtr.Zero;
if (!CredEnumerateW(Filter, Flags, out count, out pCredentials))
{
Credentials = null;
return Marshal.GetHRForLastWin32Error();
}
CriticalCredentialHandle CredHandle = new CriticalCredentialHandle(pCredentials);
Credentials = CredHandle.GetCredentials(count);
return 0;
}
public static int CredRead(string target, CRED_TYPE type, out Credential Credential)
{
IntPtr pCredential = IntPtr.Zero;
Credential = new Credential();
if (!CredReadW(target, type, 0, out pCredential))
{
return Marshal.GetHRForLastWin32Error();
}
CriticalCredentialHandle CredHandle = new CriticalCredentialHandle(pCredential);
Credential = CredHandle.GetCredential();
return 0;
}
public static int CredWrite(Credential userCredential)
{
if (!CredWriteW(ref userCredential, 0))
{
return Marshal.GetHRForLastWin32Error();
}
return 0;
}
#endregion
private static int AddCred()
{
Credential Cred = new Credential();
string Password = "Password";
Cred.Flags = 0;
Cred.Type = CRED_TYPE.GENERIC;
Cred.TargetName = "Target";
Cred.UserName = "UserName";
Cred.AttributeCount = 0;
Cred.Persist = CRED_PERSIST.ENTERPRISE;
Cred.CredentialBlobSize = (uint)Password.Length;
Cred.CredentialBlob = Password;
Cred.Comment = "Comment";
return CredWrite(Cred);
}
private static bool CheckError(string TestName, CRED_ERRORS Rtn)
{
switch(Rtn)
{
case CRED_ERRORS.ERROR_SUCCESS:
Console.WriteLine(string.Format("'{0}' worked", TestName));
return true;
case CRED_ERRORS.ERROR_INVALID_FLAGS:
case CRED_ERRORS.ERROR_INVALID_PARAMETER:
case CRED_ERRORS.ERROR_NO_SUCH_LOGON_SESSION:
case CRED_ERRORS.ERROR_NOT_FOUND:
case CRED_ERRORS.ERROR_BAD_USERNAME:
Console.WriteLine(string.Format("'{0}' failed; {1}.", TestName, Rtn));
break;
default:
Console.WriteLine(string.Format("'{0}' failed; 0x{1}.", TestName, Rtn.ToString("X")));
break;
}
return false;
}
/*
* Note: the Main() function is primarily for debugging and testing in a Visual
* Studio session. Although it will work from PowerShell, it's not very useful.
*/
public static void Main()
{
Credential[] Creds = null;
Credential Cred = new Credential();
int Rtn = 0;
Console.WriteLine("Testing CredWrite()");
Rtn = AddCred();
if (!CheckError("CredWrite", (CRED_ERRORS)Rtn))
{
return;
}
Console.WriteLine("Testing CredEnum()");
Rtn = CredEnum(null, out Creds);
if (!CheckError("CredEnum", (CRED_ERRORS)Rtn))
{
return;
}
Console.WriteLine("Testing CredRead()");
Rtn = CredRead("Target", CRED_TYPE.GENERIC, out Cred);
if (!CheckError("CredRead", (CRED_ERRORS)Rtn))
{
return;
}
Console.WriteLine("Testing CredDelete()");
Rtn = CredDelete("Target", CRED_TYPE.GENERIC);
if (!CheckError("CredDelete", (CRED_ERRORS)Rtn))
{
return;
}
Console.WriteLine("Testing CredRead() again");
Rtn = CredRead("Target", CRED_TYPE.GENERIC, out Cred);
if (!CheckError("CredRead", (CRED_ERRORS)Rtn))
{
Console.WriteLine("if the error is 'ERROR_NOT_FOUND', this result is OK.");
}
}
}
}
"@
#endregion
$PsCredMan = $null
try
{
$PsCredMan = [PsUtils.CredMan]
}
catch
{
#only remove the error we generate
$Error.RemoveAt($Error.Count-1)
}
if($null -eq $PsCredMan)
{
Add-Type $PsCredmanUtils
}
#endregion
#region Internal Tools
[HashTable] $ErrorCategory = @{0x80070057 = "InvalidArgument";
0x800703EC = "InvalidData";
0x80070490 = "ObjectNotFound";
0x80070520 = "SecurityError";
0x8007089A = "SecurityError"}
function Get-CredType
{
Param
(
[Parameter(Mandatory=$true)][ValidateSet("GENERIC",
"DOMAIN_PASSWORD",
"DOMAIN_CERTIFICATE",
"DOMAIN_VISIBLE_PASSWORD",
"GENERIC_CERTIFICATE",
"DOMAIN_EXTENDED",
"MAXIMUM",
"MAXIMUM_EX")][String] $CredType
)
switch($CredType)
{
"GENERIC" {return [PsUtils.CredMan+CRED_TYPE]::GENERIC}
"DOMAIN_PASSWORD" {return [PsUtils.CredMan+CRED_TYPE]::DOMAIN_PASSWORD}
"DOMAIN_CERTIFICATE" {return [PsUtils.CredMan+CRED_TYPE]::DOMAIN_CERTIFICATE}
"DOMAIN_VISIBLE_PASSWORD" {return [PsUtils.CredMan+CRED_TYPE]::DOMAIN_VISIBLE_PASSWORD}
"GENERIC_CERTIFICATE" {return [PsUtils.CredMan+CRED_TYPE]::GENERIC_CERTIFICATE}
"DOMAIN_EXTENDED" {return [PsUtils.CredMan+CRED_TYPE]::DOMAIN_EXTENDED}
"MAXIMUM" {return [PsUtils.CredMan+CRED_TYPE]::MAXIMUM}
"MAXIMUM_EX" {return [PsUtils.CredMan+CRED_TYPE]::MAXIMUM_EX}
}
}
function Get-CredPersist
{
Param
(
[Parameter(Mandatory=$true)][ValidateSet("SESSION",
"LOCAL_MACHINE",
"ENTERPRISE")][String] $CredPersist
)
switch($CredPersist)
{
"SESSION" {return [PsUtils.CredMan+CRED_PERSIST]::SESSION}
"LOCAL_MACHINE" {return [PsUtils.CredMan+CRED_PERSIST]::LOCAL_MACHINE}
"ENTERPRISE" {return [PsUtils.CredMan+CRED_PERSIST]::ENTERPRISE}
}
}
#endregion
#region Dot-Sourced API
function Del-Creds
{
<#
.Synopsis
Deletes the specified credentials
.Description
Calls Win32 CredDeleteW via [PsUtils.CredMan]::CredDelete
.INPUTS
See function-level notes
.OUTPUTS
0 or non-0 according to action success
[Management.Automation.ErrorRecord] if error encountered
.PARAMETER Target
Specifies the URI for which the credentials are associated
.PARAMETER CredType
Specifies the desired credentials type; defaults to
"CRED_TYPE_GENERIC"
#>
Param
(
[Parameter(Mandatory=$true)][ValidateLength(1,32767)][String] $Target,
[Parameter(Mandatory=$false)][ValidateSet("GENERIC",
"DOMAIN_PASSWORD",
"DOMAIN_CERTIFICATE",
"DOMAIN_VISIBLE_PASSWORD",
"GENERIC_CERTIFICATE",
"DOMAIN_EXTENDED",
"MAXIMUM",
"MAXIMUM_EX")][String] $CredType = "GENERIC"
)
[Int] $Results = 0
try
{
$Results = [PsUtils.CredMan]::CredDelete($Target, $(Get-CredType $CredType))
}
catch
{
return $_
}
if(0 -ne $Results)
{
[String] $Msg = "Failed to delete credentials store for target '$Target'"
[Management.ManagementException] $MgmtException = New-Object Management.ManagementException($Msg)
[Management.Automation.ErrorRecord] $ErrRcd = New-Object Management.Automation.ErrorRecord($MgmtException, $Results.ToString("X"), $ErrorCategory[$Results], $null)
return $ErrRcd
}
return $Results
}
function Enum-Creds
{
<#
.Synopsis
Enumerates stored credentials for operating user
.Description
Calls Win32 CredEnumerateW via [PsUtils.CredMan]::CredEnum
.INPUTS
.OUTPUTS
[PsUtils.CredMan+Credential[]] if successful
[Management.Automation.ErrorRecord] if unsuccessful or error encountered
.PARAMETER Filter
Specifies the filter to be applied to the query
Defaults to [String]::Empty
#>
Param
(
[Parameter(Mandatory=$false)][AllowEmptyString()][String] $Filter = [String]::Empty
)
[PsUtils.CredMan+Credential[]] $Creds = [Array]::CreateInstance([PsUtils.CredMan+Credential], 0)
[Int] $Results = 0
try
{
$Results = [PsUtils.CredMan]::CredEnum($Filter, [Ref]$Creds)
}
catch
{
return $_
}
switch($Results)
{
0 {break}
0x80070490 {break} #ERROR_NOT_FOUND
default
{
[String] $Msg = "Failed to enumerate credentials store for user '$Env:UserName'"
[Management.ManagementException] $MgmtException = New-Object Management.ManagementException($Msg)
[Management.Automation.ErrorRecord] $ErrRcd = New-Object Management.Automation.ErrorRecord($MgmtException, $Results.ToString("X"), $ErrorCategory[$Results], $null)
return $ErrRcd
}
}
return $Creds
}
function Read-Creds
{
<#
.Synopsis
Reads specified credentials for operating user
.Description
Calls Win32 CredReadW via [PsUtils.CredMan]::CredRead
.INPUTS
.OUTPUTS
[PsUtils.CredMan+Credential] if successful
[Management.Automation.ErrorRecord] if unsuccessful or error encountered
.PARAMETER Target
Specifies the URI for which the credentials are associated
If not provided, the username is used as the target
.PARAMETER CredType
Specifies the desired credentials type; defaults to
"CRED_TYPE_GENERIC"
#>
Param
(
[Parameter(Mandatory=$true)][ValidateLength(1,32767)][String] $Target,
[Parameter(Mandatory=$false)][ValidateSet("GENERIC",
"DOMAIN_PASSWORD",
"DOMAIN_CERTIFICATE",
"DOMAIN_VISIBLE_PASSWORD",
"GENERIC_CERTIFICATE",
"DOMAIN_EXTENDED",
"MAXIMUM",
"MAXIMUM_EX")][String] $CredType = "GENERIC"
)
if("GENERIC" -ne $CredType -and 337 -lt $Target.Length) #CRED_MAX_DOMAIN_TARGET_NAME_LENGTH
{
[String] $Msg = "Target field is longer ($($Target.Length)) than allowed (max 337 characters)"
[Management.ManagementException] $MgmtException = New-Object Management.ManagementException($Msg)
[Management.Automation.ErrorRecord] $ErrRcd = New-Object Management.Automation.ErrorRecord($MgmtException, 666, 'LimitsExceeded', $null)
return $ErrRcd
}
[PsUtils.CredMan+Credential] $Cred = New-Object PsUtils.CredMan+Credential
[Int] $Results = 0
try
{
$Results = [PsUtils.CredMan]::CredRead($Target, $(Get-CredType $CredType), [Ref]$Cred)
}
catch
{
return $_
}
switch($Results)
{
0 {break}
0x80070490 {return $null} #ERROR_NOT_FOUND
default
{
[String] $Msg = "Error reading credentials for target '$Target' from '$Env:UserName' credentials store"
[Management.ManagementException] $MgmtException = New-Object Management.ManagementException($Msg)
[Management.Automation.ErrorRecord] $ErrRcd = New-Object Management.Automation.ErrorRecord($MgmtException, $Results.ToString("X"), $ErrorCategory[$Results], $null)
return $ErrRcd
}
}
return $Cred
}
function Write-Creds
{
<#
.Synopsis
Saves or updates specified credentials for operating user
.Description
Calls Win32 CredWriteW via [PsUtils.CredMan]::CredWrite
.INPUTS
.OUTPUTS
[Boolean] true if successful
[Management.Automation.ErrorRecord] if unsuccessful or error encountered
.PARAMETER Target
Specifies the URI for which the credentials are associated
If not provided, the username is used as the target
.PARAMETER UserName
Specifies the name of credential to be read
.PARAMETER Password
Specifies the password of credential to be read
.PARAMETER Comment
Allows the caller to specify the comment associated with
these credentials
.PARAMETER CredType
Specifies the desired credentials type; defaults to
"CRED_TYPE_GENERIC"
.PARAMETER CredPersist
Specifies the desired credentials storage type;
defaults to "CRED_PERSIST_ENTERPRISE"
#>
Param
(
[Parameter(Mandatory=$false)][ValidateLength(0,32676)][String] $Target,
[Parameter(Mandatory=$true)][ValidateLength(1,512)][String] $UserName,
[Parameter(Mandatory=$true)][ValidateLength(1,512)][String] $Password,
[Parameter(Mandatory=$false)][ValidateLength(0,256)][String] $Comment = [String]::Empty,
[Parameter(Mandatory=$false)][ValidateSet("GENERIC",
"DOMAIN_PASSWORD",
"DOMAIN_CERTIFICATE",
"DOMAIN_VISIBLE_PASSWORD",
"GENERIC_CERTIFICATE",
"DOMAIN_EXTENDED",
"MAXIMUM",
"MAXIMUM_EX")][String] $CredType = "GENERIC",
[Parameter(Mandatory=$false)][ValidateSet("SESSION",
"LOCAL_MACHINE",
"ENTERPRISE")][String] $CredPersist = "ENTERPRISE"
)
if([String]::IsNullOrEmpty($Target))
{
$Target = $UserName
}
if("GENERIC" -ne $CredType -and 337 -lt $Target.Length) #CRED_MAX_DOMAIN_TARGET_NAME_LENGTH
{
[String] $Msg = "Target field is longer ($($Target.Length)) than allowed (max 337 characters)"
[Management.ManagementException] $MgmtException = New-Object Management.ManagementException($Msg)
[Management.Automation.ErrorRecord] $ErrRcd = New-Object Management.Automation.ErrorRecord($MgmtException, 666, 'LimitsExceeded', $null)
return $ErrRcd
}
if([String]::IsNullOrEmpty($Comment))
{
$Comment = [String]::Format("Last edited by {0}\{1} on {2}",
$Env:UserDomain,
$Env:UserName,
$Env:ComputerName)
}
[String] $DomainName = [Net.NetworkInformation.IPGlobalProperties]::GetIPGlobalProperties().DomainName
[PsUtils.CredMan+Credential] $Cred = New-Object PsUtils.CredMan+Credential
switch($Target -eq $UserName -and
("CRED_TYPE_DOMAIN_PASSWORD" -eq $CredType -or
"CRED_TYPE_DOMAIN_CERTIFICATE" -eq $CredType))
{
$true {$Cred.Flags = [PsUtils.CredMan+CRED_FLAGS]::USERNAME_TARGET}
$false {$Cred.Flags = [PsUtils.CredMan+CRED_FLAGS]::NONE}
}
$Cred.Type = Get-CredType $CredType
$Cred.TargetName = $Target
$Cred.UserName = $UserName
$Cred.AttributeCount = 0
$Cred.Persist = Get-CredPersist $CredPersist
$Cred.CredentialBlobSize = [Text.Encoding]::Unicode.GetBytes($Password).Length
$Cred.CredentialBlob = $Password
$Cred.Comment = $Comment
[Int] $Results = 0
try
{
$Results = [PsUtils.CredMan]::CredWrite($Cred)
}
catch
{
return $_
}
if(0 -ne $Results)
{
[String] $Msg = "Failed to write to credentials store for target '$Target' using '$UserName', '$Password', '$Comment'"
[Management.ManagementException] $MgmtException = New-Object Management.ManagementException($Msg)
[Management.Automation.ErrorRecord] $ErrRcd = New-Object Management.Automation.ErrorRecord($MgmtException, $Results.ToString("X"), $ErrorCategory[$Results], $null)
return $ErrRcd
}
return $Results
}
#endregion
#region Cmd-Line functionality
function CredManMain
{
#region Adding credentials
if($AddCred)
{
if([String]::IsNullOrEmpty($User) -or
[String]::IsNullOrEmpty($Pass))
{
Write-Host "You must supply a user name and password (target URI is optional)."
return
}
# may be [Int32] or [Management.Automation.ErrorRecord]
[Object] $Results = Write-Creds $Target $User $Pass $Comment $CredType $CredPersist
if(0 -eq $Results)
{
[Object] $Cred = Read-Creds $Target $CredType
if($null -eq $Cred)
{
Write-Host "Credentials for '$Target', '$User' was not found."
return
}
if($Cred -is [Management.Automation.ErrorRecord])
{
return $Cred
}
[String] $CredStr = @"
Successfully wrote or updated credentials as:
UserName : $($Cred.UserName)
Password : $($Cred.CredentialBlob)
Target : $($Cred.TargetName.Substring($Cred.TargetName.IndexOf("=")+1))
Updated : $([String]::Format("{0:yyyy-MM-dd HH:mm:ss}", $Cred.LastWritten.ToUniversalTime())) UTC
Comment : $($Cred.Comment)
"@
Write-Host $CredStr
return
}
# will be a [Management.Automation.ErrorRecord]
return $Results
}
#endregion
#region Removing credentials
if($DelCred)
{
if(-not $Target)
{
Write-Host "You must supply a target URI."
return
}
# may be [Int32] or [Management.Automation.ErrorRecord]
[Object] $Results = Del-Creds $Target $CredType
if(0 -eq $Results)
{
Write-Host "Successfully deleted credentials for '$Target'"
return
}
# will be a [Management.Automation.ErrorRecord]
return $Results
}
#endregion
#region Reading selected credential
if($GetCred)
{
if(-not $Target)
{
Write-Host "You must supply a target URI."
return
}
# may be [PsUtils.CredMan+Credential] or [Management.Automation.ErrorRecord]
[Object] $Cred = Read-Creds $Target $CredType
if($null -eq $Cred)
{
Write-Host "Credential for '$Target' as '$CredType' type was not found."
return
}
if($Cred -is [Management.Automation.ErrorRecord])
{
return $Cred
}
[String] $CredStr = @"
Found credentials as:
UserName : $($Cred.UserName)
Password : $($Cred.CredentialBlob)
Target : $($Cred.TargetName.Substring($Cred.TargetName.IndexOf("=")+1))
Updated : $([String]::Format("{0:yyyy-MM-dd HH:mm:ss}", $Cred.LastWritten.ToUniversalTime())) UTC
Comment : $($Cred.Comment)
"@
Write-Host $CredStr
}
#endregion
#region Reading all credentials
if($ShoCred)
{
# may be [PsUtils.CredMan+Credential[]] or [Management.Automation.ErrorRecord]
[Object] $Creds = Enum-Creds
if($Creds -split [Array] -and 0 -eq $Creds.Length)
{
Write-Host "No Credentials found for $($Env:UserName)"
return
}
if($Creds -is [Management.Automation.ErrorRecord])
{
return $Creds
}
foreach($Cred in $Creds)
{
[String] $CredStr = @"
UserName : $($Cred.UserName)
Password : $($Cred.CredentialBlob)
Target : $($Cred.TargetName.Substring($Cred.TargetName.IndexOf("=")+1))
Updated : $([String]::Format("{0:yyyy-MM-dd HH:mm:ss}", $Cred.LastWritten.ToUniversalTime())) UTC
Comment : $($Cred.Comment)
"@
if($All)
{
$CredStr = @"
$CredStr
Alias : $($Cred.TargetAlias)
AttribCnt : $($Cred.AttributeCount)
Attribs : $($Cred.Attributes)
Flags : $($Cred.Flags)
Pwd Size : $($Cred.CredentialBlobSize)
Storage : $($Cred.Persist)
Type : $($Cred.Type)
"@
}
Write-Host $CredStr
}
return
}
#endregion
#region Run basic diagnostics
if($RunTests)
{
[PsUtils.CredMan]::Main()
}
#endregion
}
#endregion
CredManMain
}
cd C:\Temp
$MUser = $env:username
$NASUser = 'user'
$NASAdmin = 'admin'
if($MUser -eq $NASUser) {
add-creds -AddCred -Target '192.168.0.5' -User 'nasuser' -Pass 'MyPassword' -Comment 'NAS' -CredType 'DOMAIN_PASSWORD'
add-creds -AddCred -Target '192.168.0.6' -User 'nasuser' -Pass 'MyPassword' -Comment 'NAS'-CredType 'DOMAIN_PASSWORD'
add-creds -AddCred -Target '192.168.0.7' -User 'nasuser' -Pass 'MyPassword' -Comment 'NAS'-CredType 'DOMAIN_PASSWORD'
add-creds -AddCred -Target '192.168.0.8' -User 'nasuser' -Pass 'MyPassword' -Comment 'NAS'-CredType 'DOMAIN_PASSWORD'
add-creds -AddCred -Target '192.168.0.3' -User 'admin' -Pass 'MyPassword' -Comment 'Download Laptop'-CredType 'DOMAIN_PASSWORD'
add-creds -AddCred -Target '192.168.0.24' -User 'admin' -Pass 'MyPassword' -Comment 'office'-CredType 'DOMAIN_PASSWORD'
add-creds -AddCred -Target '192.168.0.20' -User 'admin' -Pass 'MyPassword' -Comment 'alfie'-CredType 'DOMAIN_PASSWORD'
}
if($MUser -eq $NASAdmin) {
add-creds -AddCred -Target '192.168.0.5' -User 'nasadmin' -Pass 'MyPassword' -Comment 'NAS' -CredType 'DOMAIN_PASSWORD'
add-creds -AddCred -Target '192.168.0.6' -User 'nasadmin' -Pass 'MyPassword' -Comment 'NAS'-CredType 'DOMAIN_PASSWORD'
add-creds -AddCred -Target '192.168.0.7' -User 'nasadmin' -Pass 'MyPassword' -Comment 'NAS'-CredType 'DOMAIN_PASSWORD'
add-creds -AddCred -Target '192.168.0.8' -User 'nasadmin' -Pass 'MyPassword' -Comment 'NAS'-CredType 'DOMAIN_PASSWORD'
add-creds -AddCred -Target '192.168.0.3' -User 'admin' -Pass 'MyPassword' -Comment 'Download Laptop'-CredType 'DOMAIN_PASSWORD'
add-creds -AddCred -Target '192.168.0.24' -User 'admin' -Pass 'MyPassword' -Comment 'office'-CredType 'DOMAIN_PASSWORD'
add-creds -AddCred -Target '192.168.0.20' -User 'admin' -Pass 'MyPassword' -Comment 'alfie'-CredType 'DOMAIN_PASSWORD'
}
$net = new-object -ComObject WScript.Network
$net.MapNetworkDrive("z:", "\\192.168.0.5\TV_Series", $true)
$net.MapNetworkDrive("w:", "\\192.168.0.5\Movies", $true)
$net.MapNetworkDrive("l:", "\\192.168.0.6\TV_Series", $true)
$net.MapNetworkDrive("m:", "\\192.168.0.6\Movies", $true)
$net.MapNetworkDrive("v:", "\\192.168.0.6\Music", $true)
$net.MapNetworkDrive("a:", "\\192.168.0.6\Archive", $true)
$net.MapNetworkDrive("s:", "\\192.168.0.6\Documents", $true)
$net.MapNetworkDrive("u:", "\\192.168.0.6\Pictures", $true)
$net.MapNetworkDrive("t:", "\\192.168.0.6\Programs", $true)
$net.MapNetworkDrive("y:", "\\192.168.0.7\TV_Series", $true)
$net.MapNetworkDrive("n:", "\\192.168.0.7\Movies", $true)
$net.MapNetworkDrive("q:", "\\192.168.0.8\TV_Series", $true)
$net.MapNetworkDrive("r:", "\\192.168.0.8\Movies", $true)
New-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders" -Name "{F42EE2D3-909F-4907-8871-4C22FC0BF756}" -PropertyType "String" -Value '\\192.168.0.6\documents'
New-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders" -Name "Personal" -PropertyType "String" -Value '\\192.168.0.6\documents' -Force
