Python config.addV3User函数代码示例

 def _add_v3_md5_des_user(self, user):
     """
     Setup v3 user with md5, des
     """
     config.addV3User(self.snmpEngine, user[0],
                      config.usmHMACMD5AuthProtocol, user[1],
                      config.usmDESPrivProtocol, user[2])

    def __init__(self, client_config=None):
        if not client_config:
            client_config = conpot_config
        # Create SNMP engine instance
        self.snmpEngine = engine.SnmpEngine()

        # user: usr-sha-aes, auth: SHA, priv AES
        config.addV3User(
            self.snmpEngine, 'usr-sha-aes128',
            config.usmHMACSHAAuthProtocol, 'authkey1',
            config.usmAesCfb128Protocol, 'privkey1'
        )
        config.addTargetParams(self.snmpEngine, 'my-creds', 'usr-sha-aes128', 'authPriv')

        # Setup transport endpoint and bind it with security settings yielding
        # a target name (choose one entry depending of the transport needed).

        # UDP/IPv4
        config.addSocketTransport(
            self.snmpEngine,
            udp.domainName,
            udp.UdpSocketTransport().openClientMode()
        )
        config.addTargetAddr(
            self.snmpEngine, 'my-router',
            udp.domainName, (client_config.snmp_host, client_config.snmp_port),
            'my-creds'
        )

    def __init__(self, objects):

        self._snmpEngine = engine.SnmpEngine()

        config.addSocketTransport( self._snmpEngine, udp.domainName, udp.UdpTransport().openServerMode((_addr, _port)))
        config.addV3User(self._snmpEngine,_account,config.usmHMACMD5AuthProtocol,_auth_key,config.usmDESPrivProtocol,_priv_key)
        config.addVacmUser(self._snmpEngine, 3, _account, "authPriv",(1,3,6,1,4,1), (1,3,6,1,4,1))

        self._snmpContext = context.SnmpContext(self._snmpEngine)


        #builder create
        mibBuilder = self._snmpContext.getMibInstrum().getMibBuilder()
        mibSources = mibBuilder.getMibSources() + (builder.DirMibSource('.'),)+(builder.DirMibSource(filepath),)
        mibBuilder.setMibSources(*mibSources)


        MibScalarInstance, = mibBuilder.importSymbols('SNMPv2-SMI','MibScalarInstance')

        for mibObject in objects:
            nextVar, = mibBuilder.importSymbols(mibObject.mibName,
                                                mibObject.objectType)
            instance = createVariable(MibScalarInstance, mibObject.valueGetFunc, nextVar.name, (0,),  nextVar.syntax)
            #need to export as <var name>Instance
            instanceDict = {str(nextVar.name)+"Instance":instance}
            mibBuilder.exportSymbols(mibObject.mibName, **instanceDict)

        cmdrsp.GetCommandResponder(self._snmpEngine, self._snmpContext)
        cmdrsp.SetCommandResponder(self._snmpEngine, self._snmpContext)
        cmdrsp.NextCommandResponder(self._snmpEngine, self._snmpContext)
        cmdrsp.BulkCommandResponder(self._snmpEngine, self._snmpContext)

    def __init__(self, udpIp, udpPort):
        # Create SNMP engine with autogenernated engineID and pre-bound
        # to socket transport dispatcher
        self.snmpEngine = engine.SnmpEngine()
        self.mibBuilder = self.snmpEngine.msgAndPduDsp.mibInstrumController.mibBuilder

        mibPath = self.mibBuilder.getMibPath() + ('.',)
        self.mibBuilder.setMibPath(*mibPath)

        # Setup UDP over IPv4 transport endpoint
        config.addSocketTransport(
            self.snmpEngine,
            udp.domainName,
            udp.UdpSocketTransport().openServerMode((udpIp, udpPort))
        )

        print 'Publishing readings via SNMP'
        print 'Agent address {}:{}'.format(udpIp, udpPort)
        print 'Community name public'

        # v1/2 setup
        config.addV1System(self.snmpEngine, 'test-agent', 'public')

        # v3 setup
        config.addV3User(
            self.snmpEngine, 'test-user'
        )

        # VACM setup
        config.addContext(self.snmpEngine, '')
        config.addRwUser(self.snmpEngine, 1, 'test-agent', 'noAuthNoPriv', (1,3,6)) # v1
        config.addRwUser(self.snmpEngine, 2, 'test-agent', 'noAuthNoPriv', (1,3,6)) # v2c
        config.addRwUser(self.snmpEngine, 3, 'test-user', 'noAuthNoPriv', (1,3,6)) # v3

        # SNMP context
        snmpContext = context.SnmpContext(self.snmpEngine)

        # Apps registration
        cmdrsp.GetCommandResponder(self.snmpEngine, snmpContext)
        cmdrsp.SetCommandResponder(self.snmpEngine, snmpContext)
        cmdrsp.NextCommandResponder(self.snmpEngine, snmpContext)
        cmdrsp.BulkCommandResponder(self.snmpEngine, snmpContext)

        MibScalarInstance, = self.mibBuilder.importSymbols('SNMPv2-SMI', 'MibScalarInstance')

        class ScalarFromCallback(MibScalarInstance):
            def __init__(self, sensorId, valueGetter, typeName, instId, syntax):
                MibScalarInstance.__init__(self, typeName, instId, syntax)
                self.valueGetter = valueGetter

            def readTest(self, name, val, idx, (acFun, acCtx)):
                if not self.valueGetter():
                    raise error.NoAccessError(idx=idx, name=name)

            def readGet(self, name, val, idx, (acFun, acCtx)):
                value = self.valueGetter()
                if not value:
                    raise error.NoAccessError(idx=idx, name=name)
                else:
                    return name, self.syntax.clone(value)

     def run(self):
         
        snmpEngine = engine.SnmpEngine()
        
        if self.ipv6:
            domainName = udp6.domainName
            config.addSocketTransport(snmpEngine,domainName,udp6.Udp6Transport().openServerMode((self.host, self.port)))
        else:
            domainName = udp.domainName
            config.addSocketTransport(snmpEngine,domainName,udp.UdpTransport().openServerMode((self.host, self.port))) 
            
        config.addV3User(snmpEngine, self.user,self.auth_proto, self.auth_key,self.priv_proto,self.priv_key)
  
        # Register SNMP Application at the SNMP engine
        ntfrcv.NotificationReceiver(snmpEngine, v3trapCallback)

        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: # catch *all* exceptions
            e = sys.exc_info()[1]
            snmpEngine.transportDispatcher.closeDispatcher()
            logging.error("Looks like an error: %s" % str(e))
            sys.exit(1)

 def addV3User(self, securityName,
               authProtocol=config.usmNoAuthProtocol, authKey=None,
               privProtocol=config.usmNoPrivProtocol, privKey=None,
               contextEngineId=None):
     config.addV3User(self.snmpEngine, securityName,
                      authProtocol, authKey, privProtocol, privKey,
                      contextEngineId)
     return

    def cfgCmdGen(self, authData, transportTarget, tagList=''):
        if self.__knownAuths.has_key(authData):
            paramsName = self.__knownAuths[authData]
        else:
            paramsName = 'p%s' % nextID()
            if isinstance(authData, CommunityData):
                config.addV1System(
                    self.snmpEngine,
                    authData.securityName,
                    authData.communityName
                    )
                config.addTargetParams(
                    self.snmpEngine, paramsName,
                    authData.securityName, authData.securityLevel,
                    authData.mpModel
                    )
            elif isinstance(authData, UsmUserData):
                config.addV3User(
                    self.snmpEngine,
                    authData.securityName,
                    authData.authProtocol, authData.authKey,
                    authData.privProtocol, authData.privKey
                    )
                config.addTargetParams(
                    self.snmpEngine, paramsName,
                    authData.securityName, authData.securityLevel
                    )
            else:
                raise error.PySnmpError('Unsupported SNMP version')
            self.__knownAuths[authData] = paramsName

        if not self.__knownTransports.has_key(transportTarget.transportDomain):
            transport = transportTarget.openClientMode()
            config.addSocketTransport(
                self.snmpEngine,
                transportTarget.transportDomain,
                transport
                )
            self.__knownTransports[transportTarget.transportDomain] = transport

        k = transportTarget, tagList
        if self.__knownTransportAddrs.has_key(k):
            addrName = self.__knownTransportAddrs[k]
        else:
            addrName = 'a%s' % nextID()
            config.addTargetAddr(
                self.snmpEngine, addrName,
                transportTarget.transportDomain,
                transportTarget.transportAddr,
                paramsName,
                transportTarget.timeout * 100,
                transportTarget.retries,
                tagList                
                )
            self.__knownTransportAddrs[k] = addrName

        return addrName, paramsName

 def __init__(self, host, port, rcommunity):
     self.snmpEngine = engine.SnmpEngine()
     config.addSocketTransport(self.snmpEngine, udp.domainName, udp.UdpTransport().openServerMode((host, port)))
     config.addV1System(self.snmpEngine, 'my-area', rcommunity)
     config.addVacmUser(self.snmpEngine, 2, 'my-area', 'noAuthNoPriv', (1, 3, 6))
     config.addV3User(self.snmpEngine, 'test')
     config.addVacmUser(self.snmpEngine, 3, 'test', 'noAuthNoPriv', (1, 3, 6))
     self.snmpContext = context.SnmpContext(self.snmpEngine)
     self.mibBuilder = self.snmpContext.getMibInstrum().getMibBuilder()
     self.MibScalar, self.MibScalarInstance = self.mibBuilder.importSymbols('SNMPv2-SMI', 'MibScalar', 'MibScalarInstance')
     cmdrsp.GetCommandResponder(self.snmpEngine, self.snmpContext)
     cmdrsp.NextCommandResponder(self.snmpEngine, self.snmpContext)
     cmdrsp.BulkCommandResponder(self.snmpEngine, self.snmpContext)

    def _configureUsers(self, snmpEngine, snmpContext, params):
        logger.debug ( 'Configure users' );
        for user in params.users:
            logger.debug ( 'Creating user "%s"', user.name );

            # Parse authentication algorithm
            authAlgo = config.usmNoAuthProtocol;
            if user.authAlgo is not None:
                if not user.authAlgo in self.authAlgorithms:
                    msg = 'Invalid snmp V3 Authentification algorithm %s. Valid values are: %s' % (user.authAlgo, self.authAlgorithms.keys())
                    logger.error ( msg );
                    raise ClusterException(msg);
                else:
                    authAlgo = self.authAlgorithms[user.authAlgo.lower()];

            # Parse privacy algorithm
            privAlgo = config.usmNoPrivProtocol;
            if user.privAlgo is not None:
                if not user.privAlgo in self.privAlgorithms:
                    msg = 'Invalid snmp V3 Privacy algorithm %s. Valid values are: %s' % (user.privAlgo, self.privAlgorithms.keys())
                    logger.error ( msg );
                    raise ClusterException(msg);
                else:
                    privAlgo = self.privAlgorithms[user.privAlgo.lower()];

            # Check provided parameters
            if authAlgo==config.usmNoAuthProtocol and privAlgo!=config.usmNoPrivProtocol:
                msg = 'Privacy impossible without authentication for user: %s' % (user.name)
                logger.error ( msg );
                raise ClusterException(msg);

            if authAlgo!=config.usmNoAuthProtocol and user.authPass is None:
                msg = 'No authentication password given for user %s' % (user.name)
                logger.error ( msg );
                raise ClusterException(msg);

            if privAlgo!=config.usmNoPrivProtocol and user.privPass is None:
                msg = 'No privacy password given for user %s' % (user.name)
                logger.error ( msg );
                raise ClusterException(msg);

            # At least we can create the user
            config.addV3User( snmpEngine, user.name,
                authAlgo, user.authPass,
                privAlgo, user.privPass
            )
            pass;

        pass;

	def v3TargetName( 
		self, engine,
		ip, port=161, 
		authKey=None,
		privKey=None,
		authProtocol='MD5',
		privProtocol='DES',
	):
		"""Find/create target name for v1/v2 connection to given agent
		
		authProtocol -- one of None, 'MD5' or 'SHA' determining the hashing
			of the authorisation key (password)
		privProtocol -- one of None or 'DES', determining encryption of the
			messages sent to the agent 
		authKey -- authorisation key (password) for the agent 
		privKey -- key used to obscure requests from eavesdroppers
		"""
		if authKey is None:
			authProtocol = None 
		if privKey is None:
			privProtocol = None 
		authProtocol = self.AUTH_PROTOCOL_REGISTRY[ authProtocol ]
		privProtocol = self.PRIV_PROTOCOL_REGISTRY[ privProtocol ]
		key = ( authProtocol, authKey, privProtocol, privKey )
		paramName = self._v3paramCache.get( key )
		if paramName is None:
			nameID = self._newV3Name()
			name = 'v3user-%s'%(nameID)
			config.addV3User(
				engine, name, 
				authProtocol=authProtocol, authKey=authKey,
				privProtocol=privProtocol, privKey=privKey
			)
			if authProtocol is config.usmNoAuthProtocol:
				paramType = "noAuthNoPriv"
			elif privProtocol is config.usmNoPrivProtocol:
				paramType = "authNoPriv"
			else:
				paramType = "authPriv"
			paramName = 'v3param-%s'%(nameID)
			config.addTargetParams(
				engine, paramName, name, paramType,
				mpModel = 3
			)
			self._v3paramCache[ key ] = paramName
		return self._targetName( engine, ip, port, paramName )

 def __init__(self):
     self.snmpEngine = engine.SnmpEngine()
     
     config.addSocketTransport(
         self.snmpEngine,
         udp.domainName,
         udp.UdpSocketTransport().openServerMode(('0.0.0.0', 162))
         )
         
     config.addV1System(self.snmpEngine, 'test-agent', 'public')
     
     config.addV3User(
         self.snmpEngine, 'test-user',
         config.usmHMACMD5AuthProtocol, 'authkey1',
         config.usmDESPrivProtocol, 'privkey1'
         #    '80004fb81c3dafe69'   # ContextEngineID of Notification Originator
         )
     # Apps registration
     ntfrcv.NotificationReceiver(self.snmpEngine, self.recvcallback)
     self.snmpEngine.transportDispatcher.jobStarted(1) # this job would never finish
     self.snmpEngine.transportDispatcher.runDispatcher()

    def __init__(self, host, port, username, password, snmp_context):
        self.snmp_context = snmp_context

        self.snmp_engine = engine.SnmpEngine()
        # HiT7300 uses the user password for encryption (privacy protocol) pass phrase (PSK?)
        config.addV3User(
            self.snmp_engine, username, config.usmHMACMD5AuthProtocol, password, config.usmAesCfb128Protocol, password
        )

        # pysnmp bug?
        # setting context doesn't affect the getCommandGenerator, so we don't set it
        # FIXME: report upstream and have cmdgen use context of snmpEngine!?
        # config.addContext(self.snmp_engine, 'tnms')
        # snmp_context = context.SnmpContext(self.snmp_engine)

        config.addTargetParams(self.snmp_engine, "myParams", username, "authPriv")
        # config.addTargetParams(self.snmp_engine, 'myParams', username, 'authPriv')

        config.addTargetAddr(self.snmp_engine, "myTarget", config.snmpUDPDomain, (host, int(port)), "myParams")

        config.addSocketTransport(self.snmp_engine, udp.domainName, udp.UdpSocketTransport().openClientMode())

        self.cbCtx = {}

    def __init__(self, host, port, log_queue):
        self.log_queue = log_queue
        # Create SNMP engine
        self.snmpEngine = engine.SnmpEngine()
        # Transport setup

        udp_sock = gevent.socket.socket(gevent.socket.AF_INET, gevent.socket.SOCK_DGRAM)
        udp_sock.setsockopt(gevent.socket.SOL_SOCKET, gevent.socket.SO_BROADCAST, 1)
        udp_sock.bind((host, port))
        # UDP over IPv4
        self.addSocketTransport(
            self.snmpEngine,
            udp.domainName,
            udp_sock
        )

        #SNMPv1
        config.addV1System(self.snmpEngine, 'public-read', 'public')

        # SNMPv3/USM setup
        # user: usr-md5-des, auth: MD5, priv DES
        config.addV3User(
            self.snmpEngine, 'usr-md5-des',
            config.usmHMACMD5AuthProtocol, 'authkey1',
            config.usmDESPrivProtocol, 'privkey1'
        )
        # user: usr-sha-none, auth: SHA, priv NONE
        config.addV3User(
            self.snmpEngine, 'usr-sha-none',
            config.usmHMACSHAAuthProtocol, 'authkey1'
        )
        # user: usr-sha-aes128, auth: SHA, priv AES/128
        config.addV3User(
            self.snmpEngine, 'usr-sha-aes128',
            config.usmHMACSHAAuthProtocol, 'authkey1',
            config.usmAesCfb128Protocol, 'privkey1'
        )

        # Allow full MIB access for each user at VACM
        config.addVacmUser(self.snmpEngine, 1, 'public-read', 'noAuthNoPriv',
                           (1, 3, 6, 1, 2, 1))
        config.addVacmUser(self.snmpEngine, 3, 'usr-md5-des', 'authPriv',
                           (1, 3, 6, 1, 2, 1), (1, 3, 6, 1, 2, 1))
        config.addVacmUser(self.snmpEngine, 3, 'usr-sha-none', 'authNoPriv',
                           (1, 3, 6, 1, 2, 1), (1, 3, 6, 1, 2, 1))
        config.addVacmUser(self.snmpEngine, 3, 'usr-sha-aes128', 'authPriv',
                           (1, 3, 6, 1, 2, 1), (1, 3, 6, 1, 2, 1))

        # Get default SNMP context this SNMP engine serves
        snmpContext = context.SnmpContext(self.snmpEngine)

        # Register SNMP Applications at the SNMP engine for particular SNMP context
        cmdrsp.GetCommandResponder(self.snmpEngine, snmpContext)
        cmdrsp.SetCommandResponder(self.snmpEngine, snmpContext)
        cmdrsp.NextCommandResponder(self.snmpEngine, snmpContext)
        cmdrsp.BulkCommandResponder(self.snmpEngine, snmpContext)

    # 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
    cmdrsp.GetCommandResponder(snmpEngine, snmpContext)
    cmdrsp.SetCommandResponder(snmpEngine, snmpContext)
    cmdrsp.NextCommandResponder(snmpEngine, snmpContext)
    cmdrsp.BulkCommandResponder(snmpEngine, snmpContext)

"""#
from pysnmp.entity import engine, config
from pysnmp.carrier.asyncore.dgram import udp
from pysnmp.entity.rfc3413 import cmdgen

# Create SNMP engine instance
snmpEngine = engine.SnmpEngine()

#
# SNMPv3/USM setup
#

# user: usr-sha-aes, auth: SHA, priv AES
config.addV3User(
    snmpEngine, 'usr-sha-aes',
    config.usmHMACSHAAuthProtocol, 'authkey1',
    config.usmAesCfb128Protocol, '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.domainName,
    udp.UdpSocketTransport().openClientMode()
)