320 lines
16 KiB
C#
320 lines
16 KiB
C#
//----------------------------------------------------------------------------
|
|
//
|
|
// Copyright (c) Intel Corporation, 2010 All Rights Reserved.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Net;
|
|
using Intel.Manageability;
|
|
using Intel.Manageability.Exceptions;
|
|
using Intel.Manageability.SystemDefense;
|
|
|
|
namespace SystemDefenseSample
|
|
{
|
|
class SystemDefenseFunctionality
|
|
{
|
|
/// <summary>
|
|
/// Create policies and add them to the Intel AMT instance
|
|
/// </summary>
|
|
/// <param name="amt">The Intel AMT instance</param>
|
|
internal static void CreatePolicy(IAMTInstance amt)
|
|
{
|
|
Collection<Policy> policies = new Collection<Policy>();
|
|
Collection<UserFilter> filters = new Collection<UserFilter>();
|
|
|
|
// ----------------------
|
|
// Create Policy #1
|
|
// ----------------------
|
|
|
|
// Prepare filter list (create ipfilter for block ipv4 packets and ethernet filter for rarp packets)
|
|
IPFilter ipFilter = FilterFactory.CreateIPFilter("ipFilter", FilterType.Drop, FilterDirection.Both, true, IPVersion.IPv4);
|
|
EthernetFilter etherFilter = FilterFactory.CreateEthernetFilter("etherFilter", FilterType.StatisticsAndDrop, FilterDirection.Incoming, false, (ushort)EtherTypes.ETH_TYPE_RARP);
|
|
|
|
// Add the filters we just created to the filter list
|
|
filters.Add(ipFilter);
|
|
filters.Add(etherFilter);
|
|
|
|
// Create policy and pass the filters list as a parameter
|
|
policies.Add(new Policy("MyPolicy1", 10, 150, filters));
|
|
|
|
// ----------------------
|
|
// Create Policy #2
|
|
// ----------------------
|
|
|
|
filters.Clear();
|
|
// Preapare filter list (create ipfilter for block ipv4 packets and ethernet filter for rarp packets)
|
|
TCPFilter tcpFilter = FilterFactory.CreateTCPFilter("tcpFilter", FilterType.Pass, FilterDirection.Incoming,
|
|
true, IPVersion.IPv4, HeaderIPAddress.Destination,
|
|
new IPAddress(new byte[] { 10, 0, 0, 2 }),
|
|
new IPAddress(new byte[] { 255, 255, 255, 0 }),
|
|
HeaderPortAddresses.Both, 80, 90,
|
|
TCPFlag.ACK | TCPFlag.FIN, TCPFlag.PUSH | TCPFlag.RST);
|
|
|
|
UDPFilter udpFilter = FilterFactory.CreateUDPFilter("udpFilter", FilterType.StatisticsAndPass, FilterDirection.Outgoing,
|
|
true, IPVersion.IPv4, HeaderPortAddresses.Both, 80, 92);
|
|
|
|
// Add the filters we just created to the filter list
|
|
filters.Add(tcpFilter);
|
|
filters.Add(udpFilter);
|
|
|
|
// Create policy with default Tx and Rx filters and pass the filters list as a parameter
|
|
PolicyFilter pFilter = new PolicyFilter(true, true, true);
|
|
policies.Add(new Policy("MyPolicy2", 5, 300, filters, pFilter, pFilter, AntiSpoofingSupport.Count));
|
|
|
|
// -------------------------------------------
|
|
// Add the policies to the Intel AMT instance
|
|
// -------------------------------------------
|
|
|
|
try
|
|
{
|
|
amt.SystemDefense.PolicyStore.CreateOrUpdatePolicies(policies);
|
|
Console.WriteLine("Create policy completed successfully.");
|
|
}
|
|
catch (ManageabilityException ex)
|
|
{
|
|
Console.WriteLine("Create policy failed with exception: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete policy by name
|
|
/// </summary>
|
|
/// <param name="amt">The Intel AMT instance</param>
|
|
internal static void DeletePolicy(IAMTInstance amt, string policyName)
|
|
{
|
|
try
|
|
{
|
|
amt.SystemDefense.PolicyStore.DeletePolicy(policyName);
|
|
Console.WriteLine("Delete policy completed successfully.");
|
|
}
|
|
catch (ManageabilityException ex)
|
|
{
|
|
Console.WriteLine("Delete policy failed with exception: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete all policies
|
|
/// </summary>
|
|
/// <param name="amt">The Intel AMT instance</param>
|
|
internal static void DeleteAllPolicies(IAMTInstance amt)
|
|
{
|
|
try
|
|
{
|
|
amt.SystemDefense.PolicyStore.DeleteAllPolicies();
|
|
Console.WriteLine("Delete all policies completed successfully.");
|
|
}
|
|
catch (ManageabilityException ex)
|
|
{
|
|
Console.WriteLine("Delete policies failed with exception: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get all the policies and display their capabilities
|
|
/// </summary>
|
|
/// <param name="amt">The Intel AMT instance</param>
|
|
internal static void DisplayPolicies(IAMTInstance amt)
|
|
{
|
|
try
|
|
{
|
|
// Retrieve all policies
|
|
Collection<Policy> policies = amt.SystemDefense.PolicyStore.GetAllPolicies();
|
|
|
|
Console.WriteLine("Policies");
|
|
Console.WriteLine("---------");
|
|
// Go over the policies and display their capabilities
|
|
IEnumerator policyEnumerator = policies.GetEnumerator();
|
|
while (policyEnumerator.MoveNext())
|
|
{
|
|
Console.WriteLine();
|
|
PrintPolicyCentent(policyEnumerator.Current as Policy);
|
|
}
|
|
}
|
|
catch (ManageabilityException ex)
|
|
{
|
|
Console.WriteLine("Display policies failed with exception: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get all the policies and display their capabilities
|
|
/// </summary>
|
|
/// <param name="amt">The Intel AMT instance</param>
|
|
internal static void EnablePolicy(IAMTInstance amt, string policyName)
|
|
{
|
|
try
|
|
{
|
|
// Get the interfaces supported by the machine
|
|
NetworkInterface supportedInterface = amt.SystemDefense.GetSupportedInterface();
|
|
|
|
// Enable the desired policy on the supported interface
|
|
amt.SystemDefense.PolicyStore.EnableUserPolicy(policyName, supportedInterface);
|
|
Console.WriteLine("Enable policy completed successfully.");
|
|
}
|
|
catch (ManageabilityException ex)
|
|
{
|
|
Console.WriteLine("Enabled policy failed with exception: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Display policy statistics for wired interface
|
|
/// </summary>
|
|
/// <param name="amt">The Intel AMT instance</param>
|
|
internal static void DisplayStatistics(IAMTInstance amt)
|
|
{
|
|
// Get the supported interfaces
|
|
NetworkInterface supportedInterfaces = amt.SystemDefense.GetSupportedInterface();
|
|
|
|
if ((supportedInterfaces & NetworkInterface.Wired) != 0)
|
|
{
|
|
try
|
|
{
|
|
// As the statistics are per filter in the Intel AMT instance, the GetStatistics() function retrieves a dictionary
|
|
// of filter and its statistics.
|
|
Dictionary<Filter, PolicyStatistics> filtersStatistics = amt.SystemDefense.PolicyStore.GetStatistics(NetworkInterface.Wired);
|
|
|
|
// Go over the filters and display the statistics parameters for each filter
|
|
Console.WriteLine("\nWired statistics:");
|
|
Console.WriteLine("-------------------");
|
|
IEnumerator enumerator = filtersStatistics.GetEnumerator();
|
|
while (enumerator.MoveNext())
|
|
{
|
|
KeyValuePair<Filter, PolicyStatistics> statistics = (KeyValuePair<Filter, PolicyStatistics>)enumerator.Current ;
|
|
|
|
Console.WriteLine("Filter {0}:", ((Filter)statistics.Key).Name);
|
|
Console.WriteLine("\tActivation time: {0} ", ((PolicyStatistics)statistics.Value).ActivationTime);
|
|
Console.WriteLine("\tFilter matched: {0} ", ((PolicyStatistics)statistics.Value).FilterMatched);
|
|
Console.WriteLine("\tLast reset time: {0} ", ((PolicyStatistics)statistics.Value).LastResetTime);
|
|
Console.WriteLine("\tRead count: {0} ", ((PolicyStatistics)statistics.Value).ReadCount);
|
|
}
|
|
}
|
|
catch (ManageabilityException ex)
|
|
{
|
|
Console.WriteLine("Get Statistics failed with exception: " + ex.Message);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Display system defense capabilities
|
|
/// </summary>
|
|
/// <param name="amt">The Intel AMT instance</param>
|
|
internal static void DisplayCapabalities(IAMTInstance amt)
|
|
{
|
|
// Display general system defense capabilities
|
|
GeneralSystemDefenseCapabilities generalCapabilities = amt.SystemDefense.GetGeneralCapabilities();
|
|
Console.WriteLine("\nGeneral capabilities:");
|
|
Console.WriteLine("Max Supported Filters: " + generalCapabilities.MaxSupportedFilters);
|
|
Console.WriteLine("Max Supported Policies: " + generalCapabilities.MaxSupportedPolicies);
|
|
|
|
// Display system defense capabilities for Wired
|
|
NetworkInterface supportedInterface = amt.SystemDefense.GetSupportedInterface();
|
|
if ((NetworkInterface.Wired & supportedInterface) != 0)
|
|
{
|
|
NetworkInterfaceSystemDefenseCapabilities capabilities = amt.SystemDefense.GetNetworkInterfaceCapabilities(NetworkInterface.Wired);
|
|
|
|
Console.WriteLine("\nWired Capabilities:");
|
|
Console.WriteLine("IPv4MaxTxFilters: " + capabilities.IPv4MaxTxFilters);
|
|
Console.WriteLine("IPv4MaxTxCounters: " + capabilities.IPv4MaxTxCounters);
|
|
Console.WriteLine("IPv4MaxRxFilters: " + capabilities.IPv4MaxRxFilters);
|
|
Console.WriteLine("IPv4MaxRxCounters: " + capabilities.IPv4MaxRxCounters);
|
|
Console.WriteLine("IPv4AntiSpoofingCapable: " + capabilities.IPv4AntiSpoofingCapable);
|
|
Console.WriteLine("IPv6MaxTxFilters: " + capabilities.IPv6MaxTxFilters);
|
|
Console.WriteLine("IPv6MaxTxCounters: " + capabilities.IPv6MaxTxCounters);
|
|
Console.WriteLine("IPv6MaxRxFilters: " + capabilities.IPv6MaxRxFilters);
|
|
Console.WriteLine("IPv6MaxRxCounters: " + capabilities.IPv6MaxRxCounters);
|
|
Console.WriteLine("IPv6AntiSpoofingCapable: " + capabilities.IPv6AntiSpoofingCapable);
|
|
Console.WriteLine("IPv6ToIPv4Ratio: " + capabilities.IPv6ToIPv4Ratio);
|
|
}
|
|
}
|
|
|
|
#region Helper Methods
|
|
|
|
private static void PrintPolicyCentent(Policy policy)
|
|
{
|
|
Console.WriteLine("Policy Name: {0} ", policy.Name);
|
|
Console.WriteLine("\tPrecedence: {0} ", policy.Precedence);
|
|
Console.WriteLine("\tantiSpoofingSupport: {0} ", policy.antiSpoofingSupport);
|
|
Console.WriteLine("\tTimeout: {0} ", policy.Timeout);
|
|
Console.WriteLine("\tTx filter:\n\t\tDefaultCount: {0}\n\t\tDefaultDrop: {1}\n\t\tDefaultMatchEvent: {2}", policy.TxFilter.DefaultCount, policy.TxFilter.DefaultDrop, policy.TxFilter.DefaultMatchEvent);
|
|
Console.WriteLine("\tRx filter:\n\t\tDefaultCount: {0}\n\t\tDefaultDrop: {1}\n\t\tDefaultMatchEvent: {2}", policy.RxFilter.DefaultCount, policy.RxFilter.DefaultDrop, policy.RxFilter.DefaultMatchEvent);
|
|
|
|
// Go over the filters and display their capabilities
|
|
IEnumerator filterEnumerator = policy.Filters.GetEnumerator();
|
|
while (filterEnumerator.MoveNext())
|
|
{
|
|
Filter curFilter = filterEnumerator.Current as Filter;
|
|
|
|
if (curFilter is IPFilter)
|
|
{
|
|
PrintIPFilter(curFilter as IPFilter);
|
|
}
|
|
else if (curFilter is EthernetFilter)
|
|
{
|
|
PrintEthernetFilter(curFilter as EthernetFilter);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void PrintEthernetFilter(EthernetFilter ethernetFilter)
|
|
{
|
|
Console.WriteLine("\tFilter Name: {0} ", ethernetFilter.Name);
|
|
Console.WriteLine("\t\tFilter Direction: {0}", ethernetFilter.Direction.ToString());
|
|
Console.WriteLine("\t\tCreate Event: {0}", ethernetFilter.CreateEvent);
|
|
Console.WriteLine("\t\tFilter Profile: {0}", ethernetFilter.Profile.ToString());
|
|
if (ethernetFilter.Profile == FilterType.RateLimit)
|
|
Console.WriteLine("\t\tEvents Per Second: {0}", ethernetFilter.EventsPerSecond);
|
|
|
|
Console.WriteLine("\t\tProtocol ID: {0}", ethernetFilter.ProtocolID);
|
|
}
|
|
|
|
private static void PrintIPFilter(IPFilter ipFilter)
|
|
{
|
|
Console.WriteLine("\tFilter Name: {0} ", ipFilter.Name);
|
|
Console.WriteLine("\t\tFilter Direction: {0}", ipFilter.Direction.ToString());
|
|
Console.WriteLine("\t\tCreate Event: {0}", ipFilter.CreateEvent);
|
|
Console.WriteLine("\t\tFilter Profile: {0}", ipFilter.Profile.ToString());
|
|
if (ipFilter.Profile == FilterType.RateLimit)
|
|
Console.WriteLine("\t\tEvents Per Second: {0}", ipFilter.EventsPerSecond);
|
|
|
|
Console.WriteLine("\t\tIP Version: {0}", ipFilter.IpVersion.ToString());
|
|
if (ipFilter.IPAddress != null)
|
|
{
|
|
Console.WriteLine("\t\tIP Header Address: {0}", ipFilter.IPHeaderAddress.ToString());
|
|
Console.WriteLine("\t\tIP Address: {0}", ipFilter.IPAddress.ToString());
|
|
}
|
|
if (ipFilter.IPMask != null)
|
|
Console.WriteLine("\t\tIP Mask: {0}", ipFilter.IPMask.ToString());
|
|
|
|
if (ipFilter is ProtocolFilter)
|
|
Console.WriteLine("\t\tProtocol ID: {0}", ((ProtocolFilter)ipFilter).ProtocolID);
|
|
else if (ipFilter is TCPFilter)
|
|
{
|
|
Console.WriteLine("\t\tProtocol: TCP");
|
|
if (((TCPFilter)ipFilter).PortFilterExists)
|
|
{
|
|
Console.WriteLine("\t\tHeader Port Address: {0}", ((TCPFilter)ipFilter).HeaderPortAddress);
|
|
Console.WriteLine("\t\tPort1: {0}", ((TCPFilter)ipFilter).Port1);
|
|
Console.WriteLine("\t\tPort2: {0}", ((TCPFilter)ipFilter).Port2);
|
|
}
|
|
Console.WriteLine("\t\tFlags On: {0}", ((TCPFilter)ipFilter).FlagsOn);
|
|
Console.WriteLine("\t\tFlags Off: {0}", ((TCPFilter)ipFilter).FlagsOff);
|
|
}
|
|
else if (ipFilter is UDPFilter)
|
|
{
|
|
Console.WriteLine("\t\tProtocol: UDP");
|
|
Console.WriteLine("\t\tHeader Port Address: {0}", ((UDPFilter)ipFilter).HeaderPortAddress);
|
|
Console.WriteLine("\t\tPort1: {0}", ((UDPFilter)ipFilter).Port1);
|
|
Console.WriteLine("\t\tPort2: {0}", ((UDPFilter)ipFilter).Port2);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|