private static void startSNMP()
{
//Config. SNMP
//Communities Comuns: cr e public
SnmpSharpNet.OctetString community = new SnmpSharpNet.OctetString("public");
SNMPParameters = new AgentParameters(community)
{
Version = SnmpVersion.Ver2
};
}
public static void Start()
{
SnmpSharpNet.OctetString community = new SnmpSharpNet.OctetString("cr");
SNMPParameters = new AgentParameters(community);
SNMPParameters.Version = SnmpVersion.Ver2;
if (SNMPParameters != null)
{
Console.WriteLine("Parâmetros iniciados com sucesso");
}
DNP3Manager = DNP3ManagerFactory.CreateManager(4, new PrintingLogAdapter());
}
/// <summary>Copy constructor.</summary>
/// <param name="second">The object to copy</param>
public IpAddress(OctetString second) : this(second.GetData())
{
}
/// <summary>
/// Build SNMP discovery response packet.
/// </summary>
/// <remarks>
/// Manager application has to be able to respond to discovery requests to be able to handle
/// SNMPv3 INFORM notifications.
///
/// In an INFORM packet, engineId value is set to the manager stations id (unlike all other requests
/// where agent is the authoritative SNMP engine). For the agent to discover appropriate manager engine
/// id, boots and time values (required for authentication and privacy packet handling), manager has to
/// be able to respond to the discovery request.
/// </remarks>
/// <param name="messageId">Message id from the received discovery packet</param>
/// <param name="requestId">Request id from the received discovery packets Pdu</param>
/// <param name="engineId">Local engine id</param>
/// <param name="engineBoots">Number of times local SNMP engine has been restarted</param>
/// <param name="engineTime">Time since the engine was started in seconds</param>
/// <param name="unknownEngineIdCount">Number of discovery packets received by the local SNMP engine</param>
/// <returns>SNMP v3 packet properly formatted as a response to a discovery request</returns>
public static SnmpV3Packet DiscoveryResponse(Int32 messageId, Int32 requestId, OctetString engineId, Int32 engineBoots, Int32 engineTime, Int32 unknownEngineIdCount)
{
SnmpV3Packet packet = new SnmpV3Packet();
packet.Pdu.Type = PduType.Report;
packet.Pdu.RequestId = requestId;
packet.Pdu.VbList.Add(SnmpConstants.usmStatsUnknownEngineIDs, new Integer32(unknownEngineIdCount));
// discovery response is a report packet. We don't want to receive reports about a report
packet.MsgFlags.Reportable = false;
packet.SetEngineId(engineId);
packet.MessageId = messageId;
packet.USM.EngineBoots = engineBoots;
packet.USM.EngineTime = engineTime;
return(packet);
}
/// <summary>
/// Encode SNMP version 3 packet
/// </summary>
/// <param name="authKey">Authentication key (not password)</param>
/// <param name="privKey">Privacy key (not password)</param>
/// <remarks>
/// Before encoding the packet into a byte array you need to ensure all required information is
/// set. Examples of required information is request type, Vbs (Oid + values pairs), USM settings including
/// SecretName, authentication method and secret (if needed), privacy method and secret (if needed), etc.
/// </remarks>
/// <returns>Byte array BER encoded SNMP packet.</returns>
public byte[] Encode(byte[] authKey, byte[] privKey)
{
MutableByte buffer = new MutableByte();
// encode the global message data sequence header information
MutableByte globalMessageData = new MutableByte();
// if message id is 0 then generate a new, random message id
if (_messageId.Value == 0)
{
Random rand = new Random();
_messageId.Value = rand.Next(1, Int32.MaxValue);
}
// encode message id
_messageId.Encode(globalMessageData);
// encode max message size
_maxMessageSize.Encode(globalMessageData);
// message flags
MsgFlags.Encode(globalMessageData);
// security model code
_securityModel.Value = USM.Type;
_securityModel.Encode(globalMessageData);
// add global message data to the main buffer
// encode sequence header and add data
AsnType.BuildHeader(buffer, SnmpConstants.SMI_SEQUENCE, globalMessageData.Length);
buffer.Append(globalMessageData);
MutableByte packetHeader = new MutableByte(buffer);
// before going down this road, check if this is a discovery packet
OctetString savedUserName = new OctetString();
bool privacy = MsgFlags.Privacy;
bool authentication = MsgFlags.Authentication;
bool reportable = MsgFlags.Reportable;
if (USM.EngineId.Length <= 0)
{
// save USM settings prior to encoding a Discovery packet
savedUserName.Set(USM.SecurityName);
USM.SecurityName.Reset(); // delete security name for discovery packets
MsgFlags.Authentication = false;
MsgFlags.Privacy = false;
MsgFlags.Reportable = true;
}
USM.Encode(buffer);
if (USM.EngineId.Length <= 0)
{
// restore saved USM values
USM.SecurityName.Set(savedUserName);
MsgFlags.Authentication = authentication;
MsgFlags.Privacy = privacy;
MsgFlags.Reportable = reportable;
}
// Check if privacy encryption is required
MutableByte encodedPdu = new MutableByte();
if (MsgFlags.Privacy && USM.EngineId.Length > 0)
{
IPrivacyProtocol privacyProtocol = PrivacyProtocol.GetInstance(USM.Privacy);
if (privacyProtocol == null)
{
throw new SnmpException(SnmpException.UnsupportedPrivacyProtocol, "Specified privacy protocol is not supported.");
}
// Get BER encoded ScopedPdu
MutableByte unencryptedPdu = new MutableByte();
ScopedPdu.Encode(unencryptedPdu);
// we have to expand the key
IAuthenticationDigest auth = Authentication.GetInstance(USM.Authentication);
if (auth == null)
{
throw new SnmpException(SnmpException.UnsupportedNoAuthPriv, "Invalid authentication protocol. noAuthPriv mode not supported.");
}
byte[] encryptedBuffer = privacyProtocol.Encrypt(unencryptedPdu, 0, unencryptedPdu.Length, privKey, USM.EngineBoots, USM.EngineTime, out byte[] privacyParameters, auth);
USM.PrivacyParameters.Set(privacyParameters);
OctetString encryptedOctetString = new OctetString(encryptedBuffer);
encryptedOctetString.Encode(encodedPdu);
// now redo packet encoding
buffer.Reset();
buffer.Set(packetHeader);
USM.Encode(buffer);
int preEncodedLength = encodedPdu.Length;
buffer.Append(encodedPdu);
if (_maxMessageSize.Value != 0)
{
// verify compliance with maximum message size
if ((encodedPdu.Length - preEncodedLength) > _maxMessageSize)
{
throw new SnmpException(SnmpException.MaximumMessageSizeExceeded, "ScopedPdu exceeds maximum message size.");
}
}
}
else
{
ScopedPdu.Encode(encodedPdu);
buffer.Append(encodedPdu);
}
base.Encode(buffer);
if (MsgFlags.Authentication && USM.EngineId.Length > 0)
{
USM.Authenticate(authKey, ref buffer);
// Now re-encode the packet with the authentication information
USM.Encode(packetHeader);
packetHeader.Append(encodedPdu);
base.Encode(packetHeader);
buffer = packetHeader;
}
return(buffer);
}
/// <summary>
/// Decode SNMP version 3 packet. This method will perform authentication check and decode privacy protected <see cref="ScopedPdu"/>. This method will
/// not check for the timeliness of the packet, correct engine boot value or engine id because it does not have a reference to the engine time prior to this call.
/// </summary>
/// <param name="berBuffer">BER encoded SNMP version 3 packet buffer</param>
/// <param name="length">Buffer length</param>
/// <param name="authKey">Authentication key (not password)</param>
/// <param name="privKey">Privacy key (not password)</param>
public int Decode(byte[] berBuffer, int length, byte[] authKey, byte[] privKey)
{
MutableByte buffer = new MutableByte(berBuffer, length);
int offset = 0;
// let base class parse first sequence and SNMP version number
offset = base.Decode(buffer, length);
// check for correct SNMP protocol version
if (_protocolVersion != (int)SnmpVersion.Ver3)
{
throw new SnmpInvalidVersionException("Expecting SNMP version 3.");
}
// now grab the global message data sequence header information
byte asnType = AsnType.ParseHeader(buffer, ref offset, out int len);
if (asnType != SnmpConstants.SMI_SEQUENCE)
{
throw new SnmpDecodingException("Invalid sequence type in global message data sequence.");
}
// check that packet size can accommodate the length specified in the header
if (len > (buffer.Length - offset))
{
throw new OverflowException("Packet is too small to contain the data described in the header.");
}
// retrieve message id
offset = _messageId.Decode(buffer, offset);
// max message size
offset = _maxMessageSize.Decode(buffer, offset);
// message flags
offset = MsgFlags.Decode(buffer, offset);
// verify that a valid authentication/privacy configuration is present in the packet
if (MsgFlags.Authentication == false && MsgFlags.Privacy == true)
{
throw new SnmpException(SnmpException.UnsupportedNoAuthPriv, "SNMP version 3 noAuthPriv security combination is not supported.");
}
// security model code
offset = _securityModel.Decode(buffer, offset);
// we only support USM. code = 0x03
if (_securityModel.Value != USM.Type)
{
throw new SnmpException(SnmpException.UnsupportedSecurityModel, "Class only support SNMP Version 3 User Security Model.");
}
// parse user security model
offset = USM.Decode(buffer, offset);
// Authenticate message if authentication flag is set and packet is not a discovery packet
if (MsgFlags.Authentication && USM.EngineId.Length > 0)
{
// Authenticate packet
if (USM.AuthenticationParameters.Length != 12)
{
throw new SnmpAuthenticationException("Invalid authentication parameter field length.");
}
if (!USM.IsAuthentic(authKey, buffer))
{
throw new SnmpAuthenticationException("Authentication of the incoming packet failed.");
}
}
// Decode ScopedPdu if it is privacy protected and packet is not a discovery packet
if (MsgFlags.Privacy && USM.EngineId.Length > 0)
{
IPrivacyProtocol privacyProtocol = PrivacyProtocol.GetInstance(USM.Privacy);
if (privacyProtocol == null)
{
throw new SnmpException(SnmpException.UnsupportedPrivacyProtocol, "Privacy protocol requested is not supported.");
}
if (USM.PrivacyParameters.Length != privacyProtocol.PrivacyParametersLength)
{
throw new SnmpException(SnmpException.InvalidPrivacyParameterLength, "Invalid privacy parameters field length.");
}
// Initialize a temporary OctetString class to hold encrypted ScopedPdu
OctetString encryptedScopedPdu = new OctetString();
offset = encryptedScopedPdu.Decode(buffer, offset);
// decode encrypted packet
byte[] decryptedScopedPdu = privacyProtocol.Decrypt(encryptedScopedPdu, 0, encryptedScopedPdu.Length, privKey, USM.EngineBoots, USM.EngineTime, USM.PrivacyParameters);
int tempOffset = 0;
offset = ScopedPdu.Decode(decryptedScopedPdu, tempOffset);
}
else
{
offset = ScopedPdu.Decode(buffer, offset);
}
return(offset);
}
