def add_transport(snmpEngine, PORT, ip_type):
"""
:param snmpEngine:
:return:
"""
try:
if ip_type == '6':
config.addTransport(
snmpEngine, udp.domainName,
udp6.Udp6SocketTransport().openServerMode(('::', int(PORT))))
else:
config.addTransport(
snmpEngine, udp.domainName,
udp.UdpTransport().openServerMode(('0.0.0.0', int(PORT))))
except error.CarrierError as excep:
print "Port Binding Failed the Provided Port {} is in Use".format(PORT)
def run_trap_listener():
if not traffy_config.ENABLE_SNMP:
print("SNMP not enabled! Exiting...")
exit()
if not traffy_config.ENABLE_TRAP:
print("Trap not enabled! Exiting...")
exit()
snmp_engine = engine.SnmpEngine()
config.addTransport(
snmp_engine, udp.domainName,
udp.UdpTransport().openServerMode(
("0.0.0.0", traffy_config.TRAP_PORT)))
for id in traffy_config.SWITCHES:
config.addV3User(snmp_engine,
traffy_config.SWITCHES[id]["username"],
config.usmHMACSHAAuthProtocol,
traffy_config.SWITCHES[id]["password"],
config.usmDESPrivProtocol,
traffy_config.SWITCHES[id]["password"],
securityEngineId=v2c.OctetString(
hexValue=traffy_config.SWITCHES[id]["engine_id"]))
ntfrcv.NotificationReceiver(snmp_engine, trap_callback)
snmp_engine.transportDispatcher.jobStarted(1)
try:
snmp_engine.transportDispatcher.runDispatcher()
except:
snmp_engine.transportDispatcher.closeDispatcher()
def receiveTraps(): #checks for incoming traps
try:
snmpEngine = SnmpEngine()
TrapAgentAddress = 'localhost'
Port = 162
print("Now listening for Trap on " + TrapAgentAddress + ":" +
str(Port) + "...\n")
config.addTransport(
snmpEngine, udp.domainName + (1, ),
udp.UdpTransport().openServerMode((TrapAgentAddress, Port)))
config.addV1System(snmpEngine, 'community', 'public')
def trapOutput(snmpEngine, stateReference, contextEngineId,
contextName, varBinds, cbCtx):
print("Received new Trap message")
for name, val in varBinds: #iterates through each received oid pair
print('%s = %s' %
(name.prettyPrint(),
val.prettyPrint())) #pretty Print to make it readable
return
ntfrcv.NotificationReceiver(snmpEngine, trapOutput)
snmpEngine.transportDispatcher.jobStarted(1)
try:
snmpEngine.transportDispatcher.runDispatcher()
except:
snmpEngine.transportDispatcher.closeDispatcher()
raise
except KeyboardInterrupt:
return
def traprcv(self):
"""Create SNMP engine with autogenernated engineID and pre-bound to socket transport dispatcher"""
snmpEngine = engine.SnmpEngine()
"""Transport setup # UDP over IPv4, first listening interface/port"""
config.addTransport(
snmpEngine,
udp.domainName + (1,),
udp.UdpTransport().openServerMode((self.hosta, self.porta))
)
"""UDP over IPv4, second listening interface/port"""
config.addTransport(
snmpEngine,
udp.domainName + (2,),
udp.UdpTransport().openServerMode((self.hostb, self.portb))
)
"""SNMPv1/2c setup # SecurityName <-> CommunityName mapping"""
config.addV1System(snmpEngine, 'my-area', 'public')
"""Register SNMP Application at the SNMP engine"""
ntfrcv.NotificationReceiver(snmpEngine, self.cbFun)
"""this job would never finish"""
snmpEngine.transportDispatcher.jobStarted(1)
"""Run I/O dispatcher which would receive queries and send confirmations"""
try:
snmpEngine.transportDispatcher.runDispatcher()
except IOError:
snmpEngine.transportDispatcher.closeDispatcher()
raise
finally:
pass
def listen(
address=DEFAULT_ADDRESSS,
port=DEFAULT_PORT,
community=DEFAULT_COMMUNITY,
mibs=DEFAULT_MIBS,
):
"""Listen to and SNMP trap and print events."""
# Based on pySNMP example code.
mib_builder = builder.MibBuilder()
compiler.addMibCompiler(mib_builder)
mib_builder.loadModules(*mibs)
global _view_controller
_view_controller = view.MibViewController(mib_builder)
loop = asyncio.get_event_loop()
snmp_engine = engine.SnmpEngine()
print(f"Agent is listening SNMP Trap on {address}, Port: {port}")
if port < 1024:
print(
"WARNING: Port < 1024. Root priviledges or authbind required on *nix systems."
)
print("-" * 79)
config.addTransport(
snmp_engine,
udp.domainName + (1, ),
udp.UdpTransport().openServerMode((address, port)),
)
config.addV1System(snmp_engine, community, community)
ntfrcv.NotificationReceiver(snmp_engine, _listen_callback)
print("Press CTRL-C to quit.")
loop.run_forever()
def _setup(self):
""" Setup Server """
assert isinstance(self._callbacks, list), \
"callbacks should be list of functions type not %s" % type(
self._callbacks)
snmp_engine = engine.SnmpEngine()
build = snmp_engine.getMibBuilder()
if self._add_mib_dir:
if not os.path.exists(self._add_mib_dir):
raise PiatError("mib dir does not exist, dir=%r" %
self._add_mib_dir)
if not os.path.isdir(self._add_mib_dir):
raise PiatError(
"add_mib_dir should be a directory not a file, add_mib_dir=%r"
% self._add_mib_dir)
build.addMibSources(builder.DirMibSource(self._add_mib_dir))
build.loadModules()
viewer = view.MibViewController(build)
# UDP over IPv4, first listening interface/port
transport = udp.UdpTransport()
config.addTransport(snmp_engine, udp.domainName + (1, ),
transport.openServerMode(('0.0.0.0', self._port)))
# SecurityName <-> CommunityName mapping
config.addV1System(snmp_engine, '????', self._community)
# Register SNMP Application at the SNMP engine
handler = TrapsHandler(self._callbacks, viewer)
ntfrcv.NotificationReceiver(snmp_engine, handler.handle)
self._snmpEngine = snmp_engine
def setup_transport(self):
transport_domain = udp.domainName + (self.engine_id,)
self.engine.registerTransportDispatcher(self.transport_dispatcher,
transport_domain)
config.addTransport(self.engine, transport_domain,
udp.UdpTransport().openServerMode(
(self.ip, self.port)))
def setSnmpTransport(snmpEngine, listen=None, iface=None, iface_num=0):
"""Create network endpoint for SNMP communication.
Args:
snmpEngine (object): pysnmp `SnmpEngine` class instance
listen (tuple): if given, should refer to a local network address
for SNMP engine to listen for SNMP packets. If not given,
client-side operation is assumed. When `listen` is given, must be
in `socket` format (i.e. ('XXX.XXX.XXX.XXX', NNN)).
iface (tuple): if given, should refer to a local network address
for SNMP engine to send SNMP packets from. When `iface` is given,
must be in `socket` format (i.e. ('XXX.XXX.XXX.XXX', NNN)).
iface_num (int): UDP transport instance ID. Default is 0.
Returns:
tuple: SNMP UDP transport domain instance ID
"""
transport = udp.UdpAsyncioTransport()
if listen:
transport = transport.openServerMode(listen)
else:
transport = transport.openClientMode(iface=iface)
transportDomain = udp.domainName + (iface_num,)
config.addTransport(snmpEngine, transportDomain, transport)
return transportDomain
def initialize_snmp_listener(community, port):
# Bind SNMP to socket transport dispatcher
snmpEngine = engine.SnmpEngine()
# Transport setup
# UDP over IPv4, first listening interface/port
config.addTransport(snmpEngine, udp.domainName + (1, ),
udp.UdpTransport().openServerMode(('0.0.0.0', port)))
logger.debug(f'listening on port: {port} - the standard port is 162')
# SNMPv1/2c setup
# SecurityName <-> CommunityName mapping
config.addV1System(snmpEngine, 'my-area', community)
# Register SNMP Application at the SNMP engine
ntfrcv.NotificationReceiver(snmpEngine, handle_mac_notification)
snmpEngine.transportDispatcher.jobStarted(1) # this job would never finish
# Run I/O dispatcher which would receive queries and send confirmations
try:
logger.debug(f"SNMP Engine running")
snmpEngine.transportDispatcher.runDispatcher()
except:
snmpEngine.transportDispatcher.closeDispatcher()
logger.debug(f"SNMP Engine failure ")
raise
def _add_transport(self):
"""Configures the transport parameters for the snmp engine."""
try:
config.addTransport(
self.snmp_engine, udp.domainName,
udp.UdpTransport().openServerMode(
(self.trap_receiver_address,
int(self.trap_receiver_port))))
except Exception:
raise ValueError("Port binding failed: Port is in use.")
def _add_transport(self):
"""Configures the transport parameters for the snmp engine."""
try:
config.addTransport(
self.snmp_engine,
udp.domainName,
udp.UdpTransport().openServerMode(
(self.trap_receiver_address, int(self.trap_receiver_port)))
)
except Exception as e:
LOG.error('Failed to add transport, error is %s'
% six.text_type(e))
raise exception.DelfinException(message=six.text_type(e))
def main():
# Instantiate snmp engine
snmpEngine = engine.SnmpEngine()
# Load MIBs (for translation of the numeric OIDs)
mibBuilder = builder.MibBuilder().loadModules('SNMPv2-MIB', 'SNMP-COMMUNITY-MIB')
mibViewController = view.MibViewController(mibBuilder)
# Transport setup
# UDP over IPv6, listening interface/port
config.addTransport(
snmpEngine,
udp6.domainName + (1,),
udp6.Udp6Transport().openServerMode(('::', TRAP_PORT))
)
# SNMPv2c setup
# SecurityName <-> CommunityName mapping
config.addV1System(snmpEngine, 'my-area', 'public')
# Callback function for receiving notifications
# noinspection PyUnusedLocal,PyUnusedLocal,PyUnusedLocal
def cbFun(snmpEngine, stateReference, contextEngineId, contextName,
varBinds, cbCtx):
# Translate numerical OIDs into human readable form
varBinds = [rfc1902.ObjectType(rfc1902.ObjectIdentity(x[0]), x[1]).resolveWithMib(mibViewController) for x in varBinds]
# Turn on write permission for everyone
os.umask(0)
# Open file, append new data at the end
with open(os.open(TRAP_LOG_PATH, os.O_CREAT | os.O_WRONLY, 0o777), 'a+') as f:
t = time.gmtime()
f.write('TRAP received on %s from ContextEngineId "%s", ContextName "%s" \n' % (time.strftime('%c', t), contextEngineId.prettyPrint(),
contextName.prettyPrint()))
# Write data in file
for varbind in varBinds:
f.write(varbind.prettyPrint()+'\n')
f.write('\n')
# Register SNMP Application at the SNMP engine
ntfrcv.NotificationReceiver(snmpEngine, cbFun)
snmpEngine.transportDispatcher.jobStarted(1) # Start a job that will never finish
# Run I/O dispatcher which would receive queries and send confirmations
try:
snmpEngine.transportDispatcher.runDispatcher()
except:
snmpEngine.transportDispatcher.closeDispatcher()
raise
def __init__(self, ip, port, community='public'):
self.LISTENER = ip
self.LISTENER_PORT = port
self.snmpEngine = engine.SnmpEngine()
self.trap_sources = []
self.community = community
self.traps = {}
config.addTransport(
self.snmpEngine, udp.domainName + (1, ),
udp.UdpTransport().openServerMode(
(self.LISTENER, self.LISTENER_PORT)))
print('Starting SNMP server on %s port %s with community %s.' %
(self.LISTENER, self.LISTENER_PORT, community))
config.addV1System(self.snmpEngine, 'testindex', community)
self.stopped = False
def trap_receiver():
myAddress = socket.gethostbyname(socket.gethostname())
snmpEngine = engine.SnmpEngine()
TrapAgentAddress = myAddress
Port = 162
config.addTransport(
snmpEngine, udp.domainName + (1, ),
udp.UdpTransport().openServerMode((TrapAgentAddress, Port)))
config.addV1System(snmpEngine, 'my-area', 'public')
ntfrcv.NotificationReceiver(snmpEngine, cbFun)
snmpEngine.transportDispatcher.jobStarted(1)
try:
snmpEngine.transportDispatcher.runDispatcher()
except:
snmpEngine.transportDispatcher.closeDispatcher()
raise
def create_trap_listner_job(cls, port="162"):
"""
Create Trap listner job
:param port:
:return:None
"""
mibBuilder = builder.MibBuilder()
custom_mib_path = cls.data_repo.get("custom_mib_path")
load_mib_module = cls.data_repo.get("load_mib_module")
temp_custom_mib_paths = []
if custom_mib_path and load_mib_module:
custom_mib_paths = custom_mib_path.split(',')
for paths in custom_mib_paths:
paths = paths.strip()
if 'http' in paths and '@mib@' not in paths:
if paths[-1] == '/':
paths = paths + '/@mib@'
else:
paths = paths + '@mib@'
if 'http' in paths and 'browse' in paths:
paths = paths.replace('browse', 'raw')
if 'http' in paths and 'browse' in paths:
paths = paths.replace('browse', 'raw')
temp_custom_mib_paths.append(paths)
if os.name == 'posix' and '/usr/share/snmp/' not in custom_mib_path:
temp_custom_mib_paths.append('/usr/share/snmp/')
try:
compiler.addMibCompiler(mibBuilder,
sources=temp_custom_mib_paths)
cls.mibViewController = view.MibViewController(mibBuilder)
mibs = load_mib_module.split(",")
mibBuilder.loadModules(*mibs)
except error.MibNotFoundError as excep:
testcase_Utils.pNote("{} Mib Not Found!".format(excep),
"Error")
snmpEngine = cls.get_asyncoredispatcher(port)
udptransport = udp.UdpTransport()
cls.udptransport.update({"udptransport{}".format(port): udptransport})
config.addTransport(
snmpEngine, udp.domainName,
udptransport.openServerMode(('0.0.0.0', int(port))))
snmpEngine.transportDispatcher.jobStarted(1)
def __init__(self, out_q):
# Create SNMP engine with autogenernated engineID and pre-bound
# to socket transport dispatcher
snmpEngine = engine.SnmpEngine()
# Transport setup
# UDP over IPv4, first listening interface/port
config.addTransport(snmpEngine, udp.domainName + (1, ),
udp.UdpTransport().openServerMode((IP, 162)))
# SNMPv1/2c setup
# SecurityName <-> CommunityName mapping
config.addV1System(snmpEngine, 'my-area', 'public')
# Callback function for receiving notifications
# noinspection PyUnusedLocal,PyUnusedLocal,PyUnusedLocal
def cbFun(snmpEngine, stateReference, contextEngineId, contextName,
varBinds, cbCtx):
print('Notification from ContextEngineId "%s", ContextName "%s"' %
(contextEngineId.prettyPrint(), contextName.prettyPrint()))
for name, val in varBinds:
print('%s = %s' % (name.prettyPrint(), val.prettyPrint()))
out_q.put("teste")
# Register SNMP Application at the SNMP engine
if ntfrcv.NotificationReceiver(snmpEngine, cbFun):
print "HEEEE"
snmpEngine.transportDispatcher.jobStarted(
1) # this job would never finish
# Run I/O dispatcher which would receive queries and send confirmations
try:
snmpEngine.transportDispatcher.runDispatcher()
except:
snmpEngine.transportDispatcher.closeDispatcher()
raise
def trap_engine():
snmpEngine = engine.SnmpEngine()
print('[SNMP API] Trap Server listening on ' + listening_ip + ":" +
str(listening_port))
config.addTransport(
snmpEngine, udp.domainName + (1, ),
udp.UdpTransport().openServerMode((listening_ip, listening_port)))
config.addV1System(snmpEngine, 'my-area', 'public')
def callback(eng, ref, eng_id, name, var_binds, cb_ctx):
sender_domain, sender_address = eng.msgAndPduDsp.getTransportInfo(ref)
if not trap_list.__contains__(sender_address[0]):
trap_list.append(sender_address[0])
ntfrcv.NotificationReceiver(snmpEngine, callback)
snmpEngine.transportDispatcher.jobStarted(1)
try:
snmpEngine.transportDispatcher.runDispatcher()
finally:
snmpEngine.transportDispatcher.closeDispatcher()
raise
def createSNMP(host, community=None):
if community is None:
community = "public"
ip = gethostbyname(host)
snmpEngine = engine.SnmpEngine()
config.addV1System(snmpEngine, 'my-area', community)
config.addTargetParams(snmpEngine, 'my-creds', 'my-area', 'noAuthNoPriv',
0)
config.addTransport(snmpEngine, udp.domainName,
udp.UdpSocketTransport().openClientMode())
config.addTargetAddr(snmpEngine, 'my-router', udp.domainName, (ip, 161),
'my-creds')
cmdgen.NextCommandGenerator().sendVarBinds(
snmpEngine, 'my-router', None, '',
[((1, 3, 6, 1, 2, 1, 1, 0, 0), None)], getHost)
snmpEngine.transportDispatcher.runDispatcher()
cmdgen.NextCommandGenerator().sendVarBinds(
snmpEngine, 'my-router', None, '',
[((1, 3, 6, 1, 2, 1, 4, 34, 1, 3, 2, 16), None)], getAddrs)
snmpEngine.transportDispatcher.runDispatcher()
config.addV3User(
snmpEngine, 'usr-md5-des',
config.usmHMACMD5AuthProtocol, 'authkey1',
config.usmDESPrivProtocol, 'privkey1'
)
config.addTargetParams(snmpEngine, 'my-creds', 'usr-md5-des', 'authPriv')
#
# Setup transport endpoint and bind it with security settings yielding
# a target name
#
# UDP/IPv4
config.addTransport(
snmpEngine,
udp.domainName,
udp.UdpTwistedTransport().openClientMode()
)
config.addTargetAddr(
snmpEngine, 'my-router',
udp.domainName, ('195.218.195.228', 161),
'my-creds'
)
# Error/response receiver
def cbFun(cbCtx):
(errorIndication, errorStatus, errorIndex, varBindTable) = cbCtx
if errorIndication:
print(errorIndication)
elif errorStatus:
print('%s at %s' % (
def cfgCmdGen(self, authData, transportTarget):
if isinstance(authData, CommunityData):
if authData.communityIndex not in self.__knownAuths:
config.addV1System(self.snmpEngine, authData.communityIndex,
authData.communityName,
authData.contextEngineId,
authData.contextName, authData.tag,
authData.securityName)
self.__knownAuths[authData.communityIndex] = authData
elif isinstance(authData, UsmUserData):
authDataKey = authData.userName, authData.securityEngineId
if authDataKey not in self.__knownAuths:
config.addV3User(self.snmpEngine,
authData.userName,
authData.authProtocol,
authData.authKey,
authData.privProtocol,
authData.privKey,
authData.securityEngineId,
securityName=authData.securityName)
self.__knownAuths[authDataKey] = authData
else:
raise error.PySnmpError('Unsupported authentication object')
paramsKey = authData.securityName, \
authData.securityLevel, \
authData.mpModel
if paramsKey in self.__knownParams:
paramsName, useCount = self.__knownParams[paramsKey]
self.__knownParams[paramsKey] = paramsName, useCount + 1
else:
paramsName = 'p%s' % nextID()
config.addTargetParams(self.snmpEngine, paramsName,
authData.securityName,
authData.securityLevel, authData.mpModel)
self.__knownParams[paramsKey] = paramsName, 1
if transportTarget.transportDomain in self.__knownTransports:
transportTarget.verifyDispatcherCompatibility(self.snmpEngine)
transport, useCount = self.__knownTransports[
transportTarget.transportDomain]
self.__knownTransports[
transportTarget.transportDomain] = transport, useCount + 1
else:
transport = transportTarget.openClientMode()
config.addTransport(self.snmpEngine,
transportTarget.transportDomain, transport)
self.__knownTransports[
transportTarget.transportDomain] = transport, 1
transportKey = (paramsName, transportTarget.transportDomain,
transportTarget.transportAddr, transportTarget.tagList)
if transportKey in self.__knownTransportAddrs:
addrName, useCount = self.__knownTransportAddrs[transportKey]
self.__knownTransportAddrs[transportKey] = addrName, useCount + 1
else:
addrName = 'a%s' % nextID()
config.addTargetAddr(self.snmpEngine, addrName,
transportTarget.transportDomain,
transportTarget.transportAddr, paramsName,
transportTarget.timeout * 100,
transportTarget.retries,
transportTarget.tagList)
self.__knownTransportAddrs[transportKey] = addrName, 1
return addrName, paramsName
import datetime
import redis
import redis
redis_store = redis.Redis(host=str(yaml_config['redis']['host']),
port=str(yaml_config['redis']['port']),
db=0)
# Create SNMP engine
snmpEngine = engine.SnmpEngine()
# Transport setup
# UDP over IPv4
config.addTransport(
snmpEngine, udp.domainName,
udp.UdpTransport().openServerMode(
(str(yaml_config['snmp']['listen_address']),
int(yaml_config['snmp']['port']))))
# SNMPv3/USM setup
# user: usr-md5-none, auth: MD5, priv NONE
config.addV3User(snmpEngine, 'usr-md5-none', config.usmHMACMD5AuthProtocol,
'authkey1')
# Allow full MIB access for each user at VACM
config.addVacmUser(snmpEngine, 3, 'usr-md5-none', 'authNoPriv',
(1, 3, 6, 1, 2, 1), (1, 3, 6, 1, 2, 1))
# SNMPv2c setup
# SecurityName <-> CommunityName mapping.
from pysnmp.entity.rfc3413 import ntfrcv
snmpEngine = engine.SnmpEngine()
TrapAgentAddress = '0.0.0.0'
#Trap listerner address
Port = 162
#trap listerner port
print("Agent is listening SNMP Trap on " + TrapAgentAddress + " , Port : " +
str(Port))
print(
'--------------------------------------------------------------------------'
)
config.addTransport(
snmpEngine, udp.domainName + (1, ),
udp.UdpTransport().openServerMode((TrapAgentAddress, Port)))
#Configure community here
config.addV1System(snmpEngine, 'my-area', 'public')
def cbFun(snmpEngine, stateReference, contextEngineId, contextName, varBinds,
cbCtx):
print("Received new Trap message")
for name, val in varBinds:
print('%s = %s' % (name.prettyPrint(), val.prettyPrint()))
ntfrcv.NotificationReceiver(snmpEngine, cbFun)
"""#
from pysnmp.entity import engine, config
from pysnmp.entity.rfc3413 import cmdrsp, context
from pysnmp.carrier.asyncore.dgram import udp
from pysnmp.proto.api import v2c
# Create SNMP engine
snmpEngine = engine.SnmpEngine()
# Transport setup
# UDP over IPv4
config.addTransport(
snmpEngine,
udp.DOMAIN_NAME,
udp.UdpTransport().openServerMode(('127.0.0.1', 161))
)
# SNMPv2c setup
# SecurityName <-> CommunityName mapping.
config.addV1System(snmpEngine, 'my-area', 'public')
# Allow read MIB access for this user / securityModels at VACM
config.addVacmUser(snmpEngine, 2, 'my-area', 'noAuthNoPriv',
(1, 3, 6, 6), (1, 3, 6, 6))
# Create an SNMP context
snmpContext = context.SnmpContext(snmpEngine)
'/usr/local/share/snmp/mibs/'
])
mibViewController = view.MibViewController(mibBuilder)
# Pre-load MIB modules we expect to work with
try:
mibBuilder.loadModules('SNMPv2-MIB', 'SNMP-COMMUNITY-MIB',
'SYSLOG-MSG-MIB')
except Exception:
print("Failed loading MIBs")
# Create SNMP engine with autogenernated engineID and pre-bound to socket transport dispatcher
snmpEngine = engine.SnmpEngine()
# Transport setup
# UDP over IPv4, add listening interface/port
config.addTransport(snmpEngine, udp.domainName + (1, ),
udp.UdpTransport().openServerMode((snmpip, snmpport)))
# SNMPv1/2c setup
# SecurityName <-> CommunityName mapping
config.addV1System(snmpEngine, 'my-area', 'public')
print("Started SNMP Trap Receiver: %s, %s, Output: %s" %
(snmpport, snmpip, szOutputfile))
logFile.write("Started SNMP Trap Receiver: %s, %s, Output: %s" %
(snmpport, snmpip, szOutputfile))
logFile.flush()
# Callback function for receiving notifications
# noinspection PyUnusedLocal,PyUnusedLocal,PyUnusedLocal
def cbReceiverSnmp(snmpEngine, stateReference, contextEngineId, contextName,
transportDispatcher.registerRoutingCbFun(lambda td, t, d: td)
# Instantiate and configure SNMP Engines
for snmpEngineId, transportDomain, transportAddress in snmpEngineInfo:
# Create SNMP engine with specific engineID
snmpEngine = engine.SnmpEngine(rfc1902.OctetString(hexValue=snmpEngineId))
# Register SNMP Engine object with transport dispatcher. Request incoming
# data from specific transport endpoint to be funneled to this SNMP Engine.
snmpEngine.registerTransportDispatcher(transportDispatcher,
transportDomain)
# Transport setup
# UDP over IPv4
config.addTransport(snmpEngine, transportDomain,
udp.UdpTransport().openServerMode(transportAddress))
# SNMPv3/USM setup
# user: usr-md5-des, auth: MD5, priv DES
config.addV3User(snmpEngine, 'usr-md5-des', config.usmHMACMD5AuthProtocol,
'authkey1', config.usmDESPrivProtocol, 'privkey1')
# Allow full MIB access for this user / securityModels at VACM
config.addVacmUser(snmpEngine, 3, 'usr-md5-des', 'authPriv', (1, 3, 6),
(1, 3, 6, 1, 2, 1))
# Get default SNMP context this SNMP engine serves
snmpContext = context.SnmpContext(snmpEngine)
# Register SNMP Applications at the SNMP engine for particular SNMP context
# SecurityName <-> CommunityName mapping
config.addV1System(snmpEngine, 'my-area', 'public')
# Specify security settings per SecurityName (SNMPv1 - 0, SNMPv2c - 1)
config.addTargetParams(snmpEngine, 'my-creds', 'my-area', 'noAuthNoPriv', 0)
#
# Setup transport endpoint and bind it with security settings yielding
# a target name
#
# UDP/IPv4
config.addTransport(
snmpEngine,
udp.domainName,
udp.UdpSocketTransport().openClientMode(('0.0.0.0', 61024))
)
config.addTargetAddr(
snmpEngine, 'my-router',
udp.domainName, ('104.236.166.95', 161),
'my-creds'
)
# Error/response receiver
# noinspection PyUnusedLocal,PyUnusedLocal,PyUnusedLocal
def cbFun(snmpEngine, sendRequestHandle, errorIndication,
errorStatus, errorIndex, varBindTable, cbCtx):
if errorIndication:
print(errorIndication)
# SNMPv3/USM setup
#
# user: usr-sha-aes, auth: SHA, priv AES
config.addV3User(snmpEngine, 'usr-sha-aes', config.USM_AUTH_HMAC96_SHA,
'authkey1', config.USM_PRIV_CFB128_AES, 'privkey1')
config.addTargetParams(snmpEngine, 'my-creds', 'usr-sha-aes', 'authPriv')
#
# Setup transport endpoint and bind it with security settings yielding
# a target name
#
# UDP/IPv4
config.addTransport(snmpEngine, udp.DOMAIN_NAME,
udp.UdpSocketTransport().openClientMode())
config.addTargetAddr(snmpEngine, 'my-router', udp.DOMAIN_NAME,
('104.236.166.95', 161), 'my-creds')
# Error/response receiver
# noinspection PyUnusedLocal,PyUnusedLocal,PyUnusedLocal
def cbFun(snmpEngine, sendRequestHandle, errorIndication, errorStatus,
errorIndex, varBinds, cbCtx):
if errorIndication:
print(errorIndication)
elif errorStatus:
print('%s at %s' %
(errorStatus.prettyPrint(),
from pysnmp import error
# Create SNMP engine with autogenernated engineID and pre-bound
# to socket transport dispatcher
snmpEngine = engine.SnmpEngine()
#
# Transport setup
#
# Agent section
# UDP over IPv4
config.addTransport(
snmpEngine,
udp.DOMAIN_NAME + (1,),
udp.UdpTransport().openServerMode(('127.0.0.1', 161))
)
# Manager section
# UDP over IPv4
config.addTransport(
snmpEngine,
udp.DOMAIN_NAME + (2,),
udp.UdpTransport().openClientMode()
)
#
# SNMPv3/USM setup (Agent role)
#
| $ snmpwalk -v3 -u usr-md5-none -l authNoPriv -A authkey1 -E 8000000001020304 127.0.0.1 .1.3.6
"""#
from pysnmp.entity import engine, config
from pysnmp.entity.rfc3413 import cmdrsp, context
from pysnmp.carrier.asyncore.dgram import udp
from pysnmp.smi import instrum, builder
from pysnmp.proto.api import v2c
# Create SNMP engine
snmpEngine = engine.SnmpEngine()
# Transport setup
# UDP over IPv4
config.addTransport(snmpEngine, udp.domainName,
udp.UdpTransport().openServerMode(('127.0.0.1', 161)))
# SNMPv3/USM setup
# user: usr-md5-none, auth: MD5, priv NONE
config.addV3User(snmpEngine, 'usr-md5-none', config.usmHMACMD5AuthProtocol,
'authkey1')
# Allow full MIB access for each user at VACM
config.addVacmUser(snmpEngine, 3, 'usr-md5-none', 'authNoPriv',
(1, 3, 6, 1, 2, 1), (1, 3, 6, 1, 2, 1))
# Create an SNMP context with ContextEngineId = 8000000001020304
snmpContext = context.SnmpContext(
snmpEngine, contextEngineId=v2c.OctetString(hexValue='8000000001020304'))
def configure(self, snmpEngine, authData, transportTarget, contextName,
**options):
cache = self._getCache(snmpEngine)
if isinstance(authData, CommunityData):
if authData.communityIndex not in cache['auth']:
config.addV1System(snmpEngine, authData.communityIndex,
authData.communityName,
authData.contextEngineId,
authData.contextName, authData.tag,
authData.securityName)
cache['auth'][authData.communityIndex] = authData
elif isinstance(authData, UsmUserData):
authDataKey = authData.userName, authData.securityEngineId
if authDataKey not in cache['auth']:
config.addV3User(snmpEngine,
authData.userName,
authData.authProtocol,
authData.authKey,
authData.privProtocol,
authData.privKey,
securityEngineId=authData.securityEngineId,
securityName=authData.securityName,
authKeyType=authData.authKeyType,
privKeyType=authData.privKeyType)
cache['auth'][authDataKey] = authData
else:
raise error.PySnmpError('Unsupported authentication object')
paramsKey = (authData.securityName, authData.securityLevel,
authData.mpModel)
if paramsKey in cache['parm']:
paramsName, useCount = cache['parm'][paramsKey]
cache['parm'][paramsKey] = paramsName, useCount + 1
else:
paramsName = 'p%s' % self.nextID()
config.addTargetParams(snmpEngine, paramsName,
authData.securityName,
authData.securityLevel, authData.mpModel)
cache['parm'][paramsKey] = paramsName, 1
if transportTarget.TRANSPORT_DOMAIN in cache['tran']:
transport, useCount = cache['tran'][
transportTarget.TRANSPORT_DOMAIN]
transportTarget.verifyDispatcherCompatibility(snmpEngine)
cache['tran'][
transportTarget.TRANSPORT_DOMAIN] = transport, useCount + 1
elif config.getTransport(snmpEngine, transportTarget.TRANSPORT_DOMAIN):
transportTarget.verifyDispatcherCompatibility(snmpEngine)
else:
transport = transportTarget.openClientMode()
config.addTransport(snmpEngine, transportTarget.TRANSPORT_DOMAIN,
transport)
cache['tran'][transportTarget.TRANSPORT_DOMAIN] = transport, 1
transportKey = (paramsName, transportTarget.TRANSPORT_DOMAIN,
transportTarget.transportAddr, transportTarget.timeout,
transportTarget.retries, transportTarget.tagList,
transportTarget.iface)
if transportKey in cache['addr']:
addrName, useCount = cache['addr'][transportKey]
cache['addr'][transportKey] = addrName, useCount + 1
else:
addrName = 'a%s' % self.nextID()
config.addTargetAddr(snmpEngine, addrName,
transportTarget.TRANSPORT_DOMAIN,
transportTarget.transportAddr, paramsName,
transportTarget.timeout * 100,
transportTarget.retries,
transportTarget.tagList)
cache['addr'][transportKey] = addrName, 1
return addrName, paramsName
