private int GetHighestKeyIndex(SecuritySchemes[] securitySchemes)
{
int ret = 0;
SecuritySchemes highScheme = Enums.SecuritySchemes.S0;
if (securitySchemes.Contains(Enums.SecuritySchemes.S2_ACCESS))
{
highScheme = Enums.SecuritySchemes.S2_ACCESS;
}
else if (securitySchemes.Contains(Enums.SecuritySchemes.S2_AUTHENTICATED))
{
highScheme = Enums.SecuritySchemes.S2_AUTHENTICATED;
}
else if (securitySchemes.Contains(Enums.SecuritySchemes.S2_UNAUTHENTICATED))
{
highScheme = Enums.SecuritySchemes.S2_UNAUTHENTICATED;
}
else if (securitySchemes.Contains(Enums.SecuritySchemes.S0))
{
highScheme = Enums.SecuritySchemes.S0;
}
else
{
highScheme = securitySchemes[0]; // unexpected
}
for (int i = 0; i < securitySchemes.Length; i++)
{
if (securitySchemes[i] == highScheme)
{
ret = i;
break;
}
}
return(ret);
}
public bool IsSecuritySchemeEnabled(SecuritySchemes scheme)
{
bool ret = false;
switch (scheme)
{
case SecuritySchemes.NONE:
ret = true;
break;
case SecuritySchemes.S2_UNAUTHENTICATED:
ret = IsEnabledS2_UNAUTHENTICATED;
break;
case SecuritySchemes.S2_AUTHENTICATED:
ret = IsEnabledS2_AUTHENTICATED;
break;
case SecuritySchemes.S2_ACCESS:
ret = IsEnabledS2_ACCESS;
break;
case SecuritySchemes.S0:
ret = IsEnabledS0;
break;
case SecuritySchemes.S2_TEMP:
ret = true;
break;
default:
break;
}
return(ret);
}
public void SetCurrentSecurityScheme(SecuritySchemes securityScheme)
{
if (SecuritySchemes != null && SecuritySchemes.Length > 0)
{
SecuritySchemeIndex = Array.IndexOf <SecuritySchemes>(SecuritySchemes, securityScheme);
}
}
public SendDataMultiExOperation(byte[] data, TransmitOptions txOptions, SecuritySchemes scheme, byte groupId)
: base(CommandTypes.CmdSendDataMultiEx)
{
Data = data;
TxOptions = txOptions;
SecurityScheme = scheme;
GroupId = groupId;
}
public void Should_ReturnEmptyList_WhenSecuritySchemeIsNotOauth2(SecuritySchemes schemes)
{
string scopeName = "scopeName";
var result = builder.SecurityScheme(schemes).SecurityScheme(scopeName).Build();
Assert.Empty(result.Value);
}
public bool HasSecurityScheme(byte nodeId, SecuritySchemes scheme)
{
bool ret =
IsSecuritySchemeEnabled(scheme) &&
Nodes[NodeTag].HasSecurityScheme(scheme) &&
Nodes[nodeId].HasSecurityScheme(scheme);
return(ret);
}
/// <summary>ZCB_UpdateStatusSuccess</summary>
private ActionBase SendFwuMdStatusReport(byte nodeId, byte reportStatus, SecuritySchemes scheme)
{
var fwuMdRequestReport = new COMMAND_CLASS_FIRMWARE_UPDATE_MD_V5.FIRMWARE_UPDATE_MD_STATUS_REPORT()
{
status = reportStatus
};
var ret = new SendDataExOperation(nodeId, fwuMdRequestReport, TxOptions, scheme);
return(ret);
}
internal bool HasSecurityScheme(SecuritySchemes scheme)
{
var ret = false;
if (SecuritySchemes != null)
{
ret = SecuritySchemes.Contains(scheme);
}
return(ret);
}
///// <summary>
///// Fills network key S2 table with specified keys (Without activating any of them)
///// </summary>
///// <param name="networkKeys">Keys table</param>
//public void SetNetworkKeys(NetworkKey[] networkKeys)
//{
// NetworkKey[] keys = networkKeys ?? new NetworkKey[SecurityManagerInfo.NETWORK_KEYS_COUNT];
// if (keys.Length != NETWORK_KEYS_COUNT)
// throw new ArgumentException("invalid keys table length");
// Array.Copy(keys, _networkKeys, NETWORK_KEYS_COUNT);
//}
/// <summary>
/// Sests network key for specified scheme (wihout activating it)
/// </summary>
/// <param name="key">Network key</param>
/// <param name="scheme">scheme</param>
public void SetNetworkKey(byte[] key, SecuritySchemes scheme)
{
var index = GetNetworkKeyIndex(scheme);
if (_networkKeys[index] == null)
{
_networkKeys[index] = new NetworkKey();
}
_networkKeys[index].Value = key;
}
public ResponseDataExOperation(NetworkViewPoint network, List <byte[]> data, TransmitOptions txOptions, TransmitSecurityOptions txSecOptions, SecuritySchemes scheme, TransmitOptions2 txOptions2, byte destNodeId, byte cmdClass, byte cmd)
: base(destNodeId, 0, new ByteIndex(cmdClass), new ByteIndex(cmd))
{
_network = network;
Data = data;
TxOptions = txOptions;
TxSecOptions = txSecOptions;
SecurityScheme = scheme;
TxOptions2 = txOptions2;
IsSecuritySchemeSpecified = true;
}
public ResponseDataExOperation(NetworkViewPoint network, ResponseDataDelegate receiveCallback, TransmitOptions txOptions, TransmitSecurityOptions txSecOptions, SecuritySchemes scheme, TransmitOptions2 txOptions2, byte destNodeId, byte cmdClass, byte cmd)
: base(destNodeId, 0, new ByteIndex(cmdClass), new ByteIndex(cmd))
{
_network = network;
ReceiveCallback = receiveCallback;
TxOptions = txOptions;
TxSecOptions = txSecOptions;
SecurityScheme = scheme;
IsSecuritySchemeSpecified = true;
TxOptions2 = txOptions2;
}
public SendDataExOperation(byte bridgeNodeId, byte nodeId, byte[] data, TransmitOptions txOptions, TransmitSecurityOptions txSecOptions, SecuritySchemes scheme, TransmitOptions2 txOptions2)
: base(CommandTypes.CmdZWaveSendDataEx)
{
BridgeNodeId = bridgeNodeId;
NodeId = nodeId;
Data = data;
TxOptions = txOptions;
TxOptions2 = txOptions2;
TxSecOptions = txSecOptions;
SecurityScheme = scheme;
}
public NoiseDataExOperation(byte nodeId, byte[] data, TransmitOptions txOptions, int intervalMs, SecuritySchemes securityScheme, TransmitSecurityOptions txSecOptions, TransmitOptions2 txOptions2)
: base(false, null, false)
{
TxOptions = txOptions;
NodeId = nodeId;
Data = data;
IntervalMs = intervalMs;
SecurityScheme = securityScheme;
TxSecOptions = txSecOptions;
TxOptions2 = txOptions2;
}
private void AddSecurityScheme(SecuritySchemes addScheme)
{
var schemes = GetSecuritySchemes();
if (schemes != null)
{
SetSecuritySchemes(schemes.Union(new[] { addScheme }).ToArray());
}
else
{
SetSecuritySchemes(new[] { addScheme });
}
}
/// <summary>handleCommandClassFWUpdate</summary>
private ActionBase SendFwuMdReport(byte nodeId, SecuritySchemes scheme)
{
var fwuMdReport = new COMMAND_CLASS_FIRMWARE_UPDATE_MD_V5.FIRMWARE_MD_REPORT()
{
manufacturerId = MANUFACTURE_ID,
firmware0Id = FIRMWARE_ID,
firmwareUpgradable = 0xFF,
maxFragmentSize = Tools.GetBytes(MAX_FRAGMENT_SIZE).Skip(2).ToArray(),
};
var ret = new SendDataExOperation(nodeId, fwuMdReport, TxOptions, scheme);
return(ret);
}
public SecuritySchemes GetCurrentSecurityScheme()
{
SecuritySchemes ret = Enums.SecuritySchemes.NONE;
if (SecuritySchemes != null && SecuritySchemes.Length > 0)
{
if (SecuritySchemeIndex < 0 || SecuritySchemeIndex >= SecuritySchemes.Length)
{
SecuritySchemeIndex = GetHighestKeyIndex(SecuritySchemes);
}
return(SecuritySchemes[SecuritySchemeIndex]);
}
return(ret);
}
public RequestDataExOperation(byte srcNodeId, byte destNodeId, byte[] data, TransmitOptions txOptions, TransmitSecurityOptions txSecOptions, SecuritySchemes scheme, TransmitOptions2 txOptions2, byte cmdClass, byte cmd, int timeoutMs)
: base(false, null, false)
{
SrcNodeId = srcNodeId;
DestNodeId = destNodeId;
Data = data;
TxOptions = txOptions;
TxSecOptions = txSecOptions;
SecurityScheme = scheme;
TxOptions2 = txOptions2;
CmdClass = cmdClass;
Cmd = cmd;
TimeoutMs = timeoutMs;
}
/// <summary>Indicates whether the current object is equal to another object of the same type.</summary>
/// <param name="other">An object to compare with this object.</param>
/// <returns>true if the current object is equal to the <paramref name="other">other</paramref> parameter; otherwise, false.</returns>
public virtual bool Equals(Components other)
{
if (other is null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
if (!Schemas.NullableDictionaryEquals(other.Schemas))
{
return(false);
}
if (!Responses.NullableDictionaryEquals(other.Responses))
{
return(false);
}
if (!Parameters.NullableDictionaryEquals(other.Parameters))
{
return(false);
}
if (!Examples.NullableDictionaryEquals(other.Examples))
{
return(false);
}
if (!RequestBodies.NullableDictionaryEquals(other.RequestBodies))
{
return(false);
}
if (!Headers.NullableDictionaryEquals(other.Headers))
{
return(false);
}
if (!SecuritySchemes.NullableDictionaryEquals(other.SecuritySchemes))
{
return(false);
}
if (!Links.NullableDictionaryEquals(other.Links))
{
return(false);
}
if (!Callbacks.NullableDictionaryEquals(other.Callbacks))
{
return(false);
}
return(true);
}
/// <summary>CmdClassFirmwareUpdateMdGet</summary>
private ActionBase SendFwuMdGet(byte nodeId, ushort fwuReportNumber, SecuritySchemes scheme)
{
_lastUsedReportNumber = fwuReportNumber;
var reportNumber = Tools.GetBytes(fwuReportNumber);
var fwuMdGet = new COMMAND_CLASS_FIRMWARE_UPDATE_MD_V5.FIRMWARE_UPDATE_MD_GET()
{
numberOfReports = 0x01,
reportNumber2 = reportNumber[1],
properties1 = new COMMAND_CLASS_FIRMWARE_UPDATE_MD_V5.FIRMWARE_UPDATE_MD_GET.Tproperties1()
{
reportNumber1 = reportNumber[0]
}
};
var ret = new SendDataExOperation(nodeId, fwuMdGet, TxOptions, scheme);
return(ret);
}
protected bool IsSupportedScheme(NetworkViewPoint network, byte[] command, SecuritySchemes scheme)
{
bool ret = false;
if (command != null && command.Length > 0)
{
if (scheme == SecuritySchemes.NONE && !network.HasNetworkAwareCommandClass(command[0]) && network.HasSecurityScheme(SecuritySchemeSet.ALL))
{
ret = !network.HasSecureCommandClass(command[0]);
}
else
{
ret = true;
}
}
return(ret);
}
public Components Clone()
{
var clone = new Components();
clone.Schemas = Schemas.ToDictionary(p => p.Key, p => p.Value);
clone.Messages = Messages.ToDictionary(p => p.Key, p => p.Value);
clone.SecuritySchemes = SecuritySchemes.ToDictionary(p => p.Key, p => p.Value);
clone.Parameters = Parameters.ToDictionary(p => p.Key, p => p.Value);
clone.CorrelationIds = CorrelationIds.ToDictionary(p => p.Key, p => p.Value);
clone.ServerBindings = ServerBindings.ToDictionary(p => p.Key, p => p.Value);
clone.ChannelBindings = ChannelBindings.ToDictionary(p => p.Key, p => p.Value);
clone.OperationBindings = OperationBindings.ToDictionary(p => p.Key, p => p.Value);
clone.MessageBindings = MessageBindings.ToDictionary(p => p.Key, p => p.Value);
clone.OperationTraits = OperationTraits.ToDictionary(p => p.Key, p => p.Value);
clone.MessageTraits = MessageTraits.ToDictionary(p => p.Key, p => p.Value);
return(clone);
}
/// <summary>
/// Activates network key from with specified security class for specified nodes
/// </summary>
/// <param name="peerNodeId">MSB is local NodeId, LSB is remote NodeId</param>
/// <param name="scheme">scheme</param>
public void ActivateNetworkKeyS2ForNode(InvariantPeerNodeId peerNodeId, SecuritySchemes scheme)
{
byte[] networkKey = null;
if (scheme == SecuritySchemes.S2_TEMP)
{
networkKey = GetActualNetworkKeyS2Temp();
}
else
{
networkKey = GetActualNetworkKey(scheme);
}
if (peerNodeId.IsEmpty)
{
_defaultActiveNetworkKeyType = scheme;
}
FireNetworkKeyS2Changed(peerNodeId, networkKey, scheme);
}
private void Network_S2SchemeSettingsChanged(SecuritySchemes scheme, bool isEnabled)
{
if (SecuritySchemeSet.ALLS2.Contains(scheme))
{
var nodeIds = _nodesMask.Where(id => id != Network.NodeId && Network.HasSecurityScheme(id, scheme)).ToList();
var selfNodeId = Network.NodeId;
foreach (var id in nodeIds)
{
var key = new InvariantPeerNodeId(selfNodeId, id);
if (ScKeys.ContainsKey(key))
{
if ((int)scheme >= (int)ScKeys[key].SecurityScheme)
{
ScKeys.Remove(key);
}
}
}
if (MpanTable != null)
{
var groups = MpanTable.SelectGroupIds(selfNodeId).Where(
groupId =>
{
var container = MpanTable.GetContainer(new NodeGroupId(selfNodeId, groupId));
if (container != null)
{
return(container.ReceiverGroupHandle.Intersect(nodeIds).Any());
}
return(false);
});
foreach (var groupId in groups)
{
var peerGroupId = new NodeGroupId(selfNodeId, groupId);
McKeys.Remove(peerGroupId);
}
}
}
}
/// <summary>
/// Returns index of the Network key of the specified security scheme
/// in the network keys array
/// </summary>
/// <param name="scheme">scheme</param>
/// <returns>index</returns>
public static int GetNetworkKeyIndex(SecuritySchemes scheme)
{
int ret = -1;
switch (scheme)
{
case SecuritySchemes.S2_UNAUTHENTICATED:
ret = NetworkKeyS2Flags.S2Class0.GetByteFlagIndex();
break;
case SecuritySchemes.S2_AUTHENTICATED:
ret = NetworkKeyS2Flags.S2Class1.GetByteFlagIndex();
break;
case SecuritySchemes.S2_ACCESS:
ret = NetworkKeyS2Flags.S2Class2.GetByteFlagIndex();
break;
case SecuritySchemes.S0:
ret = NetworkKeyS2Flags.S0.GetByteFlagIndex();
break;
}
return(ret);
}
internal static SecuritySchemes ConvertToSecurityScheme(NetworkKeyS2Flags verifyKey)
{
SecuritySchemes ret = SecuritySchemes.NONE;
switch (verifyKey)
{
case NetworkKeyS2Flags.S2Class0:
ret = SecuritySchemes.S2_UNAUTHENTICATED;
break;
case NetworkKeyS2Flags.S2Class1:
ret = SecuritySchemes.S2_AUTHENTICATED;
break;
case NetworkKeyS2Flags.S2Class2:
ret = SecuritySchemes.S2_ACCESS;
break;
case NetworkKeyS2Flags.S0:
ret = SecuritySchemes.S0;
break;
}
return(ret);
}
public static SecurityClasses GetSecurityClass(SecuritySchemes scheme)
{
SecurityClasses ret = SecurityClasses.None;
switch (scheme)
{
case SecuritySchemes.S2_UNAUTHENTICATED:
ret = SecurityClasses.S2Class0;
break;
case SecuritySchemes.S2_AUTHENTICATED:
ret = SecurityClasses.S2Class1;
break;
case SecuritySchemes.S2_ACCESS:
ret = SecurityClasses.S2Class2;
break;
case SecuritySchemes.S0:
ret = SecurityClasses.S0;
break;
}
return(ret);
}
public static SecuritySchemes GetSecurityScheme(SecurityClasses securityClass)
{
SecuritySchemes ret = SecuritySchemes.NONE;
switch (securityClass)
{
case SecurityClasses.S2Class0:
ret = SecuritySchemes.S2_UNAUTHENTICATED;
break;
case SecurityClasses.S2Class1:
ret = SecuritySchemes.S2_AUTHENTICATED;
break;
case SecurityClasses.S2Class2:
ret = SecuritySchemes.S2_ACCESS;
break;
case SecurityClasses.S0:
ret = SecuritySchemes.S0;
break;
}
return(ret);
}
/// <summary>
/// Shortcut to add a security requirement that is not <see cref="SecuritySchemes.Oauth2"/>
/// </summary>
/// <param name="securityScheme">
/// The security scheme.
/// </param>
/// <returns>
/// The <see cref="SwaggerRootBuilder"/>.
/// </returns>
public SwaggerRootBuilder SecurityRequirement(SecuritySchemes securityScheme)
{
return(this.SecurityRequirement(new SecurityRequirementBuilder().SecurityScheme(securityScheme).Build()));
}
/// <summary>
/// The security scheme.
/// </summary>
/// <param name="scheme">
/// The scheme.
/// </param>
/// <returns>
/// The <see cref="SecurityRequirementBuilder"/>.
/// </returns>
public SecurityRequirementBuilder SecurityScheme(SecuritySchemes scheme)
{
this.scheme = scheme;
return this;
}
protected virtual void SaveDataForRetransmission(InvariantPeerNodeId peerNodeId, byte[] plainData, SubstituteSettings substituteSettings, SecuritySchemes scheme)
{
}
protected override void OnHandledInternal(DataReceivedUnit ou)
{
var destNodeId = ReceivedAchData.DestNodeId > 0 ? ReceivedAchData.DestNodeId : _securityManagerInfo.Network.NodeId;
SecuritySchemes scheme = SecuritySchemes.NONE;
InvariantPeerNodeId peerNodeId = new InvariantPeerNodeId(destNodeId, ReceivedAchData.SrcNodeId);
ou.SetNextActionItems();
if (!ou.DataFrame.IsSkippedSecurity)
{
if (_securityManagerInfo.Network.HasSecurityScheme(SecuritySchemeSet.ALLS2) && _securityManagerInfo.IsActive)
{
byte[] command = ReceivedAchData.Command;
bool isNonceReport = false;
bool isSupportedReport = false; // Only for test frame
Extensions extensions = null;
SubstituteSettings substituteSettings = null;
if (command != null && command.Length > 1)
{
bool isSubstituteDenied = false;
byte[] dataToSend = null;
bool isMulticastFrame = (ou.DataFrame.Data[2] & MULTICAST_MASK) == MULTICAST_MASK;
bool isBroadcastFrame = (ou.DataFrame.Data[2] & BROADCAST_MASK) == BROADCAST_MASK;
if (command[1] == COMMAND_CLASS_SECURITY_2.SECURITY_2_NONCE_GET.ID && (SecuritySchemes)ReceivedAchData.SecurityScheme == SecuritySchemes.NONE)
{
byte rxSequenceNumber = command[2];
if (!isMulticastFrame && !isBroadcastFrame)
{
if (handlingNonceGetFromNode != ReceivedAchData.SrcNodeId)
{
handlingNonceGetFromNode = ReceivedAchData.SrcNodeId;
var currentTxSequenceNumber = _spanTable.GetTxSequenceNumber(peerNodeId);
_spanTable.SetNonceFree(peerNodeId);
//reset MPAN for owner Id
foreach (byte groupId in _mpanTable.SelectGroupIds(ReceivedAchData.SrcNodeId))
{
_mpanTable.RemoveRecord(new NodeGroupId(ReceivedAchData.SrcNodeId, groupId));
}
dataToSend = _securityS2CryptoProvider.GenerateNonceReport(_spanTable, peerNodeId, ++currentTxSequenceNumber, rxSequenceNumber, true, false);
isNonceReport = true;
isSubstituteDenied = true;
}
}
}
else if (command[1] == COMMAND_CLASS_SECURITY_2.SECURITY_2_MESSAGE_ENCAPSULATION.ID)
{
byte rxSequenceNumber = command[2];
if (!isMulticastFrame && !isBroadcastFrame && ValidateS2MessageExtensions(command))
{
var currentTxSequenceNumber = _spanTable.GetTxSequenceNumber(peerNodeId);
_spanTable.SetNonceFree(peerNodeId);
var isMos = _securityS2CryptoProvider.CheckMpanMosForOwnerNode(_mpanTable, ReceivedAchData.SrcNodeId);
dataToSend = _securityS2CryptoProvider.GenerateNonceReport(_spanTable, peerNodeId, ++currentTxSequenceNumber, rxSequenceNumber, true, isMos);
isNonceReport = true;
isSubstituteDenied = true;
}
}
else if (command[1] == COMMAND_CLASS_SECURITY_2.SECURITY_2_NONCE_REPORT.ID && (SecuritySchemes)ReceivedAchData.SecurityScheme == SecuritySchemes.NONE)
{
if (!isMulticastFrame && !isBroadcastFrame)
{
COMMAND_CLASS_SECURITY_2.SECURITY_2_NONCE_REPORT nonceReportCmd = command;
if (_securityManagerInfo.InitializingNodeId != ReceivedAchData.SrcNodeId) // Node must be already initialized.
{
if (nonceReportCmd.properties1.sos > 0 && // Singlecast out of sync.
nonceReportCmd.receiversEntropyInput != null &&
nonceReportCmd.receiversEntropyInput.Count == 16
)
{
var rTable = _securityManagerInfo.RetransmissionTableS2;
if (rTable.ContainsKey(peerNodeId))
{
if (rTable[peerNodeId].Counter > 0)
{
_spanTable.AddOrReplace(peerNodeId,
nonceReportCmd.receiversEntropyInput.ToArray(),
_spanTable.GetTxSequenceNumber(peerNodeId),
nonceReportCmd.sequenceNumber);
dataToSend = rTable[peerNodeId].Data;
scheme = rTable[peerNodeId].SecurityScheme;
substituteSettings = rTable[peerNodeId].SubstituteSettings;
rTable[peerNodeId].Counter--;
}
else
{
rTable.Remove(peerNodeId);
_spanTable.SetNonceFree(peerNodeId);
}
}
else
{
_spanTable.SetNonceFree(peerNodeId);
}
}
if (nonceReportCmd.properties1.mos > 0) // Mutlicast out of sync.
{
var groupId = _securityS2CryptoProvider.LastSentMulticastGroupId;
extensions = new Extensions();
var nodeGroupId = new NodeGroupId(destNodeId, groupId);
if (!_mpanTable.CheckMpanExists(nodeGroupId))
{
_mpanTable.AddOrReplace(nodeGroupId, 0x55, null, _securityS2CryptoProvider.GetRandomData());
}
extensions.AddMpanExtension(_mpanTable.GetContainer(nodeGroupId).MpanState, groupId);
}
}
}
}
else if (command[1] == COMMAND_CLASS_SECURITY_2.SECURITY_2_COMMANDS_SUPPORTED_GET.ID)
{
if (!isMulticastFrame && !isBroadcastFrame)
{
scheme = (SecuritySchemes)ReceivedAchData.SecurityScheme;
if (scheme != SecuritySchemes.NONE && scheme != SecuritySchemes.S0 && _securityManagerInfo.Network.HasSecurityScheme(scheme))
{
if (!_securityManagerInfo.Network.HasSecurityScheme(ReceivedAchData.SrcNodeId, SecuritySchemeSet.ALLS2) &&
!_securityManagerInfo.Network.IsSecuritySchemesSpecified(ReceivedAchData.SrcNodeId))
{
_securityManagerInfo.Network.SetSecuritySchemes(ReceivedAchData.SrcNodeId, SecuritySchemeSet.ALL);
}
isSupportedReport = true;
var ccReport = new COMMAND_CLASS_SECURITY_2.SECURITY_2_COMMANDS_SUPPORTED_REPORT();
if (ReceivedAchData.CommandType == CommandTypes.CmdApplicationCommandHandler_Bridge &&
ReceivedAchData.DestNodeId != _securityManagerInfo.Network.NodeId)
{
ccReport.commandClass = new List <byte>(_securityManagerInfo.Network.GetVirtualSecureCommandClasses());
}
else
{
var secureCommandClasses = _securityManagerInfo.Network.GetSecureCommandClasses();
if (secureCommandClasses != null)
{
switch (scheme)
{
case SecuritySchemes.S2_UNAUTHENTICATED:
if (!_securityManagerInfo.Network.HasSecurityScheme(SecuritySchemes.S2_ACCESS) &&
!_securityManagerInfo.Network.HasSecurityScheme(SecuritySchemes.S2_AUTHENTICATED))
{
ccReport.commandClass = new List <byte>(_securityManagerInfo.Network.GetSecureCommandClasses());
}
break;
case SecuritySchemes.S2_AUTHENTICATED:
if (!_securityManagerInfo.Network.HasSecurityScheme(SecuritySchemes.S2_ACCESS))
{
ccReport.commandClass = new List <byte>(_securityManagerInfo.Network.GetSecureCommandClasses());
}
break;
case SecuritySchemes.S2_ACCESS:
ccReport.commandClass = new List <byte>(secureCommandClasses);
break;
default:
break;
}
}
}
dataToSend = ccReport;
}
}
}
if (dataToSend != null || extensions != null)
{
ApiOperation sendData = null;
if (SecuritySchemeSet.ALLS2.Contains(scheme))
{
sendData = new SendDataExOperation(ReceivedAchData.DestNodeId, ReceivedAchData.SrcNodeId, dataToSend, _securityManagerInfo.TxOptions, scheme);
}
else
{
if (ReceivedAchData.DestNodeId > 0)
{
sendData = new SendDataBridgeOperation(ReceivedAchData.DestNodeId, ReceivedAchData.SrcNodeId, dataToSend, _securityManagerInfo.TxOptions);
if (extensions != null)
{
((SendDataBridgeOperation)sendData).Extensions = extensions;
}
}
else
{
sendData = new SendDataOperation(ReceivedAchData.SrcNodeId, dataToSend, _securityManagerInfo.TxOptions);
if (extensions != null)
{
((SendDataOperation)sendData).Extensions = extensions;
}
}
}
if (substituteSettings != null)
{
sendData.SubstituteSettings = substituteSettings;
}
if (isSubstituteDenied)
{
sendData.SubstituteSettings.SetFlag(SubstituteFlags.DenySecurity);
}
sendData.CompletedCallback = (x) =>
{
var action = x as ActionBase;
if (action != null)
{
handlingNonceGetFromNode = 0;
SpecificResult.TotalCount++;
if (action.Result.State != ActionStates.Completed)
{
SpecificResult.FailCount++;
}
}
};
#region TestFrames
if (isNonceReport)
{
_securityTestSettingsService.ActivateTestPropertiesForFrame(SecurityS2TestFrames.NonceReport, sendData);
}
else if (isSupportedReport)
{
_securityTestSettingsService.ActivateTestPropertiesForFrame(SecurityS2TestFrames.CommandsSupportedReport, sendData);
}
#endregion
ou.SetNextActionItems(sendData);
}
else
{
ou.SetNextActionItems();
}
}
}
else
{
"REJECT, {0}, {1} (IsNodeSecureS2={2}, IsActive={3}"._DLOG(
_securityManagerInfo.IsInclusion,
_securityManagerInfo.Network.HasSecurityScheme(ReceivedAchData.SrcNodeId, SecuritySchemeSet.ALLS2),
_securityManagerInfo.Network.HasSecurityScheme(SecuritySchemeSet.ALLS2),
_securityManagerInfo.IsActive);
}
}
}
/// <summary>
/// Shortcut to add a security requirement that is not <see cref="SecuritySchemes.Oauth2"/>
/// </summary>
/// <param name="securityScheme">
/// The security scheme.
/// </param>
/// <returns>
/// The <see cref="OperationBuilder"/>.
/// </returns>
public OperationBuilder SecurityRequirement(SecuritySchemes securityScheme)
{
return this.SecurityRequirement(new SecurityRequirementBuilder().SecurityScheme(securityScheme).Build());
}
