725 lines
17 KiB
C#
725 lines
17 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Collections.ObjectModel;
|
|
using System.Management.Automation;
|
|
using System.Management.Automation.Provider;
|
|
using System.Management.Automation.Runspaces;
|
|
|
|
|
|
|
|
namespace Intel.Management.PSModule.Amt
|
|
{
|
|
/// <summary>
|
|
/// This sample implements a Windows PowerShell provider class
|
|
/// that acts upon AMT Hardware.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Get-PSDrive
|
|
/// $DebugPreference = "Continue"
|
|
/// $DebugPreference = "SilentlyContinue"
|
|
/// </remarks>
|
|
[CmdletProvider("AmtSystem", ProviderCapabilities.Credentials)]
|
|
public class AmtDriveProvider : DriveProvider
|
|
{
|
|
|
|
|
|
public AmtDriveProvider()
|
|
: base()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// The Windows PowerShell engine calls this method when the
|
|
/// New-PSDrive cmdlet is run and the path to this provider is
|
|
/// specified. This method creates a connection to the database
|
|
/// file and sets the Connection property of the PSDriveInfo object.
|
|
/// </summary>
|
|
/// <param name="drive">
|
|
/// Information describing the drive to create.
|
|
/// </param>
|
|
/// <returns>An AmtDriveInfo object that represents
|
|
/// the new drive.</returns>
|
|
protected override PSDriveInfo NewDrive(PSDriveInfo drive)
|
|
{
|
|
//AmtDriveInfo.AmtDriveParameters localParams = _driveParams;
|
|
//_driveParams=null;
|
|
WriteDebug("AMT NewDrive");
|
|
PSDriveInfo result = null;
|
|
|
|
try
|
|
{
|
|
|
|
result = new AmtDriveInfo(drive,(AmtDriveParameters)DynamicParameters, this);
|
|
|
|
}
|
|
catch (PSArgumentException argException)
|
|
{
|
|
WriteError(new ErrorRecord(
|
|
argException,
|
|
argException.GetType().Name,
|
|
ErrorCategory.InvalidArgument,
|
|
PSDriveInfo));
|
|
}
|
|
catch (Intel.Management.Wsman.WsmanUnauthorizedException authException)
|
|
{
|
|
WriteError(new ErrorRecord(
|
|
authException,
|
|
authException.GetType().Name,
|
|
ErrorCategory.PermissionDenied,
|
|
PSDriveInfo));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
protected override object NewDriveDynamicParameters()
|
|
{
|
|
return new AmtDriveParameters();
|
|
}
|
|
|
|
//private Collection<PSDriveInfo> _drives;
|
|
|
|
|
|
/// <summary>
|
|
/// When the provider engine starts a provider, the InitializeDefaultDrives method
|
|
/// is called. This is an opportunity for the provider to mount drives that are
|
|
/// important to it.
|
|
/// </summary>
|
|
/// <returns>A collection of PSDriveInfo objects for each drive the provider
|
|
/// wants to mount.</returns>
|
|
/* protected override Collection<PSDriveInfo> InitializeDefaultDrives()
|
|
{
|
|
|
|
/* if (_drives == null)
|
|
{
|
|
WriteDebug("Initializing amt drive");
|
|
_drives = new Collection<PSDriveInfo>();
|
|
_drives.Add(new PSDriveInfo("AMT", ProviderInfo, "Config",
|
|
"Intel(r) AMT Subsystem", Credential));
|
|
}
|
|
|
|
|
|
}*/
|
|
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// The Windows PowerShell engine calls this method when the
|
|
/// Remove-PSDrive cmdlet is run and the path to this provider is
|
|
/// specified. This method closes a hardware connection
|
|
/// </summary>
|
|
/// <param name="drive">The drive to remove.</param>
|
|
/// <returns>An AMTDrive object that represents
|
|
/// the removed drive.</returns>
|
|
protected override PSDriveInfo RemoveDrive(PSDriveInfo drive)
|
|
{
|
|
return drive;
|
|
} // End RemoveDrive.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
/// <summary>
|
|
/// Definition of an AmtDriveInfo object
|
|
/// </summary>
|
|
internal class AmtDriveInfo : PSDriveInfo
|
|
{
|
|
AmtDriveItem _root;
|
|
HECIClass _heci;
|
|
|
|
string _cashedPath;
|
|
AmtDriveItem _cashedItem;
|
|
|
|
bool _bDriverLoaded;
|
|
bool _bDriverLocked;
|
|
|
|
public AmtDriveInfo(PSDriveInfo info) : base(info)
|
|
{
|
|
|
|
_heci = new HECIClass();
|
|
_cashedItem = null;
|
|
_cashedPath = string.Empty;
|
|
|
|
//_root = new ContainerItem("LocalDriver",
|
|
_root = new AmtRootItem(_heci);
|
|
_bDriverLoaded = false;
|
|
}
|
|
|
|
public void LockDriver()
|
|
{
|
|
_bDriverLocked=true;
|
|
}
|
|
|
|
public void UnlockDriver()
|
|
{
|
|
_bDriverLocked = false;
|
|
UnLoadDriver();
|
|
}
|
|
|
|
public void LoadDriver()
|
|
{
|
|
if (!_bDriverLoaded)
|
|
{
|
|
_heci.Init();
|
|
_bDriverLoaded = true;
|
|
}
|
|
}
|
|
|
|
public void UnLoadDriver()
|
|
{
|
|
if (_bDriverLoaded && !_bDriverLocked)
|
|
{
|
|
_heci.DeInit();
|
|
_bDriverLoaded = false;
|
|
}
|
|
}
|
|
|
|
public AmtDriveItem GetItemFromPath(string path)
|
|
{
|
|
//check root
|
|
if (string.IsNullOrEmpty(path) ||
|
|
string.Compare(this.Name,path,true)==0 ||
|
|
string.Compare(this.Name+"\\", path, true)==0)
|
|
{
|
|
return _root;
|
|
}
|
|
|
|
|
|
|
|
// Get path components
|
|
char[] splits = {'\\'};
|
|
string[] paths = path.Split(splits, StringSplitOptions.RemoveEmptyEntries);
|
|
|
|
//find item in path
|
|
AmtDriveItem parent = _root;
|
|
AmtDriveItem foundItem = null;
|
|
|
|
//load heci if its in the path
|
|
foreach (string pathItem in paths)
|
|
{
|
|
if (string.Compare(pathItem, AmtHeciRootItem.HostDriveName, true) == 0)
|
|
LoadDriver();
|
|
|
|
}
|
|
|
|
//check and see if the item is cached
|
|
if (string.Compare(path, _cashedPath, true) == 0)
|
|
{
|
|
return _cashedItem;
|
|
}
|
|
else
|
|
{
|
|
//check if parent is cached
|
|
int pos = path.ToLower().IndexOf(_cashedPath.ToLower() + "\\");
|
|
if (pos == 0)
|
|
{
|
|
paths = path.Substring(_cashedPath.Length).Split(splits, StringSplitOptions.RemoveEmptyEntries);
|
|
parent = _cashedItem;
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
|
|
for (int i = 0; i < paths.Length; i++)
|
|
{
|
|
foundItem = null;
|
|
|
|
foreach (AmtDriveItem childItem in parent.GetChildItems())
|
|
{
|
|
if (string.Compare(childItem.Name, paths[i], true) == 0)
|
|
{
|
|
foundItem = childItem;
|
|
parent = foundItem;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (foundItem == null)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
_cashedItem = foundItem;
|
|
_cashedPath = path;
|
|
}
|
|
}
|
|
|
|
}
|
|
finally
|
|
{
|
|
UnLoadDriver();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return foundItem;
|
|
}
|
|
}
|
|
// End defintion of AMTDriveInfo
|
|
|
|
|
|
internal class AmtRootContainerValue : ContainerItemValue
|
|
{
|
|
AmtDriveItem[] _items;
|
|
|
|
|
|
public AmtRootContainerValue(HECIClass heci)
|
|
{
|
|
//build the array
|
|
_items = new AmtDriveItem[1];
|
|
_items[0]= new AmtHeciRootItem(heci);
|
|
}
|
|
|
|
public override AmtDriveItem[] GetChildItems()
|
|
{
|
|
return _items;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Definition of the Root Container
|
|
/// </summary>
|
|
internal class AmtRootItem : AmtDriveItem
|
|
{
|
|
|
|
AmtRootContainerValue _value;
|
|
|
|
public AmtRootItem(HECIClass heci)
|
|
{
|
|
_value = new AmtRootContainerValue(heci);
|
|
}
|
|
|
|
public override string Name
|
|
{
|
|
get
|
|
{
|
|
return DriveName;
|
|
}
|
|
}
|
|
|
|
public override object Value
|
|
{
|
|
get
|
|
{
|
|
return _value;
|
|
}
|
|
}
|
|
|
|
public override bool HasChildren
|
|
{
|
|
get
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public static string DriveName
|
|
{
|
|
get
|
|
{
|
|
return "AMT";
|
|
}
|
|
}
|
|
|
|
}
|
|
//End Definition of the Root Container
|
|
|
|
internal class AmtSetupContainerValue : ContainerItemValue
|
|
{
|
|
HECIClass _heci;
|
|
|
|
public AmtSetupContainerValue(HECIClass heci)
|
|
{
|
|
_heci = heci;
|
|
}
|
|
|
|
public override AmtDriveItem[] GetChildItems()
|
|
{
|
|
List<AmtDriveItem> list = new List<AmtDriveItem>();
|
|
|
|
HECIClass.ProvisioningMode mode;
|
|
bool bOk = _heci.GetProvisioningMode(out mode);
|
|
if (bOk)
|
|
list.Add(new AmtPropertyItem("ProvisioningMode", mode));
|
|
|
|
bool ztcEnabled;
|
|
bOk = _heci.GetZeroTouchEnabled(out ztcEnabled);
|
|
if (bOk)
|
|
list.Add(new AmtPropertyItem("ZeroTouch", ztcEnabled));
|
|
|
|
HECIClass.TlsMode tlsMode;
|
|
bOk = _heci.GetTlsMode(out tlsMode);
|
|
if (bOk)
|
|
list.Add(new AmtPropertyItem("SetupMode", tlsMode));
|
|
|
|
HECIClass.RngSeedStatus rngStatus;
|
|
bOk = _heci.GetRngSeedStatus(out rngStatus);
|
|
if (bOk)
|
|
list.Add(new AmtPropertyItem("RngStatus", rngStatus));
|
|
|
|
return list.ToArray();
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Definition of the setup container
|
|
/// </summary>
|
|
internal class AmtSetupItem : AmtDriveItem
|
|
{
|
|
|
|
AmtSetupContainerValue _value;
|
|
public AmtSetupItem(HECIClass heci)
|
|
{
|
|
_value = new AmtSetupContainerValue(heci);
|
|
}
|
|
|
|
|
|
public override bool HasChildren
|
|
{
|
|
get
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
public override string Name
|
|
{
|
|
get
|
|
{
|
|
return "LegacySetup";
|
|
}
|
|
}
|
|
|
|
public override object Value
|
|
{
|
|
get
|
|
{
|
|
return _value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Definition of an individual hash item
|
|
/// </summary>
|
|
internal class AmtHashEntryItem : AmtDriveItem
|
|
{
|
|
AmtHashContainerValue _value;
|
|
|
|
public AmtHashEntryItem(HECIClass.HashEntry entry)
|
|
{
|
|
_value = new AmtHashContainerValue(entry);
|
|
}
|
|
|
|
|
|
public override bool HasChildren
|
|
{
|
|
get
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
public override string Name
|
|
{
|
|
get
|
|
{
|
|
return _value.Name;
|
|
}
|
|
}
|
|
|
|
public override object Value
|
|
{
|
|
get
|
|
{
|
|
return _value;
|
|
}
|
|
}
|
|
}
|
|
// Definition of an Hash Entry Item
|
|
|
|
|
|
/// <summary>
|
|
/// Container value for a Hash Entry
|
|
/// </summary>
|
|
internal class AmtHashContainerValue : ContainerItemValue
|
|
{
|
|
HECIClass.HashEntry _entry;
|
|
|
|
public AmtHashContainerValue(HECIClass.HashEntry entry)
|
|
{
|
|
_entry = entry;
|
|
}
|
|
|
|
public string Name
|
|
{
|
|
get
|
|
{
|
|
return _entry.Name;
|
|
}
|
|
}
|
|
|
|
public override AmtDriveItem[] GetChildItems()
|
|
{
|
|
List<AmtDriveItem> list = new List<AmtDriveItem>();
|
|
|
|
list.Add(new AmtPropertyItem("Name", _entry.Name));
|
|
list.Add(new AmtPropertyItem("IsDefault", _entry.IsDefault));
|
|
list.Add(new AmtPropertyItem("IsActive", _entry.IsActive));
|
|
list.Add(new AmtPropertyItem("Thumbprint", _entry.Thumbprint));
|
|
list.Add(new AmtPropertyItem("HashString", _entry.HashString));
|
|
|
|
return list.ToArray();
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return _entry.Thumbprint;
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Container value for Hashes
|
|
/// </summary>
|
|
internal class AmtHashesContainerValue : ContainerItemValue
|
|
{
|
|
HECIClass _heci;
|
|
|
|
public AmtHashesContainerValue(HECIClass heci)
|
|
{
|
|
_heci = heci;
|
|
}
|
|
|
|
public override AmtDriveItem[] GetChildItems()
|
|
{
|
|
HECIClass.HashEntry[] hashes;
|
|
AmtDriveItem[] result = { };
|
|
if (_heci.GetCertHashes(out hashes))
|
|
{
|
|
result = new AmtDriveItem[hashes.Length];
|
|
for (int i = 0; i < hashes.Length; i++)
|
|
{
|
|
result[i] = new AmtHashEntryItem(hashes[i]);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Definition of a collection of hashes
|
|
/// </summary>
|
|
internal class AmtHashesItem : AmtDriveItem
|
|
{
|
|
AmtHashesContainerValue _value;
|
|
bool _hasChildren;
|
|
|
|
public AmtHashesItem(HECIClass heci) : base()
|
|
{
|
|
_value = new AmtHashesContainerValue(heci);
|
|
_hasChildren = false;
|
|
}
|
|
|
|
public override bool IsContainer
|
|
{
|
|
get
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public override bool HasChildren
|
|
{
|
|
get
|
|
{
|
|
return _hasChildren;
|
|
}
|
|
}
|
|
|
|
public override AmtDriveItem[] GetChildItems()
|
|
{
|
|
AmtDriveItem[] result = _value.GetChildItems();
|
|
|
|
_hasChildren = result.Length > 0;
|
|
|
|
return result;
|
|
}
|
|
|
|
public override string Name
|
|
{
|
|
get
|
|
{
|
|
return "Hashes";
|
|
}
|
|
}
|
|
|
|
public override object Value
|
|
{
|
|
get
|
|
{
|
|
return _value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Container value for Root Heci Items
|
|
/// </summary>
|
|
internal class AmtHeciContainerValue : ContainerItemValue
|
|
{
|
|
HECIClass _heci;
|
|
|
|
public AmtHeciContainerValue(HECIClass heci)
|
|
{
|
|
_heci = heci;
|
|
}
|
|
|
|
public override AmtDriveItem[] GetChildItems()
|
|
{
|
|
List<AmtDriveItem> list = new List<AmtDriveItem>();
|
|
|
|
bool bOk;
|
|
string boisString;
|
|
|
|
|
|
HECIClass.ProvisioningState state;
|
|
bOk = _heci.GetProvisioningState(out state);
|
|
if (bOk)
|
|
list.Add(new AmtPropertyItem("ProvisioningState", state));
|
|
|
|
|
|
HECIClass.AMT_VERSION_TYPE[] verTypes;
|
|
bOk = _heci.GetCodeVersions(out boisString, out verTypes);
|
|
if (bOk)
|
|
{
|
|
|
|
list.Add(new AmtPropertyItem("BIOSVersion", boisString));
|
|
foreach (HECIClass.AMT_VERSION_TYPE verType in verTypes)
|
|
{
|
|
list.Add(new AmtPropertyItem(verType.Description.Text,
|
|
verType.Version.Text));
|
|
}
|
|
}
|
|
|
|
|
|
string userName, password;
|
|
bOk = _heci.GetLocalAdminCredentials(out userName, out password);
|
|
if (bOk)
|
|
{
|
|
list.Add(new AmtPropertyItem("LocalUser", userName));
|
|
list.Add(new AmtPropertyItem("LocalPassword", password));
|
|
}
|
|
|
|
list.Add(new AmtPropertyItem("LocalAddress", "http://localhost:16992/wsman"));
|
|
|
|
|
|
list.Add(new AmtSetupItem(_heci));
|
|
list.Add(new AmtHashesItem(_heci));
|
|
|
|
return list.ToArray();
|
|
}
|
|
}
|
|
//Container value for Root Heci Items
|
|
|
|
/// <summary>
|
|
/// Definition of the Heci Root Item
|
|
/// </summary>
|
|
internal class AmtHeciRootItem : AmtDriveItem
|
|
{
|
|
AmtHeciContainerValue _value;
|
|
public AmtHeciRootItem(HECIClass heci)
|
|
{
|
|
_value = new AmtHeciContainerValue(heci);
|
|
}
|
|
|
|
|
|
public override bool HasChildren
|
|
{
|
|
get
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public override string Name
|
|
{
|
|
get
|
|
{
|
|
return HostDriveName;
|
|
}
|
|
}
|
|
|
|
public override object Value
|
|
{
|
|
get
|
|
{
|
|
return _value;
|
|
}
|
|
}
|
|
|
|
public static string HostDriveName
|
|
{
|
|
get
|
|
{
|
|
return "HostDriver";
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Definition a property item
|
|
/// </summary>
|
|
internal class AmtPropertyItem : AmtDriveItem
|
|
{
|
|
string _name;
|
|
object _value;
|
|
|
|
public AmtPropertyItem(string name, object value) : base()
|
|
{
|
|
_name = name;
|
|
_value = value;
|
|
}
|
|
|
|
public override string Name
|
|
{
|
|
get
|
|
{
|
|
return _name;
|
|
}
|
|
}
|
|
|
|
public override object Value
|
|
{
|
|
get
|
|
{
|
|
return _value;
|
|
}
|
|
}
|
|
}*/
|
|
|
|
} //End AMTDriveProvider
|
|
|
|
|
|
} // end Namepsace
|