RFC 2261
An Architecture for Describing SNMP Management Frameworks
RFC 2261 🎀 An Architecture for Describing SNMP Management Frameworks
Okay bestie, here's the header tea ☕ This doc was put together by three people:
- D. Harrington, from Cabletron Systems, Inc. 💅
- R. Presuhn, from BMC Software, Inc. 🦋
- B. Wijnen, from IBM T. J. Watson Research 🧚
It's a Standards Track document, dated January 1998. The title block doesn't list anything it obsoletes or updates, so there's no drama there 🙈
Status of this Memo ✨
Okay so this bit is the official disclaimer, and it's lowkey important. It says this is an Internet standards track protocol for the Internet community, and the authors are asking for discussion and suggestions for improvements 💌 For the current standardization state and status, you check the "Internet Official Protocol Standards" (STD 1) list 📋 And distribution of this memo is unlimited, so it's all open, no cap 🌈
Copyright Notice 🔒
Copyright (C) The Internet Society (1997). All Rights Reserved. 💜
Abstract 🫧
So the main point here: this doc describes an architecture for describing SNMP Management Frameworks ✨ It's built to be modular, which is so smart, because it lets the SNMP protocol standards evolve over time without everything breaking 🔥
The big pieces are an SNMP engine, which contains a Message Processing Subsystem, a Security Subsystem, and an Access Control Subsystem 👑 On top of that there can be multiple SNMP applications, and each one does its own specific processing of management data 💅
Table of Contents 📖
1. Introduction ................................................ 3
1.1. Overview .................................................. 3
1.2. SNMP ...................................................... 4
1.3. Goals of this Architecture ................................ 5
1.4. Security Requirements of this Architecture ................ 6
1.5. Design Decisions .......................................... 7
2. Documentation Overview ...................................... 8
2.1. Document Roadmap .......................................... 10
2.2. Applicability Statement ................................... 10
2.3. Coexistence and Transition ................................ 10
2.4. Transport Mappings ........................................ 11
2.5. Message Processing ........................................ 11
2.6. Security .................................................. 11
2.7. Access Control ............................................ 11
2.8. Protocol Operations ....................................... 12
2.9. Applications .............................................. 12
2.10. Structure of Management Information ...................... 12
2.11. Textual Conventions ...................................... 13
2.12. Conformance Statements ................................... 13
2.13. Management Information Base Modules ...................... 13
2.13.1. SNMP Instrumentation MIBs .............................. 13
2.14. SNMP Framework Documents ................................. 13
3. Elements of the Architecture ................................ 14
3.1. The Naming of Entities .................................... 14
3.1.1. SNMP engine ............................................. 15
3.1.1.1. snmpEngineID .......................................... 16
3.1.1.2. Dispatcher ............................................ 16
3.1.1.3. Message Processing Subsystem .......................... 16
3.1.1.3.1. Message Processing Model ............................ 17
3.1.1.4. Security Subsystem .................................... 17
3.1.1.4.1. Security Model ...................................... 17
3.1.1.4.2. Security Protocol ................................... 18
3.1.2. Access Control Subsystem ................................ 18
3.1.2.1. Access Control Model .................................. 18
3.1.3. Applications ............................................ 18
3.1.3.1. SNMP Manager .......................................... 19
3.1.3.2. SNMP Agent ............................................ 20
3.2. The Naming of Identities .................................. 21
3.2.1. Principal ............................................... 21
3.2.2. securityName ............................................ 21
3.2.3. Model-dependent security ID ............................. 22
3.3. The Naming of Management Information ...................... 22
3.3.1. An SNMP Context ......................................... 23
3.3.2. contextEngineID ......................................... 24
3.3.3. contextName ............................................. 24
3.3.4. scopedPDU ............................................... 25
3.4. Other Constructs .......................................... 25
3.4.1. maxSizeResponseScopedPDU ................................ 25
3.4.2. Local Configuration Datastore ........................... 25
3.4.3. securityLevel ........................................... 25
4. Abstract Service Interfaces ................................. 26
4.1. Dispatcher Primitives ..................................... 26
4.1.1. Generate Outgoing Request or Notification ............... 26
4.1.2. Process Incoming Request or Notification PDU ............ 26
4.1.3. Generate Outgoing Response .............................. 27
4.1.4. Process Incoming Response PDU ........................... 27
4.1.5. Registering Responsibility for Handling SNMP PDUs ....... 28
4.2. Message Processing Subsystem Primitives ................... 28
4.2.1. Prepare Outgoing SNMP Request or Notification Message ... 28
4.2.2. Prepare an Outgoing SNMP Response Message ............... 29
4.2.3. Prepare Data Elements from an Incoming SNMP Message ..... 29
4.3. Access Control Subsystem Primitives ....................... 30
4.4. Security Subsystem Primitives ............................. 30
4.4.1. Generate a Request or Notification Message .............. 30
4.4.2. Process Incoming Message ................................ 31
4.4.3. Generate a Response Message ............................. 31
4.5. Common Primitives ......................................... 32
4.5.1. Release State Reference Information ..................... 32
4.6. Scenario Diagrams ......................................... 32
4.6.1. Command Generator or Notification Originator ............ 32
4.6.2. Scenario Diagram for a Command Responder Application .... 33
5. Managed Object Definitions for SNMP Management Frameworks ... 35
6. Intellectual Property ....................................... 44
7. Acknowledgements ............................................ 45
8. Security Considerations ..................................... 46
9. References .................................................. 46
10. Editors' Addresses ......................................... 48
A. Guidelines for Model Designers .............................. 49
A.1. Security Model Design Requirements ........................ 49
A.1.1. Threats ................................................. 49
A.1.2. Security Processing ..................................... 50
A.1.3. Validate the security-stamp in a received message ....... 51
A.1.4. Security MIBs ........................................... 51
A.1.5. Cached Security Data .................................... 51
A.2. Message Processing Model Design Requirements .............. 52
A.2.1. Receiving an SNMP Message from the Network .............. 52
A.2.2. Sending an SNMP Message to the Network .................. 52
A.3. Application Design Requirements ........................... 53
A.3.1. Applications that Initiate Messages ..................... 53
A.3.2. Applications that Receive Responses ..................... 54
A.3.3. Applications that Receive Asynchronous Messages ......... 54
A.3.4. Applications that Send Responses ........................ 54
A.4. Access Control Model Design Requirements .................. 55
B. Full Copyright Statement .................................... 561. Introduction ✨
1.1. Overview
Okay so section 1.1 is the vibe check 💖 This doc defines a vocabulary for describing SNMP Management Frameworks, and it sets up an architecture for describing the major portions of those frameworks 🧚
It's not a beginner's guide to SNMP, so if you need a warm-up, other documents and books do that way better 📚 It also doesn't tell the history of SNMP. That's covered elsewhere too, so no history lesson here 🙈
Section 1 is where the purpose, goals, and design decisions of the architecture live 🎯
Section 2 covers the different kinds of documents that define SNMP Frameworks and how they slot into this architecture 🗺️ It also gives a minimal roadmap to the documents that already defined SNMP frameworks, which is so helpful 🌸
Section 3 is the vocabulary bestie. It's the big one for understanding the rest of the doc, and for understanding any document written to fit this architecture 🤓🔥
Section 4 describes the primitives for the abstract service interfaces between the various subsystems, models, and applications in this architecture 💅
Section 5 defines a collection of managed objects that are used to instrument SNMP entities here 🦋
Sections 6, 7, 8, and 9 are administrative in nature. Not the most exciting, but you still need them 😭
Appendix A has guidelines for designers of Models that are expected to fit within this architecture 🫶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in [RFC2119]. 🌈
1.2. SNMP ✨
okay so an SNMP management system is basically a little crew of pieces, and each one has a job 💅
- several (potentially many) nodes, each with an SNMP entity containing command responder and notification originator applications, which have access to management instrumentation (traditionally called agents) 🌸
- at least one SNMP entity containing command generator and/or notification receiver applications (traditionally called a manager) and 👑
- a management protocol, used to convey management information between the SNMP entities 🦋
so the SNMP entities running command generator and notification receiver applications are the ones doing the monitoring and controlling 🫶 and the things they manage are called managed elements. these are devices like hosts, routers, terminal servers, etc., and you watch and steer them by getting access to their management information. it's giving remote control, bestie 🎀
the whole point of this document is to define an architecture that can grow and still do effective management across a bunch of different setups and environments 🌈 it was designed to fit lots of kinds of implementations:
- minimal SNMP entities with command responder and/or notification originator applications (traditionally called SNMP agents) 🍓
- SNMP entities with proxy forwarder applications (traditionally called SNMP proxy agents) 🧚
- command line driven SNMP entities with command generator and/or notification receiver applications (traditionally called SNMP command line managers) 💜
- SNMP entities with command generator and/or notification receiver, plus command responder and/or notification originator applications (traditionally called SNMP mid-level managers or dual-role entities) ✨
- SNMP entities with command generator and/or notification receiver and possibly other types of applications for managing a potentially very large number of managed nodes (traditionally called (network) management stations) 👑
1.3. Goals of this Architecture 🎀
this architecture was driven by these goals, and honestly they're iconic 😭
- Use existing materials as much as possible. It is heavily based on previous work, informally known as SNMPv2u and SNMPv2*. 🦋
- Address the need for secure SET support, which is considered the most important deficiency in SNMPv1 and SNMPv2c. 🔥
- Make it possible to move portions of the architecture forward in the standards track, even if consensus has not been reached on all pieces. 🌸
- Define an architecture that allows for longevity of the SNMP Frameworks that have been and will be defined. 💖
- Keep SNMP as simple as possible. 🫶
- Make it relatively inexpensive to deploy a minimal conforming implementation. 💅
- Make it possible to upgrade portions of SNMP as new approaches become available, without disrupting an entire SNMP framework. 🌈
- Make it possible to support features required in large networks, but make the expense of supporting a feature directly related to the support of the feature. 👑
1.4. Security Requirements of this Architecture 💀
okay this section is serious, bestie, because security is literally the main character here 🙈 several of the classic threats to network protocols apply to the management problem, so they'd apply to any Security Model used in an SNMP Management Framework. other threats don't apply to management at all. this section covers principal threats, secondary threats, and threats that matter less.
the principal threats that any Security Model in this architecture SHOULD protect against are:
Modification of Information 🔥 The modification threat is the danger that some unauthorized SNMP entity may alter in-transit SNMP messages generated on behalf of an authorized principal in such a way as to effect unauthorized management operations, including falsifying the value of an object.
Masquerade 🎭 The masquerade threat is the danger that management operations not authorized for some principal may be attempted by assuming the identity of another principal that has the appropriate authorizations.
Message Stream Modification 🌀 The SNMP protocol is typically based upon a connectionless transport service which may operate over any subnetwork service. The re-ordering, delay or replay of messages can and does occur through the natural operation of many such subnetwork services. The message stream modification threat is the danger that messages may be maliciously re-ordered, delayed or replayed to an extent which is greater than can occur through the natural operation of a subnetwork service, in order to effect unauthorized management operations.
Disclosure 👀 The disclosure threat is the danger of eavesdropping on the exchanges between SNMP engines. Protecting against this threat may be required as a matter of local policy.
there are at least two threats that a Security Model within this architecture does NOT need to protect against 💅
Denial of Service 🙅 A Security Model need not attempt to address the broad range of attacks by which service on behalf of authorized users is denied. Indeed, such denial-of-service attacks are in many cases indistinguishable from the type of network failures with which any viable management protocol must cope as a matter of course.
Traffic Analysis 🧠 A Security Model need not attempt to address traffic analysis attacks. Many traffic patterns are predictable - entities may be managed on a regular basis by a relatively small number of management stations - and therefore there is no significant advantage afforded by protecting against traffic analysis.
1.5. Design Decisions 🧚
there were various design decisions made to support the goals of the architecture and the security requirements, and these are the big ones:
- Architecture 🏗️ An architecture should be defined which identifies the conceptual boundaries between the documents. Subsystems should be defined which describe the abstract services provided by specific portions of an SNMP framework. Abstract service interfaces, as described by service primitives, define the abstract boundaries between documents, and the abstract services that are provided by the conceptual subsystems of an SNMP framework.
- Self-contained Documents 📦 Elements of procedure plus the MIB objects which are needed for processing for a specific portion of an SNMP framework should be defined in the same document, and as much as possible, should not be referenced in other documents. This allows pieces to be designed and documented as independent and self-contained parts, which is consistent with the general SNMP MIB module approach. As portions of SNMP change over time, the documents describing other portions of SNMP are not directly impacted. This modularity allows, for example, Security Models, authentication and privacy mechanisms, and message formats to be upgraded and supplemented as the need arises. The self-contained documents can move along the standards track on different time-lines.
- Threats 🛡️ The Security Models in the Security Subsystem SHOULD protect against the principal threats: modification of information, masquerade, message stream modification and disclosure. They do not need to protect against denial of service and traffic analysis.
- Remote Configuration 🌐 The Security and Access Control Subsystems add a whole new set of SNMP configuration parameters. The Security Subsystem also requires frequent changes of secrets at the various SNMP entities. To make this deployable in a large operational environment, these SNMP parameters must be able to be remotely configured.
- Controlled Complexity ⚖️ It is recognized that producers of simple managed devices want to keep the resources used by SNMP to a minimum. At the same time, there is a need for more complex configurations which can spend more resources for SNMP and thus provide more functionality. The design tries to keep the competing requirements of these two environments in balance and allows the more complex environments to logically extend the simple environment. 💖
2. Documentation Overview ✨
okay so bestie, this is the map of the whole SNMP document universe 🗺️🦋 the diagram below shows every doc that fits into the SNMP Architecture, and yes it's a lot, but it's giving organized 💅
+------------------------- Document Set ----------------------------+
| |
| +------------+ +-----------------+ +----------------+ |
| | Document * | | Applicability * | | Coexistence * | |
| | Roadmap | | Statement | | & Transition | |
| +------------+ +-----------------+ +----------------+ |
| |
| +---------------------------------------------------------------+ |
| | Message Handling | |
| | +----------------+ +-----------------+ +-----------------+ | |
| | | Transport | | Message | | Security | | |
| | | Mappings | | Processing and | | | | |
| | | | | Dispatcher | | | | |
| | +----------------+ +-----------------+ +-----------------+ | |
| +---------------------------------------------------------------+ |
| |
| +---------------------------------------------------------------+ |
| | PDU Handling | |
| | +----------------+ +-----------------+ +-----------------+ | |
| | | Protocol | | Applications | | Access | | |
| | | Operations | | | | Control | | |
| | +----------------+ +-----------------+ +-----------------+ | |
| +---------------------------------------------------------------+ |
| |
| +---------------------------------------------------------------+ |
| | Information Model | |
| | +--------------+ +--------------+ +---------------+ | |
| | | Structure of | | Textual | | Conformance | | |
| | | Management | | Conventions | | Statements | | |
| | | Information | | | | | | |
| | +--------------+ +--------------+ +---------------+ | |
| +---------------------------------------------------------------+ |
| |
| +---------------------------------------------------------------+ |
| | MIBs | |
| | +-------------+ +-------------+ +----------+ +----------+ | |
| | | Standard v1 | | Standard v1 | | Historic | | Draft v2 | | |
| | | RFC1157 | | RFC1212 | | RFC14XX | | RFC19XX | | |
| | | format | | format | | format | | format | | |
| | +-------------+ +-------------+ +----------+ +----------+ | |
| +---------------------------------------------------------------+ |
| |
+-------------------------------------------------------------------+ngl the * ones are the vibes-in-progress, they're expected to be written in the future 🔮 and every doc on this board might get replaced or supplemented later, so nothing is set in stone 🫶 this Architecture doc is specifically about how new docs slot into the Message and PDU handling crew 🎀
Note: RFC14XX means RFCs 1442, 1443, and 1444. RFC19XX means RFCs 1902, 1903, and 1904.
2.1. Document Roadmap 🗺️
one or more docs might get written to explain how sets of documents come together to form specific Frameworks 🧩 the configuration of document sets can change over time, so the "road map" should live in its own doc, separate from the standards docs themselves 💜
2.2. Applicability Statement 🏢
SNMP runs on networks of all sizes and complexity, and it's used by organizations with wildly different management needs 🌈 some models are designed to tackle specific problems, like message security 🔐
one or more docs may be written to describe the environments where certain SNMP versions or models would be appropriately applied 🎯 and the environments where a given model might be inappropriately applied too, so you don't end up using the wrong tool bestie 🙈
2.3. Coexistence and Transition 🤝
the whole point of an evolutionary architecture is letting new models replace or supplement existing ones ✨ but the interactions between models could lead to incompatibilities, security "holes", and other undesirable effects 💀
Coexistence docs exist to detail recognized anomalies and to describe required and recommended behaviors for resolving the interactions between models within the architecture 🛠️
Coexistence docs may be prepared separately from model definition docs, to describe and resolve interaction anomalies between a model definition and one or more other model definitions 🦋
and recommendations for transitions between models may also be described, either in a coexistence doc or in a separate doc 🚀
2.4. Transport Mappings 📬
SNMP messages get sent over various transports, and that's where Transport Mapping docs come in 💖 their job is to define how the mapping between SNMP and the transport is done 🧚
2.5. Message Processing 💌
a Message Processing Model doc defines a message format, which is typically identified by a version field in an SNMP message header 🎀 the doc may also define a MIB module for use in message processing and for instrumenting version-specific interactions 🌸
an SNMP engine includes one or more Message Processing Models, so it can send and receive multiple versions of SNMP messages at once 👑
2.6. Security 🔐
some environments require secure protocol interactions, and security is normally applied at two different stages 💅
- in the transmission/receipt of messages, and
- in the processing of the contents of messages.
for purposes of this doc, "security" means message-level security, while "access control" refers to the security applied to protocol operations ✨
authentication, encryption, and timeliness checking are common functions of message level security 🫶
a security doc describes a Security Model 🛡️ the threats it protects against, its goals, the protocols it uses to meet those goals, and it may define a MIB module to describe the data used during processing and to allow remote configuration of message-level security parameters, such as passwords 🔑
an SNMP engine may support multiple Security Models concurrently 🌈
2.7. Access Control 🚪
during processing, it may be required to control access to managed objects for operations 🙅♀️
an Access Control Model defines mechanisms to determine whether access to a managed object should be allowed 🧐 it may define a MIB module used during processing and to allow remote configuration of access control policies 💜
2.8. Protocol Operations ⚙️
SNMP messages encapsulate an SNMP Protocol Data Unit (PDU) 📦 it's the purpose of a Protocol Operations doc to define the operations of the protocol with respect to processing those PDUs 🧠
an application doc defines which Protocol Operations docs are supported by the application 🎯
2.9. Applications 📱
an SNMP entity normally includes a number of applications 🍓 they use the services of an SNMP engine to accomplish specific tasks, coordinate the processing of management information operations, and may use SNMP messages to talk to other SNMP entities 💬
Applications docs describe the purpose of an application, the services required of the associated SNMP engine, and the protocol operations and informational model the application uses to perform management operations ✨
an application doc defines which set of docs are used to specifically define the structure of management information, textual conventions, conformance requirements, and operations supported by the application 📚
2.10. Structure of Management Information 🏗️
management information is viewed as a collection of managed objects, living in a virtual information store called the Management Information Base (MIB) 🗄️ collections of related objects are defined in MIB modules 🧩
it's the purpose of a Structure of Management Information doc to establish the syntax for defining objects, modules, and other elements of managed information 📐
2.11. Textual Conventions 🏷️
when designing a MIB module, it's often useful to define new types similar to those in the SMI, but with more precise semantics or with special semantics attached 💅 these newly defined types are called textual conventions, and they may be defined in separate docs or within a MIB module 🌸
2.12. Conformance Statements ✅
it may be useful to define the acceptable lower-bounds of implementation, along with the actual level of implementation achieved 📊 it's the purpose of Conformance Statements to define the notation used for these purposes 🤓
2.13. Management Information Base Modules 🧠
MIB docs describe collections of managed objects that instrument some aspect of a managed node 🖥️
2.13.1. SNMP Instrumentation MIBs 🔍
an SNMP MIB doc may define a collection of managed objects that instrument the SNMP protocol itself 🪞 MIB modules may also be defined within the docs describing parts of the SNMP architecture, like the docs for Message Processing Models, Security Models, and so on 🎀 this is for instrumenting those Models, and for allowing remote configuration of the Model 💖
2.14. SNMP Framework Documents 🖼️
this architecture is designed to allow an orderly evolution of portions of SNMP Frameworks 🦋
throughout the rest of this doc, the term "subsystem" refers to an abstract and incomplete specification of a portion of a Framework, which gets further refined by a model specification 🧩
a "model" describes a specific design of a subsystem, defining additional constraints and rules for conformance to the model 📏 a model is detailed enough to make it possible to implement the specification 🛠️
an "implementation" is an instantiation of a subsystem, conforming to one or more specific models 💜
SNMP version 1 (SNMPv1), is the original Internet-standard Network Management Framework, as described in RFCs 1155, 1157, and 1212 👑
SNMP version 2 (SNMPv2), is the SNMPv2 Framework as derived from the SNMPv1 Framework 🌱 it is described in RFCs 1902-1907, and SNMPv2 has no message definition 🙈
The Community-based SNMP version 2 (SNMPv2c), is an experimental SNMP Framework which supplements the SNMPv2 Framework, as described in RFC1901 🧪 it adds the SNMPv2c message format, which is similar to the SNMPv1 message format 🍭
SNMP version 3 (SNMPv3), is an extensible SNMP Framework which supplements the SNMPv2 Framework by supporting the following: 🌈
- a new SNMP message format,
- Security for Messages, and
- Access Control.
other SNMP Frameworks, i.e., other configurations of implemented subsystems, are expected to also be consistent with this architecture 🫶💖
3. Elements of the Architecture ✨
okay bestie, this section is where we meet all the building blocks 🧱 and figure out what each one is called. There are three kinds of naming in here:
- the naming of entities,
- the naming of identities, and
- the naming of management information.
The architecture also gives names to some other constructs that show up all over the documentation, so we'll keep an eye out for those too 👀
3.1. The Naming of Entities 🎀
An SNMP entity is an implementation of this architecture. Each one is made of an SNMP engine plus one or more associated applications. Here's the whole picture 🦋
+-------------------------------------------------------------------+
| SNMP entity |
| |
| +-------------------------------------------------------------+ |
| | SNMP engine (identified by snmpEngineID) | |
| | | |
| | +------------+ +------------+ +-----------+ +-----------+ | |
| | | | | | | | | | | |
| | | Dispatcher | | Message | | Security | | Access | | |
| | | | | Processing | | Subsystem | | Control | | |
| | | | | Subsystem | | | | Subsystem | | |
| | | | | | | | | | | |
| | +------------+ +------------+ +-----------+ +-----------+ | |
| | | |
| +-------------------------------------------------------------+ |
| |
| +-------------------------------------------------------------+ |
| | Application(s) | |
| | | |
| | +-------------+ +--------------+ +--------------+ | |
| | | Command | | Notification | | Proxy | | |
| | | Generator | | Receiver | | Forwarder | | |
| | +-------------+ +--------------+ +--------------+ | |
| | | |
| | +-------------+ +--------------+ +--------------+ | |
| | | Command | | Notification | | Other | | |
| | | Responder | | Originator | | | | |
| | +-------------+ +--------------+ +--------------+ | |
| | | |
| +-------------------------------------------------------------+ |
| |
+-------------------------------------------------------------------+3.1.1. SNMP engine ⚙️
An SNMP engine is the part that does the heavy lifting: sending and receiving messages, authenticating and encrypting them, and controlling who gets access to managed objects. It's giving one-to-one energy, because each SNMP engine belongs to exactly one SNMP entity, the one that contains it 💅
The engine contains:
- a Dispatcher,
- a Message Processing Subsystem,
- a Security Subsystem, and
- an Access Control Subsystem.
3.1.1.1. snmpEngineID 🪪
Within an administrative domain, an snmpEngineID is the unique and unambiguous identifier of an SNMP engine. Since every SNMP engine goes with exactly one SNMP entity, the snmpEngineID also uniquely and unambiguously identifies that entity. So it's like the engine's ID card and the entity's ID card at the same time, iconic 🌈
3.1.1.2. Dispatcher 📬
There is only one Dispatcher in an SNMP engine, and it's the one doing the juggling ✨ It lets multiple versions of SNMP messages run at the same time inside the engine. It does this by:
- sending and receiving SNMP messages to and from the network,
- figuring out the version of an SNMP message and working with the matching Message Processing Model,
- providing an abstract interface to SNMP applications for delivery of a PDU to an application.
- providing an abstract interface for SNMP applications that lets them send a PDU to a remote SNMP entity.
3.1.1.3. Message Processing Subsystem 📦
The Message Processing Subsystem is responsible for getting messages ready to send, and for pulling data back out of messages it receives. Main character energy 👑
It can hold more than one Message Processing Model, as you can see in the next figure. The asterisk (*) means one or more Message Processing Models may be present.
+------------------------------------------------------------------+
| |
| Message Processing Subsystem |
| |
| +------------+ +------------+ +------------+ +------------+ |
| | * | | * | | * | | * | |
| | SNMPv3 | | SNMPv1 | | SNMPv2c | | Other | |
| | Message | | Message | | Message | | Message | |
| | Processing | | Processing | | Processing | | Processing | |
| | Model | | Model | | Model | | Model | |
| | | | | | | | | |
| +------------+ +------------+ +------------+ +------------+ |
| |
+------------------------------------------------------------------+3.1.1.3.1. Message Processing Model 🧩
Each Message Processing Model defines the format of one particular version of an SNMP message. It also coordinates the preparing and extracting of that version-specific message format, so every version has its own little specialist 🫶
3.1.1.4. Security Subsystem 🔐
The Security Subsystem provides security services such as authentication and privacy of messages. It can hold multiple Security Models, as shown in the following figure. The asterisk (*) means one or more Security Models may be present.
+------------------------------------------------------------------+
| |
| Security Subsystem |
| |
| +----------------+ +-----------------+ +-------------------+ |
| | * | | * | | * | |
| | User-Based | | Other | | Other | |
| | Security | | Security | | Security | |
| | Model | | Model | | Model | |
| | | | | | | |
| +----------------+ +-----------------+ +-------------------+ |
| |
+------------------------------------------------------------------+3.1.1.4.1. Security Model 🛡️
A Security Model defines the threats it protects against, the goals of its services, and the security protocols it uses to deliver services such as authentication and privacy. Think of it as the whole safety plan 📋💖
3.1.1.4.2. Security Protocol 🗝️
A Security Protocol defines the mechanisms, procedures, and MIB data used to provide a security service, like authentication or privacy. It's the actual how-to, bestie 🧚
3.1.2. Access Control Subsystem 🚪
The Access Control Subsystem provides authorization services through one or more Access Control Models. Only the right folks get through this door 💅
+------------------------------------------------------------------+
| |
| Access Control Subsystem |
| |
| +---------------+ +-----------------+ +------------------+ |
| | * | | * | | * | |
| | View-Based | | Other | | Other | |
| | Access | | Access | | Access | |
| | Control | | Control | | Control | |
| | Model | | Model | | Model | |
| | | | | | | |
| +---------------+ +-----------------+ +------------------+ |
| |
+------------------------------------------------------------------+3.1.2.1. Access Control Model 🔑
An Access Control Model defines a particular access decision function, which is the thing that makes the call on whether someone's access rights are good enough 🫠✨
3.1.3. Applications 🎪
There are several types of applications, and they're all super different:
- command generators, which monitor and manipulate management data,
- command responders, which provide access to management data,
- notification originators, which initiate asynchronous messages,
- notification receivers, which process asynchronous messages, and
- proxy forwarders, which forward messages between entities.
All of these apps lean on the services the SNMP engine provides, so the engine is the real MVP here 🏆💜
3.1.3.1. SNMP Manager 💼
okay so an SNMP entity that has one or more command generator and/or notification receiver applications (plus its SNMP engine) is traditionally called an SNMP manager 🎀 * One or more models may be present.
(traditional SNMP manager)
+-------------------------------------------------------------------+
| +--------------+ +--------------+ +--------------+ SNMP entity |
| | NOTIFICATION | | NOTIFICATION | | COMMAND | |
| | ORIGINATOR | | RECEIVER | | GENERATOR | |
| | applications | | applications | | applications | |
| +--------------+ +--------------+ +--------------+ |
| ^ ^ ^ |
| | | | |
| v v v |
| +-------+--------+-----------------+ |
| ^ |
| | +---------------------+ +----------------+ |
| | | Message Processing | | Security | |
| Dispatcher v | Subsystem | | Subsystem | |
| +-------------------+ | +------------+ | | | |
| | PDU Dispatcher | | +->| v1MP * |<--->| +------------+ | |
| | | | | +------------+ | | | Other | | |
| | | | | +------------+ | | | Security | | |
| | | | +->| v2cMP * |<--->| | Model | | |
| | Message | | | +------------+ | | +------------+ | |
| | Dispatcher <--------->+ | | | |
| | | | | +------------+ | | +------------+ | |
| | | | +->| v3MP * |<--->| | User-based | | |
| | Transport | | | +------------+ | | | Security | | |
| | Mapping | | | +------------+ | | | Model | | |
| | (e.g RFC1906) | | +->| otherMP * |<--->| +------------+ | |
| +-------------------+ | +------------+ | | | |
| ^ +---------------------+ +----------------+ |
| | |
| v |
+-------------------------------------------------------------------+
+-----+ +-----+ +-------+
| UDP | | IPX | . . . | other |
+-----+ +-----+ +-------+
^ ^ ^
| | |
v v v
+------------------------------+
| Network |
+------------------------------+3.1.3.2. SNMP Agent 🦋
the flip side! an SNMP entity with one or more command responder and/or notification originator applications (plus its SNMP engine) is traditionally called an SNMP agent ✨
+------------------------------+
| Network |
+------------------------------+
^ ^ ^
| | |
v v v
+-----+ +-----+ +-------+
| UDP | | IPX | . . . | other |
+-----+ +-----+ +-------+ (traditional SNMP agent)
+-------------------------------------------------------------------+
| ^ |
| | +---------------------+ +----------------+ |
| | | Message Processing | | Security | |
| Dispatcher v | Subsystem | | Subsystem | |
| +-------------------+ | +------------+ | | | |
| | Transport | | +->| v1MP * |<--->| +------------+ | |
| | Mapping | | | +------------+ | | | Other | | |
| | (e.g. RFC1906) | | | +------------+ | | | Security | | |
| | | | +->| v2cMP * |<--->| | Model | | |
| | Message | | | +------------+ | | +------------+ | |
| | Dispatcher <--------->| +------------+ | | +------------+ | |
| | | | +->| v3MP * |<--->| | User-based | | |
| | | | | +------------+ | | | Security | | |
| | PDU Dispatcher | | | +------------+ | | | Model | | |
| +-------------------+ | +->| otherMP * |<--->| +------------+ | |
| ^ | +------------+ | | | |
| | +---------------------+ +----------------+ |
| v |
| +-------+-------------------------+---------------+ |
| ^ ^ ^ |
| | | | |
| v v v |
| +-------------+ +---------+ +--------------+ +-------------+ |
| | COMMAND | | ACCESS | | NOTIFICATION | | PROXY * | |
| | RESPONDER |<->| CONTROL |<->| ORIGINATOR | | FORWARDER | |
| | application | | | | applications | | application | |
| +-------------+ +---------+ +--------------+ +-------------+ |
| ^ ^ |
| | | |
| v v |
| +----------------------------------------------+ |
| | MIB instrumentation | SNMP entity |
+-------------------------------------------------------------------+3.2. The Naming of Identities 🪪
principal
^
|
|
+----------------------------|-------------+
| SNMP engine v |
| +--------------+ |
| | | |
| +-----------------| securityName |---+ |
| | Security Model | | | |
| | +--------------+ | |
| | ^ | |
| | | | |
| | v | |
| | +------------------------------+ | |
| | | | | |
| | | Model | | |
| | | Dependent | | |
| | | Security ID | | |
| | | | | |
| | +------------------------------+ | |
| | ^ | |
| | | | |
| +-------------------------|----------+ |
| | |
| | |
+----------------------------|-------------+
|
v
network3.2.1. Principal 👑
a principal is the "who" that services get provided for, or on whose behalf processing happens 💅
a principal can be lots of things! like an individual playing a particular role, a group of individuals who each play a particular role, an application or a bunch of applications, or any mix of those 🌈
3.2.2. securityName 🫶
a securityName is a human readable string that stands in for a principal. it has a model-independent format, so it can be used outside of any particular Security Model ✨
3.2.3. Model-dependent security ID 🧚
a model-dependent security ID is the model-specific version of a securityName inside one particular Security Model 🍓
model-dependent security IDs may or may not be human readable, and they have a model-dependent syntax. examples include community names, user names, and parties 💜
turning model-dependent security IDs into securityNames (and back again) is the job of the relevant Security Model 🎀
3.3. The Naming of Management Information 📚
management information lives at an SNMP entity where a Command Responder Application has local access to potentially multiple contexts. this application uses a contextEngineID that's equal to the snmpEngineID of its associated SNMP engine 🌸
+-----------------------------------------------------------------+
| SNMP entity (identified by snmpEngineID, example: abcd) |
| |
| +------------------------------------------------------------+ |
| | SNMP engine (identified by snmpEngineID) | |
| | | |
| | +-------------+ +------------+ +-----------+ +-----------+ | |
| | | | | | | | | | | |
| | | Dispatcher | | Message | | Security | | Access | | |
| | | | | Processing | | Subsystem | | Control | | |
| | | | | Subsystem | | | | Subsystem | | |
| | | | | | | | | | | |
| | +-------------+ +------------+ +-----------+ +-----------+ | |
| | | |
| +------------------------------------------------------------+ |
| |
| +------------------------------------------------------------+ |
| | Command Responder Application | |
| | (contextEngineID, example: abcd) | |
| | | |
| | example contextNames: | |
| | | |
| | "bridge1" "bridge2" "" (default) | |
| | --------- --------- ------------ | |
| | | | | | |
| +------|------------------|-------------------|--------------+ |
| | | | |
| +------|------------------|-------------------|--------------+ |
| | MIB | instrumentation | | | |
| | +---v------------+ +---v------------+ +----v-----------+ | |
| | | context | | context | | context | | |
| | | | | | | | | |
| | | +------------+ | | +------------+ | | +------------+ | | |
| | | | bridge MIB | | | | bridge MIB | | | | other MIB | | | |
| | | +------------+ | | +------------+ | | +------------+ | | |
| | | | | | | | | |
| | | | | | | +------------+ | | |
| | | | | | | | some MIB | | | |
| | | | | | | +------------+ | | |
| | | | | | | | | |
+-----------------------------------------------------------------+3.3.1. An SNMP Context ✨
okay so an SNMP context (or just "context" for short 🫶) is a collection of management information that an SNMP entity can access. The same item of management info can live in more than one context, and an SNMP entity can potentially have access to lots of contexts. 🌸
there are usually tons of instances of each managed object type in a management domain 😭. to keep things simple, the MIB module's method for identifying instances doesn't let every instance be told apart from every other instance in the whole domain. instead, each instance only needs to be identified within some scope, which is the "context," and the domain has multiple contexts. a context is often a physical device, or maybe a logical one, but it can also cover several devices, part of one device, or even parts of several devices. the catch is that a context is always a subset of a single SNMP entity 💅. so to pin down one specific item of management info in the whole domain, you need its contextName and contextEngineID on top of its object type and instance.
for example, the managed object type ifDescr [RFC1573] describes a network interface. to find the description of device-X's first network interface, you need four things: the snmpEngineID of the SNMP entity that gives access to device-X's management info, the contextName (device-X), the managed object type (ifDescr), and the instance ("1") 🧚.
every context has at least one unique identification within the management domain. the same item of management info can exist in multiple contexts, and an item can have multiple unique identifications. that happens when it shows up in several contexts, and it also happens when one context has several unique identifications. it's giving layers 🌈.
the combo of a contextEngineID and a contextName unambiguously identifies a context inside an administrative domain. just note that more than one combo of contextEngineID and contextName can unambiguously identify the same context 🦋.
3.3.2. contextEngineID 🎀
inside an administrative domain, a contextEngineID uniquely identifies an SNMP entity that might realize an instance of a context with a particular contextName 🧚♀️.
3.3.3. contextName 💜
a contextName is what you use to name a context. each contextName MUST be unique within an SNMP entity, no exceptions bestie 🙅♀️.
3.3.4. scopedPDU 🍓
a scopedPDU is a block of data that holds a contextEngineID, a contextName, and a PDU ✨.
the PDU is an SNMP Protocol Data Unit carrying info that's named in the context. that context is unambiguously identified inside an administrative domain by the combo of the contextEngineID and the contextName. for more on SNMP PDUs, check out RFC1905 👑.
3.4. Other Constructs 🧁
3.4.1. maxSizeResponseScopedPDU 🌷
the maxSizeResponseScopedPDU is the maximum size of a scopedPDU that's allowed to be included in a response message. heads up that the size of a scopedPDU doesn't count the size of the SNMP message header 💅.
3.4.2. Local Configuration Datastore 🗂️
the subsystems, models, and applications inside an SNMP entity might need to keep their own sets of configuration info 🫶.
some of that configuration info might be accessible as managed objects 🔥.
the whole collection of these sets of info is called an entity's Local Configuration Datastore (LCD) 💖.
3.4.3. securityLevel 🔐
this architecture recognizes three levels of security 👑:
- without authentication and without privacy (noAuthNoPriv)
- with authentication but without privacy (authNoPriv)
- with authentication and with privacy (authPriv)
these three values are ordered, so noAuthNoPriv is less than authNoPriv, and authNoPriv is less than authPriv 📈.
every message has an associated securityLevel. all the Subsystems (Message Processing, Security, Access Control) and applications are required to either supply a value of securityLevel or to abide by the supplied value while they process the message and its contents 🛡️.
4. Abstract Service Interfaces ✨
abstract service interfaces are defined to describe the conceptual interfaces between the various subsystems inside an SNMP entity 🧠.
these abstract service interfaces are defined by a set of primitives. the primitives say which services are provided and which abstract data elements get passed when a service is invoked. this section lists the primitives defined for the various subsystems 💖.
4.1. Dispatcher Primitives 🌸
the Dispatcher usually provides services to SNMP applications through its PDU Dispatcher. this section describes the primitives the PDU Dispatcher provides 🦋.
4.1.1. Generate Outgoing Request or Notification 📤
the PDU Dispatcher provides the following primitive so an application can send an SNMP Request or Notification to another SNMP entity 💌:
statusInformation = -- sendPduHandle if success
-- errorIndication if failure
sendPdu(
IN transportDomain -- transport domain to be used
IN transportAddress -- transport address to be used
IN messageProcessingModel -- typically, SNMP version
IN securityModel -- Security Model to use
IN securityName -- on behalf of this principal
IN securityLevel -- Level of Security requested
IN contextEngineID -- data from/at this entity
IN contextName -- data from/in this context
IN pduVersion -- the version of the PDU
IN PDU -- SNMP Protocol Data Unit
IN expectResponse -- TRUE or FALSE
)4.1.2. Process Incoming Request or Notification PDU 📥
the PDU Dispatcher provides the following primitive to pass an incoming SNMP PDU to an application 🎁:
processPdu( -- process Request/Notification PDU
IN messageProcessingModel -- typically, SNMP version
IN securityModel -- Security Model in use
IN securityName -- on behalf of this principal
IN securityLevel -- Level of Security
IN contextEngineID -- data from/at this SNMP entity
IN contextName -- data from/in this context
IN pduVersion -- the version of the PDU
IN PDU -- SNMP Protocol Data Unit
IN maxSizeResponseScopedPDU -- maximum size of the Response PDU
IN stateReference -- reference to state information
) -- needed when sending a response4.1.3. Generate Outgoing Response 📨
the PDU Dispatcher provides the following primitive so an application can return an SNMP Response PDU to the PDU Dispatcher 🌈:
returnResponsePdu(
IN messageProcessingModel -- typically, SNMP version
IN securityModel -- Security Model in use
IN securityName -- on behalf of this principal
IN securityLevel -- same as on incoming request
IN contextEngineID -- data from/at this SNMP entity
IN contextName -- data from/in this context
IN pduVersion -- the version of the PDU
IN PDU -- SNMP Protocol Data Unit
IN maxSizeResponseScopedPDU -- maximum size of the Response PDU
IN stateReference -- reference to state information
-- as presented with the request
IN statusInformation -- success or errorIndication
) -- error counter OID/value if error4.1.4. Process Incoming Response PDU 📬
the PDU Dispatcher provides the following primitive to pass an incoming SNMP Response PDU to an application 💫:
processResponsePdu( -- process Response PDU
IN messageProcessingModel -- typically, SNMP version
IN securityModel -- Security Model in use
IN securityName -- on behalf of this principal
IN securityLevel -- Level of Security
IN contextEngineID -- data from/at this SNMP entity
IN contextName -- data from/in this context
IN pduVersion -- the version of the PDU
IN PDU -- SNMP Protocol Data Unit
IN statusInformation -- success or errorIndication
IN sendPduHandle -- handle from sendPdu
)4.1.5. Registering Responsibility for Handling SNMP PDUs 🎫
applications can register and unregister responsibility for a specific contextEngineID, and for specific pduTypes, with the PDU Dispatcher. they do this with the primitives below. which particular pduTypes an application can register for is decided by the Message Processing Model(s) supported by the SNMP entity that contains the PDU Dispatcher 🗝️.
statusInformation = -- success or errorIndication
registerContextEngineID(
IN contextEngineID -- take responsibility for this one
IN pduType -- the pduType(s) to be registered
)
unregisterContextEngineID(
IN contextEngineID -- give up responsibility for this one
IN pduType -- the pduType(s) to be unregistered
)note that realizations of the registerContextEngineID and unregisterContextEngineID abstract service interfaces may provide implementation-specific ways for applications to register and deregister responsibility for all possible values of the contextEngineID or pduType parameters 👀.
4.2. Message Processing Subsystem Primitives 📦
the Dispatcher works with a Message Processing Model to process a specific version of an SNMP Message. this section describes the primitives the Message Processing Subsystem provides 🧩.
4.2.1. Prepare Outgoing SNMP Request or Notification Message 🛠️
the Message Processing Subsystem provides this service primitive to prepare an outgoing SNMP Request or Notification Message 💅:
statusInformation = -- success or errorIndication
prepareOutgoingMessage(
IN transportDomain -- transport domain to be used
IN transportAddress -- transport address to be used
IN messageProcessingModel -- typically, SNMP version
IN securityModel -- Security Model to use
IN securityName -- on behalf of this principal
IN securityLevel -- Level of Security requested
IN contextEngineID -- data from/at this entity
IN contextName -- data from/in this context
IN pduVersion -- the version of the PDU
IN PDU -- SNMP Protocol Data Unit
IN expectResponse -- TRUE or FALSE
IN sendPduHandle -- the handle for matching
-- incoming responses
OUT destTransportDomain -- destination transport domain
OUT destTransportAddress -- destination transport address
OUT outgoingMessage -- the message to send
OUT outgoingMessageLength -- its length
)4.2.2. Prepare an Outgoing SNMP Response Message ✨
okay bestie, this one is the Message Processing Subsystem's move for building an outgoing SNMP Response message 💅. the parameters are basically the receipts from the original request, so you can see how the whole conversation stays connected 🦋
result = -- SUCCESS or FAILURE
prepareResponseMessage(
IN messageProcessingModel -- typically, SNMP version
IN securityModel -- same as on incoming request
IN securityName -- same as on incoming request
IN securityLevel -- same as on incoming request
IN contextEngineID -- data from/at this SNMP entity
IN contextName -- data from/in this context
IN pduVersion -- the version of the PDU
IN PDU -- SNMP Protocol Data Unit
IN maxSizeResponseScopedPDU -- maximum size of the Response PDU
IN stateReference -- reference to state information
-- as presented with the request
IN statusInformation -- success or errorIndication
-- error counter OID/value if error
OUT destTransportDomain -- destination transport domain
OUT destTransportAddress -- destination transport address
OUT outgoingMessage -- the message to send
OUT outgoingMessageLength -- its length
)4.2.3. Prepare Data Elements from an Incoming SNMP Message 🎀
this is the Message Processing Subsystem unpacking an incoming SNMP message into its abstract data elements, so the rest of the system can actually work with them 🧚
result = -- SUCCESS or errorIndication
prepareDataElements(
IN transportDomain -- origin transport domain
IN transportAddress -- origin transport address
IN wholeMsg -- as received from the network
IN wholeMsgLength -- as received from the network
OUT messageProcessingModel -- typically, SNMP version
OUT securityModel -- Security Model to use
OUT securityName -- on behalf of this principal
OUT securityLevel -- Level of Security requested
OUT contextEngineID -- data from/at this entity
OUT contextName -- data from/in this context
OUT pduVersion -- the version of the PDU
OUT PDU -- SNMP Protocol Data Unit
OUT pduType -- SNMP PDU type
OUT sendPduHandle -- handle for matched request
OUT maxSizeResponseScopedPDU -- maximum size of the Response PDU
OUT statusInformation -- success or errorIndication
-- error counter OID/value if error
OUT stateReference -- reference to state information
-- to be used for possible Response
)4.3. Access Control Subsystem Primitives 🌸
applications are the main clients of the Access Control Subsystem, so they're the ones calling its services, lowkey the VIP section of this whole doc 👑
the Access Control Subsystem gives you one primitive to check whether access is allowed. it's giving "may I please" energy 🙈
statusInformation = -- success or errorIndication
isAccessAllowed(
IN securityModel -- Security Model in use
IN securityName -- principal who wants to access
IN securityLevel -- Level of Security
IN viewType -- read, write, or notify view
IN contextName -- context containing variableName
IN variableName -- OID for the managed object
)4.4. Security Subsystem Primitives 🔐
the Message Processing Subsystem is the usual client of the Security Subsystem, so it's always the one knocking on this door 🫶
4.4.1. Generate a Request or Notification Message 💜
the Security Subsystem gives you this primitive to generate a Request or Notification message. it's the one that handles the security stuff on the way out, so the message is locked and loaded before it leaves 🔥
statusInformation =
generateRequestMsg(
IN messageProcessingModel -- typically, SNMP version
IN globalData -- message header, admin data
IN maxMessageSize -- of the sending SNMP entity
IN securityModel -- for the outgoing message
IN securityEngineID -- authoritative SNMP entity
IN securityName -- on behalf of this principal
IN securityLevel -- Level of Security requested
IN scopedPDU -- message (plaintext) payload
OUT securityParameters -- filled in by Security Module
OUT wholeMsg -- complete generated message
OUT wholeMsgLength -- length of the generated message
)4.4.2. Process Incoming Message 🌈
this is the Security Subsystem's primitive for processing an incoming message. it takes the raw bytes off the wire and gives back the principal, the plaintext payload, and a state reference so a response can be built later ✨
statusInformation = -- errorIndication or success
-- error counter OID/value if error
processIncomingMsg(
IN messageProcessingModel -- typically, SNMP version
IN maxMessageSize -- of the sending SNMP entity
IN securityParameters -- for the received message
IN securityModel -- for the received message
IN securityLevel -- Level of Security
IN wholeMsg -- as received on the wire
IN wholeMsgLength -- length as received on the wire
OUT securityEngineID -- identification of the principal
OUT securityName -- identification of the principal
OUT scopedPDU, -- message (plaintext) payload
OUT maxSizeResponseScopedPDU -- maximum size of the Response PDU
OUT securityStateReference -- reference to security state
) -- information, needed for response4.4.3. Generate a Response Message 🍓
the outgoing mirror of 4.4.2 😭 this one builds the secured Response message, and it uses the state reference from the original request so the whole exchange stays matched up 💖
statusInformation =
generateResponseMsg(
IN messageProcessingModel -- typically, SNMP version
IN globalData -- message header, admin data
IN maxMessageSize -- of the sending SNMP entity
IN securityModel -- for the outgoing message
IN securityEngineID -- authoritative SNMP entity
IN securityName -- on behalf of this principal
IN securityLevel -- for the outgoing message
IN scopedPDU -- message (plaintext) payload
IN securityStateReference -- reference to security state
-- information from original request
OUT securityParameters -- filled in by Security Module
OUT wholeMsg -- complete generated message
OUT wholeMsgLength -- length of the generated message
)4.5. Common Primitives 🧸
these primitives are shared by more than one Subsystem, so they're the group-project stuff everybody uses 🫧
4.5.1. Release State Reference Information 🧹
any Subsystem that passes stateReference information around also gives you a primitive to free up the memory holding that state. think of it as cleaning up after the party so nothing gets left behind ✨
stateRelease(
IN stateReference -- handle of reference to be released
)4.6. Scenario Diagrams 🗺️
okay, the diagrams are where it all clicks, bestie 🤩
4.6.1. Command Generator or Notification Originator 🦋
this diagram shows how a Command Generator or Notification Originator application asks for a PDU to be sent, and how the response comes back (asynchronously) to that application. follow the arrows and you'll see the whole journey, it's so iconic 😭🔥
Command Dispatcher Message Security
Generator | Processing Model
| | Model |
| sendPdu | | |
|------------------->| | |
| | prepareOutgoingMessage | |
: |----------------------->| |
: | | generateRequestMsg |
: | |-------------------->|
: | | |
: | |<--------------------|
: | | |
: |<-----------------------| |
: | | |
: |------------------+ | |
: | Send SNMP | | |
: | Request Message | | |
: | to Network | | |
: | v | |
: : : : :
: : : : :
: : : : :
: | | | |
: | Receive SNMP | | |
: | Response Message | | |
: | from Network | | |
: |<-----------------+ | |
: | | |
: | prepareDataElements | |
: |----------------------->| |
: | | processIncomingMsg |
: | |-------------------->|
: | | |
: | |<--------------------|
: | | |
: |<-----------------------| |
| processResponsePdu | | |
|<-------------------| | |
| | | |4.6.2. Scenario Diagram for a Command Responder Application 🎀
okay so this diagram is giving "how a Command Responder or Notification Receiver app gets set up and handles stuff" 💅 It shows how the app registers itself to handle a pduType, how a PDU gets dispatched to it once an SNMP message comes in, and how the Response gets sent back out to the network (asynchronously, so it's not all happening in one straight line 🧚)
Command Dispatcher Message Security
Responder | Processing Model
| | Model |
| | | |
| registerContextEngineID | | |
|------------------------>| | |
|<------------------------| | | |
| | Receive SNMP | | |
: | Message | | |
: | from Network | | |
: |<-------------+ | |
: | | |
: |prepareDataElements | |
: |------------------->| |
: | | processIncomingMsg |
: | |------------------->|
: | | |
: | |<-------------------|
: | | |
: |<-------------------| |
| processPdu | | |
|<------------------------| | |
| | | |
: : : :
: : : :
| returnResponsePdu | | |
|------------------------>| | |
: | prepareResponseMsg | |
: |------------------->| |
: | |generateResponseMsg |
: | |------------------->|
: | | |
: | |<-------------------|
: | | |
: |<-------------------| |
: | | |
: |--------------+ | |
: | Send SNMP | | |
: | Message | | |
: | to Network | | |
: | v | |5. Managed Object Definitions for SNMP Management Frameworks ✨
okay this is the part where the actual MIB module shows up 🦋 It's called SNMP-FRAMEWORK-MIB and it's where the framework's textual conventions live, like SnmpEngineID and SnmpSecurityModel. Here's the whole thing, every single line:
SNMP-FRAMEWORK-MIB DEFINITIONS ::= BEGIN
IMPORTS
MODULE-IDENTITY, OBJECT-TYPE,
OBJECT-IDENTITY,
snmpModules FROM SNMPv2-SMI
TEXTUAL-CONVENTION FROM SNMPv2-TC
MODULE-COMPLIANCE, OBJECT-GROUP FROM SNMPv2-CONF;
snmpFrameworkMIB MODULE-IDENTITY
LAST-UPDATED "9711200000Z" -- 20 November 1997
ORGANIZATION "SNMPv3 Working Group"
CONTACT-INFO "WG-email: snmpv3@tis.com
Subscribe: majordomo@tis.com
In message body: subscribe snmpv3
Chair: Russ Mundy
Trusted Information Systems
postal: 3060 Washington Rd
Glenwood MD 21738
USA
email: mundy@tis.com
phone: +1 301-854-6889
Co-editor Dave Harrington
Cabletron Systems, Inc.
postal: Post Office Box 5005
Mail Stop: Durham
35 Industrial Way
Rochester, NH 03867-5005
USA
email: dbh@ctron.com
phone: +1 603-337-7357
Co-editor Randy Presuhn
BMC Software, Inc.
postal: 1190 Saratoga Avenue
Suite 130
San Jose, CA 95129
USA
email: rpresuhn@bmc.com
phone: +1 408-556-0720
Co-editor: Bert Wijnen
IBM T.J. Watson Research
postal: Schagen 33
3461 GL Linschoten
Netherlands
email: wijnen@vnet.ibm.com
phone: +31 348-432-794
"
DESCRIPTION "The SNMP Management Architecture MIB"
::= { snmpModules 2 }
-- Textual Conventions used in the SNMP Management Architecture ***
SnmpEngineID ::= TEXTUAL-CONVENTION
STATUS current
DESCRIPTION "An SNMP engine's administratively-unique identifier.
The value for this object may not be all zeros or
all 'ff'H or the empty (zero length) string.
The initial value for this object may be configured
via an operator console entry or via an algorithmic
function. In the latter case, the following
example algorithm is recommended.
In cases where there are multiple engines on the
same system, the use of this algorithm is NOT
appropriate, as it would result in all of those
engines ending up with the same ID value.
1) The very first bit is used to indicate how the
rest of the data is composed.
0 - as defined by enterprise using former methods
that existed before SNMPv3. See item 2 below.
1 - as defined by this architecture, see item 3
below.
Note that this allows existing uses of the
engineID (also known as AgentID [RFC1910]) to
co-exist with any new uses.
2) The snmpEngineID has a length of 12 octets.
The first four octets are set to the binary
equivalent of the agent's SNMP management
private enterprise number as assigned by the
Internet Assigned Numbers Authority (IANA).
For example, if Acme Networks has been assigned
{ enterprises 696 }, the first four octets would
be assigned '000002b8'H.
The remaining eight octets are determined via
one or more enterprise-specific methods. Such
methods must be designed so as to maximize the
possibility that the value of this object will
be unique in the agent's administrative domain.
For example, it may be the IP address of the SNMP
entity, or the MAC address of one of the
interfaces, with each address suitably padded
with random octets. If multiple methods are
defined, then it is recommended that the first
octet indicate the method being used and the
remaining octets be a function of the method.
3) The length of the octet strings varies.
The first four octets are set to the binary
equivalent of the agent's SNMP management
private enterprise number as assigned by the
Internet Assigned Numbers Authority (IANA).
For example, if Acme Networks has been assigned
{ enterprises 696 }, the first four octets would
be assigned '000002b8'H.
The very first bit is set to 1. For example, the
above value for Acme Networks now changes to be
'800002b8'H.
The fifth octet indicates how the rest (6th and
following octets) are formatted. The values for
the fifth octet are:
0 - reserved, unused.
1 - IPv4 address (4 octets)
lowest non-special IP address
2 - IPv6 address (16 octets)
lowest non-special IP address
3 - MAC address (6 octets)
lowest IEEE MAC address, canonical
order
4 - Text, administratively assigned
Maximum remaining length 27
5 - Octets, administratively assigned
Maximum remaining length 27
6-127 - reserved, unused
127-255 - as defined by the enterprise
Maximum remaining length 27
"
SYNTAX OCTET STRING (SIZE(1..32))
SnmpSecurityModel ::= TEXTUAL-CONVENTION
STATUS current
DESCRIPTION "An identifier that uniquely identifies a
securityModel of the Security Subsystem within the
SNMP Management Architecture.
The values for securityModel are allocated as
follows:
- The zero value is reserved.
- Values between 1 and 255, inclusive, are reserved
for standards-track Security Models and are
managed by the Internet Assigned Numbers Authority
(IANA).
- Values greater than 255 are allocated to
enterprise-specific Security Models. An
enterprise-specific securityModel value is defined
to be:
enterpriseID * 256 + security model within
enterprise
For example, the fourth Security Model defined by
the enterprise whose enterpriseID is 1 would be
260.
This scheme for allocation of securityModel
values allows for a maximum of 255 standards-
based Security Models, and for a maximum of
255 Security Models per enterprise.okay bestie, we're picking up right where the securityModel notes left off 💅✨
It is believed that the assignment of new
securityModel values will be rare in practice
because the larger the number of simultaneously
utilized Security Models, the larger the
chance that interoperability will suffer.
Consequently, it is believed that such a range
will be sufficient. In the unlikely event that
the standards committee finds this number to be
insufficient over time, an enterprise number
can be allocated to obtain an additional 255
possible values.
Note that the most significant bit must be zero;
hence, there are 23 bits allocated for various
organizations to design and define non-standard
securityModels. This limits the ability to
define new proprietary implementations of Security
Models to the first 8,388,608 enterprises.
It is worthwhile to note that, in its encoded
form, the securityModel value will normally
require only a single byte since, in practice,
the leftmost bits will be zero for most messages
and sign extension is suppressed by the encoding
rules.
As of this writing, there are several values
of securityModel defined for use with SNMP or
reserved for use with supporting MIB objects.
They are as follows:
0 reserved for 'any'
1 reserved for SNMPv1
2 reserved for SNMPv2c
3 User-Based Security Model (USM)
"
SYNTAX INTEGER(0..2147483647)
SnmpMessageProcessingModel ::= TEXTUAL-CONVENTION
STATUS current
DESCRIPTION "An identifier that uniquely identifies a Message
Processing Model of the Message Processing
Subsystem within a SNMP Management Architecture.
The values for messageProcessingModel are
allocated as follows:
- Values between 0 and 255, inclusive, are
reserved for standards-track Message Processing
Models and are managed by the Internet Assigned
Numbers Authority (IANA).
- Values greater than 255 are allocated to
enterprise-specific Message Processing Models.
An enterprise messageProcessingModel value is
defined to be:
enterpriseID * 256 +
messageProcessingModel within enterprise
For example, the fourth Message Processing Model
defined by the enterprise whose enterpriseID
is 1 would be 260.
This scheme for allocation of securityModel
values allows for a maximum of 255 standards-
based Message Processing Models, and for a
maximum of 255 Message Processing Models per
enterprise.
It is believed that the assignment of new
messageProcessingModel values will be rare
in practice because the larger the number of
simultaneously utilized Message Processing Models,
the larger the chance that interoperability
will suffer. It is believed that such a range
will be sufficient. In the unlikely event that
the standards committee finds this number to be
insufficient over time, an enterprise number
can be allocated to obtain an additional 256
possible values.
Note that the most significant bit must be zero;
hence, there are 23 bits allocated for various
organizations to design and define non-standard
messageProcessingModels. This limits the ability
to define new proprietary implementations of
Message Processing Models to the first 8,388,608
enterprises.
It is worthwhile to note that, in its encoded
form, the securityModel value will normally
require only a single byte since, in practice,
the leftmost bits will be zero for most messages
and sign extension is suppressed by the encoding
rules.
As of this writing, there are several values of
messageProcessingModel defined for use with SNMP.
They are as follows:
0 reserved for SNMPv1
1 reserved for SNMPv2c
2 reserved for SNMPv2u and SNMPv2*
3 reserved for SNMPv3
"
SYNTAX INTEGER(0..2147483647)
SnmpSecurityLevel ::= TEXTUAL-CONVENTION
STATUS current
DESCRIPTION "A Level of Security at which SNMP messages can be
sent or with which operations are being processed;
in particular, one of:
noAuthNoPriv - without authentication and
without privacy,
authNoPriv - with authentication but
without privacy,
authPriv - with authentication and
with privacy.
These three values are ordered such that
noAuthNoPriv is less than authNoPriv and
authNoPriv is less than authPriv.
"
SYNTAX INTEGER { noAuthNoPriv(1),
authNoPriv(2),
authPriv(3)
}
SnmpAdminString ::= TEXTUAL-CONVENTION
DISPLAY-HINT "255a"
STATUS current
DESCRIPTION "An octet string containing administrative
information, preferably in human-readable form.
To facilitate internationalization, this
information is represented using the ISO/IEC
IS 10646-1 character set, encoded as an octet
string using the UTF-8 transformation format
described in [RFC2044].
Since additional code points are added by
amendments to the 10646 standard from time
to time, implementations must be prepared to
encounter any code point from 0x00000000 to
0x7fffffff.
The use of control codes should be avoided.
When it is necessary to represent a newline,
the control code sequence CR LF should be used.
The use of leading or trailing white space should
be avoided.
For code points not directly supported by user
interface hardware or software, an alternative
means of entry and display, such as hexadecimal,
may be provided.
For information encoded in 7-bit US-ASCII,
the UTF-8 encoding is identical to the
US-ASCII encoding.
Note that when this TC is used for an object that
is used or envisioned to be used as an index, then
a SIZE restriction must be specified so that the
number of sub-identifiers for any object instance
does not exceed the limit of 128, as defined by
[RFC1905].
"
SYNTAX OCTET STRING (SIZE (0..255))
-- Administrative assignments ***************************************
snmpFrameworkAdmin
OBJECT IDENTIFIER ::= { snmpFrameworkMIB 1 }
snmpFrameworkMIBObjects
OBJECT IDENTIFIER ::= { snmpFrameworkMIB 2 }
snmpFrameworkMIBConformance
OBJECT IDENTIFIER ::= { snmpFrameworkMIB 3 }
-- the snmpEngine Group ********************************************
snmpEngine OBJECT IDENTIFIER ::= { snmpFrameworkMIBObjects 1 }
snmpEngineID OBJECT-TYPE
SYNTAX SnmpEngineID
MAX-ACCESS read-only
STATUS current
DESCRIPTION "An SNMP engine's administratively-unique identifier.
"
::= { snmpEngine 1 }
snmpEngineBoots OBJECT-TYPE
SYNTAX INTEGER (1..2147483647)
MAX-ACCESS read-only
STATUS current
DESCRIPTION "The number of times that the SNMP engine has
(re-)initialized itself since its initial
configuration.
"
::= { snmpEngine 2 }
snmpEngineTime OBJECT-TYPE
SYNTAX INTEGER (0..2147483647)
MAX-ACCESS read-only
STATUS current
DESCRIPTION "The number of seconds since the SNMP engine last
incremented the snmpEngineBoots object.
"
::= { snmpEngine 3 }
snmpEngineMaxMessageSize OBJECT-TYPE
SYNTAX INTEGER (484..2147483647)
MAX-ACCESS read-only
STATUS current
DESCRIPTION "The maximum length in octets of an SNMP message
which this SNMP engine can send or receive and
process, determined as the minimum of the maximum
message size values supported among all of the
transports available to and supported by the engine.
"
::= { snmpEngine 4 }
-- Registration Points for Authentication and Privacy Protocols **
snmpAuthProtocols OBJECT-IDENTITY
STATUS current
DESCRIPTION "Registration point for standards-track
authentication protocols used in SNMP Management
Frameworks.
"
::= { snmpFrameworkAdmin 1 }
snmpPrivProtocols OBJECT-IDENTITY
STATUS current
DESCRIPTION "Registration point for standards-track privacy
protocols used in SNMP Management Frameworks.
"
::= { snmpFrameworkAdmin 2 }
-- Conformance information ******************************************
snmpFrameworkMIBCompliances
OBJECT IDENTIFIER ::= {snmpFrameworkMIBConformance 1}
snmpFrameworkMIBGroups
OBJECT IDENTIFIER ::= {snmpFrameworkMIBConformance 2}
-- compliance statements
snmpFrameworkMIBCompliance MODULE-COMPLIANCE
STATUS current
DESCRIPTION "The compliance statement for SNMP engines which
implement the SNMP Management Framework MIB.
"
MODULE -- this module
MANDATORY-GROUPS { snmpEngineGroup }
::= { snmpFrameworkMIBCompliances 1 }
-- units of conformance
snmpEngineGroup OBJECT-GROUP
OBJECTS {
snmpEngineID,
snmpEngineBoots,
snmpEngineTime,
snmpEngineMaxMessageSize
}
STATUS current
DESCRIPTION "A collection of objects for identifying and
determining the configuration and current timeliness
values of an SNMP engine.
"
::= { snmpFrameworkMIBGroups 1 }
END6. Intellectual Property 🦋
okay so the IETF is NOT taking a side on whether any IP or other rights people claim over this tech are valid, how far they reach, or whether you can get a license for them. 🙈 they also aren't saying they actually went looking for any of those rights, so don't read silence as "nothing's out there." 💀
if you want the nitty gritty on how the IETF handles rights for standards-track and standards-related docs, it's all in BCP-11. claims about rights that people have submitted for publication, any assurances about licenses, or the results of someone trying to get a general license or permission for implementers or users? you can grab all that from the IETF Secretariat. 📬
and the IETF is totally inviting anyone to flag copyrights, patents, patent applications, or other proprietary rights that might cover tech you'd need to implement this standard. 🫶 just send that info to the IETF Executive Director. ✨
7. Acknowledgements 💅
this doc is the result of the SNMPv3 Working Group's hard work, and they deserve all the flowers 🌸 here are the SNMPv3 WG members who get special thanks:
- Dave Battle (SNMP Research, Inc.)
- Uri Blumenthal (IBM T.J. Watson Research Center)
- Jeff Case (SNMP Research, Inc.)
- John Curran (BBN)
- T. Max Devlin (Hi-TECH Connections)
- John Flick (Hewlett Packard)
- David Harrington (Cabletron Systems Inc.)
- N.C. Hien (IBM T.J. Watson Research Center)
- Dave Levi (SNMP Research, Inc.)
- Louis A Mamakos (UUNET Technologies Inc.)
- Paul Meyer (Secure Computing Corporation)
- Keith McCloghrie (Cisco Systems)
- Russ Mundy (Trusted Information Systems, Inc.)
- Bob Natale (ACE*COMM Corporation)
- Mike O'Dell (UUNET Technologies Inc.)
- Dave Perkins (DeskTalk)
- Peter Polkinghorne (Brunel University)
- Randy Presuhn (BMC Software, Inc.)
- David Reid (SNMP Research, Inc.)
- Shawn Routhier (Epilogue)
- Juergen Schoenwaelder (TU Braunschweig)
- Bob Stewart (Cisco Systems)
- Bert Wijnen (IBM T.J. Watson Research Center)
the design is based on recommendations from the IETF Security and Administrative Framework Evolution for SNMP Advisory Team 🧚 the Advisory Team members were:
- David Harrington (Cabletron Systems Inc.)
- Jeff Johnson (Cisco Systems)
- David Levi (SNMP Research Inc.)
- John Linn (Openvision)
- Russ Mundy (Trusted Information Systems) chair
- Shawn Routhier (Epilogue)
- Glenn Waters (Nortel)
- Bert Wijnen (IBM T. J. Watson Research Center)
the Advisory Team and the SNMPv3 Working Group Charter both wanted the design to borrow as much as practical from previous RFCs and drafts, so big thanks to the authors of the earlier designs called SNMPv2u and SNMPv2* 🙌
- Jeff Case (SNMP Research, Inc.)
- David Harrington (Cabletron Systems Inc.)
- David Levi (SNMP Research, Inc.)
- Keith McCloghrie (Cisco Systems)
- Brian O'Keefe (Hewlett Packard)
- Marshall T. Rose (Dover Beach Consulting)
- Jon Saperia (BGS Systems Inc.)
- Steve Waldbusser (International Network Services)
- Glenn W. Waters (Bell-Northern Research Ltd.)
8. Security Considerations 🔐
okay this section is serious, bestie, so pay attention 😭 this doc explains how an implementation can include a Security Model to protect management messages, and an Access Control Model to control access to management info. 🔥
how much security you actually get depends entirely on which Security Model and which Access Control Model implementation(s) you're using. 🧠
applications can reach data that isn't secured. they should take reasonable steps to protect that data from disclosure. 🛡️
⚠️ the purchaser of an implementation is the one responsible for making sure that:
- an implementation follows the rules this architecture defines,
- the Security and Access Control Models being used actually meet the security and access control needs of the organization,
- the implementations of the Models and Applications follow the model and application specifications,
- and the implementation protects configuration secrets from inadvertent disclosure. 🔒
9. References 📚
[RFC1155] Rose, M. and K. McCloghrie, "Structure and Identification of Management Information for TCP/IP-based internets", STD 16, RFC 1155, May 1990.
[RFC1157] Case, J., Fedor, M., Schoffstall, M. and J. Davin, "The Simple Network Management Protocol", STD 15, RFC 1157, May 1990.
[RFC1212] Rose, M. and K. McCloghrie, "Concise MIB Definitions", STD 16, RFC 1212, March 1991.
[RFC1901] Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Introduction to Community-based SNMPv2", RFC 1901, January 1996.
[RFC1902] Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Structure of Management Information for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1902, January 1996.
[RFC1905] Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Protocol Operations for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1905, January 1996.
[RFC1906] Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Transport Mappings for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1906, January 1996.
[RFC1907] Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Management Information Base for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1907 January 1996.
[RFC1908] Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Coexistence between Version 1 and Version 2 of the Internet-standard Network Management Framework", RFC 1908, January 1996.
[RFC1909] McCloghrie, K., Editor, "An Administrative Infrastructure for SNMPv2", RFC 1909, February 1996.
[RFC1910] Waters, G., Editor, "User-based Security Model for SNMPv2", RFC 1910, February 1996.
[RFC2028] Hovey, R. and S. Bradner, "The Organizations Involved in the IETF Standards Process", BCP 11, RFC 2028, October 1996.
[RFC2044] Yergeau, F., "UTF-8, a transformation format of Unicode and ISO 10646", RFC 2044, October 1996.
[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997.
[RFC2262] Case, J., Harrington, D., Presuhn, R., and B. Wijnen, "Message Processing and Dispatching for the Simple Network Management Protocol (SNMP)", RFC 2262, January 1998.
[RFC2264] Blumenthal, U., and B. Wijnen, "The User-Based Security Model for Version 3 of the Simple Network Management Protocol (SNMPv3)", RFC 2264, January 1998.
[RFC2265] Wijnen, B., Presuhn, R., and K. McCloghrie, "View-based Access Control Model for the Simple Network Management Protocol (SNMP)", RFC 2265, January 1998.
[RFC2263] Levi, D., Meyer, P., and B. Stewart, "SNMPv3 Applications", RFC 2263, January 1998.
10. Editors' Addresses 📬
the editors, with their contact details, are below 💖
Bert Wijnen
IBM T.J. Watson Research
Schagen 33
3461 GL Linschoten
Netherlands
Phone: +31 348-432-794
EMail: wijnen@vnet.ibm.comDave Harrington
Cabletron Systems, Inc
Post Office Box 5005
Mail Stop: Durham
35 Industrial Way
Rochester, NH 03867-5005
USA
Phone: +1 603-337-7357
EMail: dbh@ctron.comRandy Presuhn
BMC Software, Inc.
1190 Saratoga Avenue
Suite 130
San Jose, CA 95129
USA
Phone: +1 408-556-0720
EMail: rpresuhn@bmc.comAPPENDIX A: A. Guidelines for Model Designers 🧚
this appendix is the guide for designers of models that are expected to fit into the architecture in this document ✨
SNMPv1 and SNMPv2c are two SNMP frameworks that use communities to provide trivial authentication and access control. SNMPv1 and SNMPv2c Frameworks can coexist with Frameworks designed according to this architecture, and modified versions of SNMPv1 and SNMPv2c Frameworks could be designed to meet the requirements of this architecture, but this document does not provide guidelines for that coexistence. 🤷♀️
within any subsystem model, there should be no reference to any specific model of another subsystem, or to data defined by a specific model of another subsystem. 🙅♀️
transfer of data between the subsystems is deliberately described as a fixed set of abstract data elements and primitive functions, which can be overloaded to satisfy the needs of multiple model definitions. 🎀
documents that define models for this architecture SHOULD use the standard primitives between subsystems, possibly defining specific mechanisms for converting the abstract data elements into model-usable formats. this constraint exists so subsystem and model docs can be written with the common borders of the subsystem and model in mind. vendors aren't constrained to recognize these borders in their implementations, so that's their call 💅
the architecture defines certain standard services to be provided between subsystems, and it defines abstract service interfaces for requesting those services. 🦋
each model definition for a subsystem SHOULD support the standard service interfaces, but whether, or how, or how well, it performs the service depends on the model definition. 💜
A.1. Security Model Design Requirements 🔒
A.1.1. Threats
a document describing a Security Model MUST describe how the model protects against the threats described under "Security Requirements of this Architecture", section 1.4. 🛡️
A.1.2. Security Processing ✨
Okay bestie, first things first: every received message MUST be validated by a Model of the Security Subsystem 🔐. Validation covers authentication and privacy processing if needed, but it's explicitly allowed to send messages that don't need authentication or privacy 💅.
A received message carries a specified securityLevel that gets used during processing. Also, all messages requiring privacy MUST also require authentication. No privacy without auth, periodt 🙅♀️.
A Security Model spells out the rules for how authentication and privacy get done. A model can define extra security features, but it's constrained to using (possibly a subset of) the abstract data elements defined in this document for passing data between subsystems 🧩.
Each Security Model can allow multiple security protocols to be used concurrently within one implementation of the model 🌈. Each Security Model defines how to decide which protocol to use, given the securityLevel and the security parameters relevant to the message. Each Security Model, together with its protocol(s), defines how the sending and receiving entities are identified, and how secrets are configured 🔑.
Authentication and Privacy protocols supported by Security Models are uniquely identified using Object Identifiers 🆔. IETF standard protocols for authentication or privacy should have an identifier defined within the snmpAuthProtocols or the snmpPrivProtocols subtrees. Enterprise specific protocol identifiers should be defined within the enterprise subtree 🌸.
For privacy, the Security Model defines what portion of the message is encrypted 🙈.
The persistent data used for security should be SNMP-manageable, but the Security Model defines whether an instantiation of the MIB is a conformance requirement 📚.
Security Models are replaceable within the Security Subsystem 🦋. Multiple Security Model implementations may exist concurrently within an SNMP engine. The number of Security Models defined by the SNMP community should remain small to promote interoperability 🫶.
A.1.3. Validate the security-stamp in a received message ✨
A Message Processing Model asks a Security Model to:
- verify that the message has not been altered,
- authenticate the identification of the principal for whom the message was generated.
- decrypt the message if it was encrypted.
Additional requirements may be defined by the model, and additional services may be provided by the model. But the model is constrained to use the following primitives for transferring data between subsystems. Implementations are not so constrained 🧠.
A Message Processing Model uses the processMsg primitive as described in section 4.5 📨.
A.1.4. Security MIBs ✨
Each Security Model defines the MIB module(s) required for security processing, including any MIB module(s) required for the security protocol(s) supported. The MIB module(s) SHOULD be defined concurrently with the procedures which use the MIB module(s). The MIB module(s) are subject to normal access control rules 🛡️.
The mapping between the model-dependent security ID and the securityName MUST be able to be determined using SNMP, if the model-dependent MIB is instantiated and if access control policy allows access 🗺️.
A.1.5. Cached Security Data ✨
For each message received, the Security Model caches the state information so a Response message can be generated using the same security information. This works even if the Local Configuration Datastore is altered between the time of the incoming request and the outgoing response 💾.
A Message Processing Model is responsible for explicitly releasing the cached data if it's no longer needed. To make this possible, an abstract securityStateReference data element is passed from the Security Model to the Message Processing Model 🎁.
The cached security data may be implicitly released by generating a response, or explicitly released by using the stateRelease primitive, as described in section 4.1 🧹.
A.2. Message Processing Model Design Requirements 🌷
An SNMP engine contains a Message Processing Subsystem, which may contain multiple Message Processing Models 🍓.
The Message Processing Model MUST always (conceptually) pass the complete PDU. In other words, it never forwards less than the complete list of varBinds 📦.
A.2.1. Receiving an SNMP Message from the Network ✨
Upon receipt of a message from the network, the Dispatcher in the SNMP engine determines the version of the SNMP message, and interacts with the corresponding Message Processing Model to determine the abstract data elements 📬.
A Message Processing Model specifies the SNMP Message format it supports, and describes how to determine the values of the abstract data elements (like msgID, msgMaxSize, msgFlags, msgSecurityParameters, securityModel, securityLevel etc). A Message Processing Model interacts with a Security Model to provide security processing for the message using the processMsg primitive, as described in section 4.5 🔍.
A.2.2. Sending an SNMP Message to the Network ✨
The Dispatcher in the SNMP engine interacts with a Message Processing Model to prepare an outgoing message. For that it uses the following primitives:
- for requests and notifications:
prepareOutgoingMessage, as described in section 4.4 - for response messages:
prepareResponseMessage, as described in section 4.4
A Message Processing Model, when preparing an Outgoing SNMP Message, interacts with a Security Model to secure the message. For that it uses the following primitives:
- for requests and notifications:
generateRequestMsg, as described in section 4.5. - for response messages:
generateResponseMsgas described in section 4.5.
Once the SNMP message is prepared by a Message Processing Model, the Dispatcher sends the message to the desired address using the appropriate transport 🚀.
A.3. Application Design Requirements 💫
Within an application, there may be an explicit binding to a specific SNMP message version (a specific Message Processing Model) and to a specific Access Control Model. But there should be no reference to any data defined by a specific Message Processing Model or Access Control Model 🙅♀️.
Within an application, there should be no reference to any specific Security Model, or to any data defined by a specific Security Model 🔒.
An application determines whether explicit or implicit access control should be applied to the operation. If access control is needed, it also determines which Access Control Model should be used 🗝️.
An application has the responsibility to define any MIB module(s) used to provide application-specific services 🧁.
Applications interact with the SNMP engine to initiate messages, receive responses, receive asynchronous messages, and send responses 📤.
A.3.1. Applications that Initiate Messages ✨
Applications may ask the SNMP engine to send messages containing SNMP commands or notifications, using the sendPdu primitive as described in section 4.2 🏹.
If it's desired that a message be sent to multiple targets, it's the application's responsibility to provide the iteration 🔁.
The SNMP engine assumes necessary access control has been applied to the PDU, and provides no access control services 🤷♀️.
The SNMP engine looks at the "expectResponse" parameter. If a response is expected, the appropriate information is cached so a later response can be associated with this message, and then returned to the application. A sendPduHandle is returned to the application so it can later match the response with this message as well 🎟️.
A.3.2. Applications that Receive Responses ✨
The SNMP engine matches incoming response messages to outstanding messages sent by this SNMP engine. It then forwards the response to the associated application using the processResponsePdu primitive, as described in section 4.2 📩.
A.3.3. Applications that Receive Asynchronous Messages ✨
When an SNMP engine receives a message that is not the response to a request from this SNMP engine, it must determine which application the message should be given to 🕵️♀️.
An Application that wishes to receive asynchronous messages registers itself with the engine using the registerContextEngineID primitive, as described in section 4.2 📝.
An Application that wishes to stop receiving asynchronous messages should unregister itself with the SNMP engine using the unregisterContextEngineID primitive, as described in section 4.2 👋.
Only one registration per combination of PDU type and contextEngineID is permitted at the same time. Duplicate registrations are ignored. An errorIndication will be returned to the application that attempts to duplicate a registration ⚠️.
All asynchronously received messages containing a registered combination of PDU type and contextEngineID are sent to the application which registered to support that combination 💌.
The engine forwards the PDU to the registered application, using the processPdu primitive, as described in section 4.2 🚚.
A.3.4. Applications that Send Responses ✨
Request operations require responses. An application sends a response via the returnResponsePdu primitive, as described in section 4.2 💖.
The contextEngineID, contextName, securityModel, securityName, securityLevel, and stateReference parameters come from the initial processPdu primitive. The PDU and statusInformation are the results of processing 🎀.
A.4. Access Control Model Design Requirements 🧚
An Access Control Model determines whether the specified securityName is allowed to perform the requested operation on a specified managed object. The Access Control Model specifies the rules by which access control is determined 🚧.
The persistent data used for access control should be manageable using SNMP, but the Access Control Model defines whether an instantiation of the MIB is a conformance requirement 📖.
The Access Control Model must provide the primitive isAccessAllowed 🔑.
B. Full Copyright Statement 💜
The legal bits, kept in full because they matter 🙏:
Copyright (C) The Internet Society (1997). All Rights Reserved.
This document and translations of it may be copied and furnished to others, and derivative works that comment on or otherwise explain it or assist in its implementation may be prepared, copied, published and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this paragraph are included on all such copies and derivative works. However, this document itself may not be modified in any way, such as by removing the copyright notice or references to the Internet Society or other Internet organizations, except as needed for the purpose of developing Internet standards in which case the procedures for copyrights defined in the Internet Standards process must be followed, or as required to translate it into languages other than English.
The limited permissions granted above are perpetual and will not be revoked by the Internet Society or its successors or assigns.
This document and the information contained herein is provided on an "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 🫶✨
📦 where this page comes from
- ietf: rfc2261 1998-01
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms