draft-ietf-snmpv3-next-gen-arch-02.txt   draft-ietf-snmpv3-next-gen-arch-03.txt 
stracts.txt'' listing contained in the Internet- Drafts Shadow
An Architecture for Describing
Internet Management Frameworks
D. Harrington
Cabletron Systems, Inc.
dbh@cabletron.com
B. Wijnen
IBM T.J. Watson Research
wijnen@vnet.ibm.com
<draft-ietf-snmpv3-next-gen-arch-02.txt>
Status of this Memo
This document is an Internet-Draft. Internet-Drafts are working
documents of the Internet Engineering Task Force (IETF), its areas,
and its working groups. Note that other groups may also distribute
working documents as Internet-Drafts.
Internet-Drafts are draft documents valid for a maximum of six months
and may be updated, replaced, or obsoleted by other documents at any
time. It is inappropriate to use Internet- Drafts as reference material
or to cite them other than as ``work in progress.''
To learn the current status of any Internet-Draft, please check the
``1id-abstracts.txt'' listing contained in the Internet- Drafts Shadow
Directories on ds.internic.net (US East Coast), nic.nordu.net (Europe), Directories on ds.internic.net (US East Coast), nic.nordu.net (Europe),
ftp.isi.edu (US West Coast), or munnari.oz.au (Pacific Rim). ftp.isi.edu (US West Coast), or munnari.oz.au (Pacific Rim).
Abstract Abstract
This document describes an architecture for describing Internet This document describes an architecture for describing Internet
Management Frameworks. The architecture is designed to be modular Management Frameworks. The architecture is designed to be modular
to allow the evolution of the protocol over time. The major portions to allow the evolution of the protocol over time. The major portions
of the architecture are a messaging engine containing a message of the architecture are an SNMP engine containing a Message Processing
processing and control subsystem and a security subsystem, plus a subsystem, a Security Subsystem and an Access Control Subsystem, and
data processing engine, called a context engine, which contains an possibly multiple SNMP applications which provide specific functional
access control subsystem, a MIB access subsystem, and possibly processing of network management data. These SNMP applications are
multiple orangelets which provide specific functional processing of various types, including Command Generator and Command Responder
of network management data. applications, Notification Originator and Notification Receiver
applications, and Proxy Forwarding applications.
Harrington/Wijnen Expires December 1977 [Page 1]
Harrington/Wijnen Expires December 1977 [Page 2] Harrington/Wijnen Expires December 1997 [Page 1]
\
0. Issues 0. Issues
0.1. Issues to be resolved 0.1. Issues to be resolved
. Need the "readable" introduction supplement . OID or Integer for auth/priv protocol identifiers
. taxonomy: second interim meeting reached consensus on OIDs
orangelets some mailing list members still say Integers preferred
. should the scopedPDU be contained in the securityParameters . forward references need to be handled
SEQUENCE, so encryption can include the PDU and some of the . Is Glossary needed to describe primitive parameters, or is the
security parameters? expanded template adequate for this purpose?
. Who counts SNMP messages? who counts snmpv3 messages? . state_reference releases - are these consistently defined?
. reportPDUs created from an error status or OID returned by the appropriate check documents.
subsystem/model? . discuss utf8. - probably open WG discussion in Munich per NMAD
. foward refreences need to be handled discuss tomorrow; remains open issue.
. some TCs were defined for interface parameters, but aren't part of a mIB. . need mechanism to discover securityModels supported
move to Glossary? . new SnmpEngineID format rules to be discussed yet.
. Is AdminString appropriate for all strings, such as securityidentifier and . needs changes to meet STDGUIDE guidelines
context and group? These had different sizes and semantics. . add a "Decision History" section (as an appendix?)
. AdminString has size (1..255); what about default context of ""? . we punted snmpEngineMaxMessageSize at 2nd interim because that
. snmpEngineMaxMessageSize maximum size? 65507? what about non-UDP transports? info travels in each SNMPv3 message. However, we may want to
. description of max message size re-introduce it so that SNMPv1/v2c managers can learn the value!!
. definitioon/description of MD5/DES protocol OIDs.
. should the tree for registering protocols be in basicGroup? 0.1.1. Issues discussed at second Interim Meeting:
. should User-based be in basicgroup conformance?
. how does MPC match incoming requests with outgoing responses? . A "readable" introduction supplement may be done after Munich.
. generateRequestMessage( globalData, scopedPDU, MIID, engineID ) . Applications are responsible for retries, but implementations may
why do we need engineID? isn't that implicit? differ.
. I rearranged primitive parameters: transport/engine/contextEngine/PDU . TCs should not be defined just to describe primitive parameters.
. state_refernce releases - are these consistently defined? If they cannot be described adequately in text, they can be defined
. should the MPC release the state_reference when it receives a response? in a Glossary. Avoid describing implementation details.
. How is duplicate registration handled? error or ignore? . Is SnmpAdminString appropriate for all strings, such as
securityIdentifier and context and group? These had different
sizes and semantics. size and semantics may be defined in
syntax and description of OBJECT
. AdminString has size (0..255); revisit for utf8 discussions
. securityModel #s - 00 for IETF standards; from v2* documents
. protocol IDs - integer or OID? voted 13-0 for OID.
. uniqueness of securityName
. mapping between principal and securityName is outside scope of WG.
. principals may have more than one securityName in an entity
. mappings may exist between many types of MDID and a single
securityName
. mappings may exist between different (model, Name) and the same
securityName by varying the model or the Name.
. the securityName and a MDID may be identical. This can be defined
by the Security Model.
(user,"public") may map to securityName "public"
. [securityName, securityModel] yields zero or one MDName, with
exceptions for backwards compatibility. The exception is defined
by the model, and the problems are the province of the model to
resolve.
Harrington/Wijnen Expires December 1997 [Page 2]
\
0.2. Change Log 0.2. Change Log
[version 4.4]
. Fixed one error in the MIB (found with SMICng)
. Reformatted text for SnmpAdminString, no change in text.
. Changed text for SnmpEngineID.. this is still under discussion.
But this new text seems to be getting close to what we want.
. Added an issue w.r.t. snmpEngineMaxMessageSize
. adapt Primitive names and parameters to very latest (july 11) names
. removed blank lines before the .p page controls.
[version 4.3]
. some minor editing adjustments
[version 4.2]
. modify abstract so there is no requirement for one entity
to contain both a command generator and a notification receiver.
. modify Introduction list of entities which are meant to be
supported
. reorganized sections 1 through 4 for more consistency in contents.
. described section contents in Introduction:Target Audience
. move documentation descriptions to section 2
. rewrite section 4 to be more like a real elements of procedure.
. modified SnmpSecurityModel and SnmpEngineID definitions
. replaced MIB with Bert's replacement
. added Randy's TC for SnmpAdminString
. modified the example algorithm text for SnmpEngineID
. rewrote security considerations for brevity.
. modified "context" description
. moved "Threats" to Goals/Requirements
. eliminated snmpEngineMaxMessageSize object
. posted to snmpv3 (by DBH)
[version 4.1]
. Adopt "abstract" to new terminology
. Addressed all comments I (BW) made to DBH in an earlier email
. Changed Introduction section to new terminology
. changed wording for "implementation" to indicate it may contain
multiple models.
. Section 2. Started some wording on Goals and Design decisions
. Added the overview picture of a traditional agent and a
traditional manager. This is in section 2.
. Changed overview figure in section 3. to address the comments
by Dave Levi. It now lists the type of applications
. At various places ensure that text (easily) fits within 72
columns as required by RFC-editors Guidelines document.
. Section 2.3 (new section) has the documents set overview.
I verified the claims about standards. Not sure I worded the
SNMPv2 std correctly,. We'll hear it if we did it wrong.
. Section 2.4 (new section) gives overview of SNMP entities based
on modified Dave Levi figure. I (Bert) wonder however if it would
Harrington/Wijnen Expires December 1997 [Page 3]
\
not be better to move it to after section 3.1.13
. Section 3. Added more figures... please let us know if you find
then useful and/or helpful. We could also move these back to
section 2 if such makes more sense.
. Added a picture in section 3.2.
It also shows some of access control, so not sure it really fits
here, although it does map principal to model dependent security
ID to securityName
. Replace "<" with "is lower than" in section 3.4.3 which seems
better in a text document.
. Renamed section 4.1 to "SNMP engine processing" instead of
"The Message Processing Subsystem" because the transport
mappings, mpc multiplexor and such is done in ARCH document so
it is done "in general in the engine" and it passes a specific
message to a Message Processing Subsystem.
. "bulletized" some stuff in section 4.2 and 4.3.
Dave, this is just how I (Bert) like it better. Feel free to
undo it if you strongly disagree
. Section 4.3 changed "initiate a transaction" to "originate a
notification".
. Inserted title line for section 4.4 (I think it was missing)
I have named it "Information Model" in accordance with the change
I made (after Russ's comments) in the document figure to lump SMI,
TC and Conformance together.
. Inserted a title for section 4.5 named "Operational Model" to
get in sync with the the lumping together of ProtoOps and Transport
Mappings in document overview
. Renumber section 4.4.4 to 4,5,1 and added 4.5.2 to follow the
document overview figure. If we really want to follow it, then
maybe we should also reorder some of these sections. Like
Access Control seems specifically misplaced. So I decided to move
it before applications as section 4.3, so the 4.x above should
all be read as 4.x+1
. Removed size from SnmpEngineID TC... why did you limit it to
(0..2048). Did we not decide to leave it open?
. Should we not remove snmpEngineMaxMessageSize from the MIB.
That was agreed at 2nd interim. It travels in every message and so
seems to be useless. However, I think it could indeed still help
SNMPv1 or SNMPv2c managers.
. I kept your definitions of registration-points for auth and priv
protocols, but my recollection is that they would be completely
removed from ARCH and that it would all be done in SEC document.
. Modified Security Considerations. Was still talking about LPM.
. Appendix. I am still wondering if we need to use capitals for
things like "Security Model" "Subsystem" and such. This is only
an appendix... but we better be consistent, no? Anyway
I changed it so it is consistent (at least I tried).
. Appendix, renamed imf to snmpFramework
. Appendix, changed state_reference and state_release to
stateReference and stateRelease to be consistent with other names
for abstract data and primitives.
Harrington/Wijnen Expires December 1997 [Page 4]
\
. A.2 changed MessageEngine to SNMP engine
. Fixed ASI primitives to be in sync with SEC document.
I also thought that our ARCH document-outline wanted to at least
have the primitives listed within the main body of the text, no?
. Adapted send_pdu to sendPdu primitive as reconciled by Randy
In fact I made sure all primitives are in-line with current
agreement on names and parameters.
. Rename title of A.2.4 and A.2.5 so it fits on 1 line in contents
. I did not look at appendix B. That is your (DBH) specialty is it
not ? ;-).
. Quick simple spell check done with "spell" on AIX
[version 4.0]
. move section 7 - Model Requirements to an appendix
. move Section 3 - Design Goals to an appendix
. modified Section 5 - Naming
. remove "possibly multiple"
. moved Section 5 to Section 3
. change orangelets to applications
. modify description of applications
. change scopedPDU-MMS and PDU-MMS to maxSizeResponseScopedPDU
. change Scoped-PDU and ScopedPDU to scopedPDU (no dash, lower case S)
. change imfxxx to snmpFrameworkxxx
. change security-entity to principal
. change securityIdentity to securityName
. change MIID to securityName
. eliminate all reference to groupName or group
. LoS ordering noAuthNoPriv < authNoPriv < authPriv
. Los TC naming - noAuthNoPriv(1), authNoPriv(2), authPriv(3)
. remove TCs not used in MIBs - securityIdentity TC etc
. changed Message Processing and Control to Message Processing
. changed future tense to present tense
. eliminate messageEngine
. added/updated primitives
. addressed issues raised on the mailing list
[version 3.1] [version 3.1]
. change securityIdentity to MIID . change securityIdentity to MIID
. write text to explain the differences between security-identities, . write text to explain the differences between security-identities,
model-dependent identifiers, and model-independent identifiers. model-dependent identifiers, and model-independent identifiers.
. write text to explain distinction within the LCD of the security . write text to explain distinction within the LCD of the security
data, the access control data, and the oranglet data. data, the access control data, and the orangelet data.
. identify issues . identify issues
. publish as <draft-ietf-snmpv3-next-gen-arch-02.txt> . publish as <draft-ietf-snmpv3-next-gen-arch-02.txt>
[version 3.0] [version 3.0]
. add section on threats for message security . add section on threats for message security
. add section on threats for access control . add section on threats for access control
. change application to orangelet . change application to orangelet
. remove references to F-Ts . remove references to F-Ts
. change securityIdentity to security-identity . change securityIdentity to security-identity
Harrington/Wijnen Expires December 1997 [Page 5]
\
. change securityCookie to securityIdentity . change securityCookie to securityIdentity
. the format of securityIdentity is defined by the model . the format of securityIdentity is defined by the model
. add securityModel to passed parameters as needed . add securityModel to passed parameters as needed
Harrington/Wijnen Expires December 1977 [Page 3]
. eliminate group from passed parameters . eliminate group from passed parameters
. remove unused IMPORTS . remove unused IMPORTS
. add glossary section with initial set of words to define . add glossary section with initial set of words to define
. differentiate the messageEngine from the contextEngine . differentiate the messageEngine from the contextEngine
. eliminate the term SNMPng . eliminate the term SNMPng
. rewrote 1.1. A Note on Terminology . rewrote 1.1. A Note on Terminology
. eliminated assumptions about SNMP processing always being . eliminated assumptions about SNMP processing always being
message related message related
. rewrote 4.x to reflect new thinking . rewrote 4.x to reflect new thinking
. rewrote 5.x to reflect new thinking . rewrote 5.x to reflect new thinking
. rewrote 6.x (the MIB) to reflect new thinking . rewrote 6.x (the MIB) to reflect new thinking
. added MIB objects at this level (previously only T-Cs) . added MIB objects at this level (previously only TCs)
. rewrote 7.x . rewrote 7.x
. sent to v3edit list . sent to v3edit list
Harrington/Wijnen Expires December 1977 [Page 4] Harrington/Wijnen Expires December 1997 [Page 6]
\
1. Introduction 1. Introduction
A management system contains: several (potentially many) nodes, each 1.1. Target Audience
with a processing entity, termed an agent, which has access to
management instrumentation; at least one management station; and, a
management protocol, used to convey management information between the
agents and management stations, or between management stations and
other management stations.
Management stations execute management applications which monitor and This document will have as its audience persons with varying levels
control managed elements. Managed elements are devices such as hosts, of technical understanding of SNMP.
routers, terminal servers, etc., which are monitored and controlled via
access to their management information. This document does not provide a general introduction to SNMP. Other
documents and books can provide a much better introduction to SNMP.
Nor does this document provide a history of SNMP. That also can be
found in books and other documents.
This document does define a vocabulary for describing Internet
Management Frameworks, and an architecture for describing the
major portions of Internet Management Frameworks.
Section 1 describes the purpose, goals, and design decisions of
the architecture.
Section 2 describes various types of documents which define Internet
Frameworks, and how they fit into this architecture. It also provides
a minimal roadmap to the documents which have defined previous
SNMP frameworks.
Section 3 details the vocabulary of this architecture and its pieces.
This section is important for understanding the remaining sections,
and for understanding documents which are written to fit within this
architecture.
Section 4 describes the elements of procedure followed by an SNMP
engine in coordinating the processing of messages by the subsystems
of the engine and by applications.
Section 5 defines a collection of managed objects used to instrument
SNMP engines within this architecture.
Sections 6, 7, 8, and 9 are administrative in nature.
Appendix A contains guidelines for developers of Models which are
expected to fit within this architecture.
Appendix B contains a discussion of software design principles which
guided the development of this architecture. Many books provide a
more in-depth discussion of these topics.
1.2. Management Systems
A management system contains:
- several (potentially many) nodes, each with an SNMP entity
containing command responder and notification originator
applications, which have access to management instrumentation;
Harrington/Wijnen Expires December 1997 [Page 7]
\
- at least one SNMP entity containing command generator and/or
notification receiver applications; and,
- a management protocol, used to convey management information
between the SNMP entities.
SNMP entities executing command generator and notification receiver
applications monitor and control managed elements. Managed elements
are devices such as hosts, routers, terminal servers, etc., which
are monitored and controlled via access to their management
information.
Operations of the protocol are carried out under an administrative Operations of the protocol are carried out under an administrative
framework which defines minimum requirements for standard services, framework which defines minimum requirements for standard services,
such as sending and receiving messages, countering security threats to such as sending and receiving messages, countering security threats
messages, controlling access to managed objects, and processing various to messages, controlling access to managed objects, and processing
types of requests. various types of requests.
It is the purpose of this document to define an architecture which It is the purpose of this document to define an architecture which
can evolve to realize effective network management in a variety can evolve to realize effective network management in a variety
of configurations and environments. The architecture has been of configurations and environments. The architecture has been
designed to meet the needs of implementors of minimal agents, command designed to meet the needs of implementations of:
line driven managers, mid-level managers, and full-function network - minimal SNMP entities with command responder and/or notification
enterprise management stations. originator applications (traditionally called SNMP agents),
- SNMP entities with proxy forwarder applications (traditionally
called SNMP proxy agent),
- 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 enterprise management stations).
1.1. A Note on Terminology 1.3. Goals of this Architecture
This architecture was driven by the following goals:
- 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.
Harrington/Wijnen Expires December 1997 [Page 8]
\
- Keep SNMP as simple as possible.
- Make it relatively inexpensive to deploy a minimal conformant
implementation
- Make it possible to upgrade portions of a framework as new
approaches become available, without disrupting the entire
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
Several of the classical threats to network protocols are applicable
to the network management problem and therefore would be applicable
to any Security Model used in an Internet Management Framework. Other
threats are not applicable to the network management problem. This
section discusses principal threats, secondary threats, and threats
which are of lesser importance.
The principal threats against which any Security Model used within
this architecture SHOULD provide protection 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.
Harrington/Wijnen Expires December 1997 [Page 9]
\
There are at least two threats against which a Security Model used by
a framework within this architecture need not protect.
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 network 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
Various designs decision were made in support of these goals:
- Architecture
An architecture should be defined which identifies the
conceptual boundaries between the documents of a framework.
Subsystems should be defined which describe the abstract
services provided by specific portions of the 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 a framework.
- Self-contained Documents
Elements of procedure plus the MIB objects which are needed for
processing for a specific portion of a framework should be
defined in the same document, and as much as possible, should
not be referenced in other documents. This allows various
pieces of SNMP Frameworks 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 the
framework 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.
- 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 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
The following figure shows the set of documents that fit within the
SNMP Architecture.
Document Set
+--------------------------------------------------------------------+
| |
| +------------+ +-----------------+ +----------------+ |
| | * | | * | | * | |
| | Document | | Applicability | | Coexistence | |
| | Roadmap | | Statement | | & Transition | |
| +------------+ +-----------------+ +----------------+ |
| |
| +-------------------+ +-----------------------------------------+ |
| | Operational Model | | Security and Administration | |
| | | | | |
| | +-------------+ | | +------------+ +----------+ +---------+ | |
| | | | | | | | | | | | | |
| | | Protocol | | | | Message | | Security | | Access | | |
| | | Operations | | | | Processing | | | | Control | | |
| | +-------------+ | | +------------+ +----------+ +---------+ | |
| | +-------------+ | | | |
| | | | | | +--------------+ +----------+ | |
| | | Transport | | | | | | | | |
| | | Mappings | | | | Applications | ......... | | | |
| | +-------------+ | | +--------------+ +----------+ | |
| | | | | |
| +-------------------+ +-----------------------------------------+ |
| |
| +----------------------------------------------------------------+ |
| | 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 | | |
| | +-------------+ +-------------+ +----------+ +----------+ | |
| +----------------------------------------------------------------+ |
| |
+--------------------------------------------------------------------+
\
Those marked with an asterisk (*) are expected to be written in the
future. Each of these documents may be replaced or supplemented.
This Architecture document specifically describes how new documents
fit into the set of documents in the Security and Administration area.
2.1. Document Roadmap
One or more documents may be written that will describe how sets
of documents taken together form a specific SNMP framework.
The configuration of document sets might change over time, so the
"roadmap" should be maintained in a document separate from the
standards documents themselves.
2.2. Applicability Statement
SNMP is used in networks that vary widely in size and complexity,
by organizations that vary widely in their requirements of network
management. Some models will be designed to address specific
problems of network management, such as message security.
One or more documents may be written which describe the environments
to which certain versions of SNMP or models within SNMP would be
appropriately applied, and those to which a given model might be
inappropriately applied.
2.3. Coexistence and Transition
The purpose of an evolutionary architecture is to permit new models
to replace or supplement existing models. The interactions between
models could result in incompatibilities, security "holes", and
other undesirable effects.
The purpose of Coexistence documents is to detail recognized anomalies
and to describe required and recommended behaviors for resolving the
interactions between models within the architecture.
It would be very difficult to document all the possible interactions
between a model and all other previously existing models while in the
process of developing a new model.
Coexistence documents are therefore expected to be prepared separately
from model definition documents, to describe and resolve interaction
anomalies between a model definition and one or more other model
definitions.
Additionally, recommendations for transitions between models may
also be described, either in a coexistence document or in a separate
document.
\
2.4. Transport Mappings
SNMP messages are sent over various transports. It is the purpose of
Transport Mapping documents to define how the mapping between SNMP
and the transport is done. A specific implementation of an SNMP engine
defines which transports it supports.
2.5. Message Processing
A Message Processing Model document defines a message format, which is
typically identified by a version field in an SNMP message header.
The document may also define a MIB module for use in message
processing and for instrumentation of version-specific interactions.
An engine will include one or more Message Processing Models, and thus
may support sending and receiving multiple SNMP versions of
messages.
2.6. Security
Some environments require secure protocol interactions. 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 document, "security" refers to message-level
security; "access control" refers to the security applied to protocol
operations.
Authentication, encryption, and timeliness checking are common
functions of message level security.
A security document will describe a Security Model, the threats
against which the model protects, the goals of the Security Model,
the protocols which it uses to meet those goals, and it may define
a MIB module to describe the data used during processing, and to allow
the 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 certain
instrumentation for certain operations. An Access Control Model
determines whether access to an object should be allowed. The
mechanism by which access control is checked is defined by the
Access Control Model.
An Access Control Model document defines the mechanisms used to
\
determine whether access to a managed object should be allowed,
and may define a MIB module used during processing, and to allow
the remote configuration of access control policies.
2.8. Applications
An SNMP entity normally includes a number of applications.
Applications use the services of an SNMP engine to accomplish
specific tasks. They coordinate the processing of management
information operations, and may use SNMP messages to communicate
with other SNMP entities.
Applications documents describe the purpose of an application, the
services required of the associated SNMP engine, and the protocol
operations and informational model that the application uses to
perform network management operations.
An application document defines which set of documents are used to
specifically define the structure of management information, textual
conventions, conformance requirements, and operations supported by
the application.
2.9. Structure of Management Information
Management information is viewed as a collection of managed objects,
residing in a virtual information store, termed the Management
Information Base (MIB). Collections of related objects are defined
in MIB modules.
It is the purpose of a Structure of Management Information document
to establish the syntax for defining objects, modules, and other
elements of managed information.
2.10. Textual Conventions
When designing a MIB module, it is often useful to define new types
similar to those defined in the SMI, but with more precise semantics,
or which have special semantics associated with them. These newly
defined types are termed textual conventions, and may defined in
separate documents, or within a MIB module.
2.11. Conformance Statements
It may be useful to define the acceptable lower-bounds of
implementation, along with the actual level of implementation
achieved. It is the purpose of Conformance Statements to define
the notation used for these purposes.
\
2.12. Protocol Operations
SNMP messages encapsulate an SNMP Protocol Data Unit (PDU). It is the
purpose of a Protocol Operations document to define the operations
of the protocol with respect to the processing of the PDUs.
An application document defines which Protocol Operations documents
are supported by the application.
2.13. Management Information Base Modules
MIB documents describe collections of managed objects which
instrument some aspect of a managed node.
2.13.1. SNMP Instrumentation MIBs
An SNMP MIB document may define a collection of managed objects which
instrument the SNMP protocol itself. In addition, MIB modules may be
defined within the documents which describe portions of the SNMP
architecture, such as the documents for Message processing Models,
Security Models, etc. for the purpose of instrumenting those
Models, and for the purpose of allowing remote configuration of
the Model.
2.14. SNMP Framework Documents
This architecture is designed to allow an orderly evolution of This architecture is designed to allow an orderly evolution of
portions of SNMP Frameworks. portions of SNMP Frameworks.
Throughout the rest of this document, the term "subsystem" will Throughout the rest of this document, the term "subsystem" refers
refer to an abstract and incomplete specification of a portion of to an abstract and incomplete specification of a portion of
a Framework, that will be further refined by a model specification. a Framework, that is further refined by a model specification.
A "model" describes a specific design of a subsystem, defining A "model" describes a specific design of a subsystem, defining
additional constraints and rules for conformance to the model. additional constraints and rules for conformance to the model.
A model is sufficiently detailed to make it possible to implement A model is sufficiently detailed to make it possible to implement
the specification. the specification.
A "implementation" is an instantiation of a subsystem, conforming to a An "implementation" is an instantiation of a subsystem, conforming
specific model. to one or more specific models.
SNMP version 1 (SNMPv1), is the original Internet-standard Network SNMP version 1 (SNMPv1), is the original Internet-standard Network
Management Framework, as described in RFCs 1155, 1157, and 1212. Management Framework, as described in RFCs 1155, 1157, and 1212.
SNMP version 2 (SNMPv2) is an updated design of portions of SNMPv1, SNMP version 2 (SNMPv2) is an updated design of portions of SNMPv1,
as described in RFCs 1902-1908. SNMPv2 has an incomplete message as described in RFCs 1902-1908. SNMPv2 has an incomplete message
definition. definition.
Harrington/Wijnen Expires December 1977 [Page 5]
Community-based SNMP version 2 (SNMPv2c) is an experimental Framework Community-based SNMP version 2 (SNMPv2c) is an experimental Framework
which supplements the incomplete message format of SNMPv2 with which supplements the incomplete message format of SNMPv2 with
portions of the message format of SNMPv1, as described in RFC1901. portions of the message format of SNMPv1, as described in RFC1901.
\
SNMP version 3 (SNMPv3) Framework is a particular configuration of SNMP version 3 (SNMPv3) Framework is a particular configuration of
implemented subsystems, consistent with the architecture described implemented subsystems, consistent with the architecture described
in this document. in this document.
Other SNMP Frameworks, i.e. other configurations of implemented Other SNMP Frameworks, i.e. other configurations of implemented
subsystems, are expected to also be consistent with this architecture. subsystems, are expected to also be consistent with this architecture.
This document does not describe any framework, but describes an This document does not describe any framework, but describes an
architecture into which multiple frameworks may be fitted. architecture into which multiple frameworks may be fitted.
2. Overview \
The architecture presented here emphasizes the use of modularity to 3. Naming
allow the evolution of portions of SNMP without requiring a redesign
of the general architecture of SNMP.
SNMP processing must be performed in consistently ordered steps, which This architecture deals with three kinds of naming:
fall into general categories of similar functionality. This document
will describe major abstractions of functionality required during
SNMP processing, and the abstract interactions between these major
categories of functionality.
This document will describe how this architecture is meant to allow 1) the naming of entities,
modules of functionality corresponding to these abstract categories to 2) the naming of identities, and
be designed to allow the evolution of the whole by modifying discrete 3) the naming of management information.
modules within the architecture.
Harrington/Wijnen Expires December 1977 [Page 6] This architecture also defines some names for other constructs that
are used in the documentation.
3. An Evolutionary Architecture - Design Goals 3.1. The Naming of Entities
The goals of the architectural design are to use encapsulation, The following picture shows detail about an SNMP entity and how
cohesion, hierarchical rules, and loose coupling to reduce complexity components within it are named.
of design and make the evolution of portions of the architecture
possible.
3.1. Encapsulation +--------------------------------------------------------------------+
| |
| SNMP entity |
| |
| +--------------------------------------------------------------+ |
| | | |
| | SNMP engine (identified by snmpEngineID) | |
| | | |
| | +---------------+ +--------------+ +---------------+ | |
| | | | | | | | | |
| | | Message | | Security | | Access | | |
| | | Processing | | Subsystem | | Control | | |
| | | Subsystem | | | | Subsystem | | |
| | | | | | | | | |
| | +---------------+ +--------------+ +---------------+ | |
| | | |
| +--------------------------------------------------------------+ |
| |
| +--------------------------------------------------------------+ |
| | | |
| | Application(s) | |
| | | |
| | +-------------+ +--------------+ +--------------+ | |
| | | Command | | Notification | | Proxy | | |
| | | Generator | | Receiver | | Forwarder | | |
| | +-------------+ +--------------+ +--------------+ | |
| | | |
| | +-------------+ +--------------+ +--------------+ | |
| | | Command | | Notification | | Other | | |
| | | Responder | | Originator | | | | |
| | +-------------+ +--------------+ +--------------+ | |
| | | |
| +--------------------------------------------------------------+ |
| |
+--------------------------------------------------------------------+
Encapsulation describes the practice of hiding the details that are \
used internal to a process. Some data is required for a given
procedure, but isn't needed by any other part of the process.
In networking, the concept of a layered stack reflects this approach. 3.1.1. SNMP entity
The transport layer contains data specific to its processing; the data
is not visible to the other layers. In programming this is reflected
in language elements such as "file static" variables in C, and
"private" in C++, etc.
In this architecture, all data used for processing only within An SNMP entity is an implementation of this architecture. Each such
a functional portion of the architecture should have its visibility SNMP entity consists of an SNMP engine and one or more associated
restricted to that portion if possible. The data should be accessed applications.
only by that functionality defined with the data. No reference to the
data should be made from outside the functional portion of the
architecture, except through predefined public interfaces.
3.2. Cohesion 3.1.2. SNMP engine
Similar functions can be grouped together and their differences An SNMP engine has three subsystems:
ignored, so they can be dealt with as a single entity. It is important
that the functions which are grouped together are actually similar.
Similarity of the data used to perform functions can be a good
indicator of the similarity of the functions.
For example, authentication and encryption are both security functions 1) a Message Processing Subsystem,
which are applied to a message. Access control, while similar in some 2) a Security Subsystem, and
ways, is dissimilar in that it is not applied to a message, it is 3) an Access Control Subsystem.
applied to a (proposed) request for a management operation.
The data required to perform authentication and encryption are
different than the data needed to perform access control, and the
two sets of services can be described independently.
Similar functions, especially those that use the same data elements, 3.1.3. snmpEngineID
should be defined together. The security functions which operate at
the message level should be defined in a document together with the
definitions for those data elements that are used only by those
security functions. For example, a MIB with authentication keys is
used only by authentication functions; they should be defined together.
Harrington/Wijnen Expires December 1977 [Page 7] Within an administrative domain, an snmpEngineID is the unique
and unambiguous identifier of an SNMP engine. Since there is a
one-to-one association between SNMP engines and SNMP entities,
it also uniquely and unambiguously identifies the SNMP entity.
3.3. Hierarchical Rules 3.1.4. Message Processing Subsystem
Functionality can be grouped into hierarchies where each element in the The Message Processing Subsystem is responsible for preparing and
hierarchy receives general characteristics from its direct superior, sending messages, and receiving and distributing messages.
and passes on those characteristics to each of its direct subordinates.
This architecture uses the hierarchical approach by defining The Message Processing Subsystem potentially contains multiple
subsystems, which specify the general rules of a portion of the system, Message Processing Models as shown in the next picture. Those
models which define the specific rules to be followed by an marked with an asterisk (*) may be absent.
implementation of the portion of the system, and implementations which
encode those rules into reality for a portion of the system.
It is expected that within portions of the system, hierarchical +------------------------------------------------------------------+
relationships will be used to compartmentalize, or modularize, the | |
implementation of specific functionality. For example, it is expected | Message Processing Subsystem |
that within the security portion of the system, authentication and | |
privacy will probably be contained in separate modules, and that | +------------+ +------------+ +------------+ +------------+ |
multiple authentication and privacy mechanisms will be supported by | | | | * | | * | | * | |
allowing supplemental modules that provide protocol-specific | | SNMPv3 | | SNMPv1 | | SNMPv2c | | Other | |
authentication and privacy services. | | Message | | Message | | Message | | Message | |
| | Processing | | Processing | | Processing | | Processing | |
| | Model | | Model | | Model | | Model | |
| | | | | | | | | |
| +------------+ +------------+ +------------+ +------------+ |
| |
+------------------------------------------------------------------+
3.4. Coupling 3.1.5. Message Processing Model
Coupling describes the amount of interdependence between parts of Each Message Processing Model defines the format of a particular
a system. Loose coupling indicates that two sub-systems are relatively version of an SNMP message and coordinates the processing of each
independent of each other; tight coupling indicates a high degree of version-specific message.
mutual dependence.
To make it possible to evolve the architecture by replacing only part \
of the system, or by supplementing existing portions with alternate
mechanisms for similar functionality, without obsoleting the complete
system, it is necessary to limit the coupling of the parts.
Encapsulation and cohesion help to reduce coupling by limiting the 3.1.6. Security Subsystem
visibility of those parts that are only needed within portions of a
system. Another mechanism is to constrain the nature of interactions
between various parts of the system.
This can be done by defining fixed, generic, flexible interfaces The Security Subsystem provides security services such as the
for transferring data between the parts of the system. The concept of authentication and privacy of messages and potentially contains
plug-and-play hardware components is based on that type of interface multiple Security Models as shown in the next picture. Those
between the hardware component and system into which it will be marked with an asterisk (*) may be absent.
"plugged."
This approach has been chosen so individual portions of the system +------------------------------------------------------------------+
can be upgraded over time, while keeping the overall system intact. | |
| Security Subsystem |
| |
| +------------+ +-------------------+ +---------------------+ |
| | | | * | | * | |
| | User-Based | | Community-based | | Other | |
| | Security | | Security | | Security | |
| | Model | | Model | | Model | |
| | | | | | | |
| +------------+ +-------------------+ +---------------------+ |
| |
+------------------------------------------------------------------+
To avoid specifying fixed interfaces, which would constrain a vendor's 3.1.7. Security Model
choice of implementation strategies, a set of abstract data elements
is used for (conceptually) transferring data between subsystems in
documents which describe subsystem or model interactions. Documents
Harrington/Wijnen Expires December 1977 [Page 8] A Security Model defines the threats against which it protects,
the goals of its services, and the security protocols used to provide
security services such as authentication and privacy.
describing the interaction of subsystems or models should use only 3.1.8. Security Protocol
the abstract data elements provided for transferring data but vendors
are not constrained to using the described data elements for
transferring data between portions of their implementation.
Loose coupling works well with the IETF standards process. If we A Security Protocol defines the mechanisms, procedures, and MIB
separate message-handling from security and from local processing, data used to provide a security service such as authentication
then the separate portions of the system can move through the standards or privacy.
process with less dependence on the status of the other portions of the
standard. Security models may be able to be re-opened for discussion
due to patents, new research, export laws, etc., as is clearly expected
by the WG, without needing to reopen the documents which detail the
message format or the local processing of PDUs. Thus, the standards
track status of related, but independent, documents is not affected.
Harrington/Wijnen Expires December 1977 [Page 9] \
4. Abstract Functionality 3.1.9. Access Control Subsystem
DBH: {ref: Get-Request, PDU, authentication, encryption, timeliness, The Access Control Subsystem provides authorization services by
managed objects, proxy, } means of one or more Access Control Models.
The architecture described here contains four subsystems, each +------------------------------------------------------------------+
capable of being defined as one or more different models which may | |
be replaced or supplemented as the growing needs of network management | Access Control Subsystem |
require. The subsystems are a Message Processing and Control | |
subsystem, a Security subsystem, an Orangelet subsystem, and an | +------------+ +-------------------+ +---------------------+ |
Access Control subsystem. | | | | * | | * | |
| | View-Based | | Community | | Other | |
| | Access | | Access | | Access | |
| | Control | | Control | | Control | |
| | Model | | Model | | Model | |
| | | | | | | |
| +------------+ +-------------------+ +---------------------+ |
| |
+------------------------------------------------------------------+
The subsystems are contained in two "engines". 3.1.10. Access Control Model
A messageEngine deals with SNMP messages, and is responsible for An Access Control Model defines a particular access decision function
sending and receiving messages, including having authentication in order to support decisions regarding authorization.
and encryption services applied to the messages, and determining
to which Orangelet the message contents should be delivered.
A contextEngine deals with processing network management operations, 3.1.11. Applications
and contains subsystems for Access Control, MIB access, and
Orangelets which provide specific functional processing.
Depending on the network management service needed, an Orangelet
may use the access control and MIB access subsystems, and may use
SNMP messages to communicate with remote nodes. The network
management service may be requested via the payload of an SNMP
message, or may be requested via a local process.
4.1. The messageEngine There are several types of applications, which include:
The messageEngine interacts with the network using SNMP messages, - command generator,
and with the message processing subsystem and the security subsystem - command responder,
and with orangelets using service interfaces defined within this - notification originator,
architecture. - notification receiver, and
- proxy forwarder.
4.1.1. Transport Mappings These applications make use of the services provided by the Security
and Administration Framework.
SNMP messages are sent to, or received from, the network using 3.1.12. SNMP Agent
transport addresses. It is the responsibility of the messageEngine
to listen at the appropriate local addresses, and to send messages
through the appropriate addresses, consistent with mappings defined
by SNMP Transport Mapping documents, such as RFC1906.
4.1.2. SNMP-Based Message Formats An SNMP entity containing one or more command responder and/or
notification originator applications (along with their associated
SNMP engine) has traditionally been called an SNMP agent.
SNMP messages sent to, or received from, the network use a format 3.1.13. SNMP Manager
defined by a version-specific Message Processing and Control model.
The messageEngine determines to which version-specific model the
message should be given.
The version-specific model interacts with the security subsystem, An SNMP entity containing one or more command generator and/or
notification receiver applications (along with their associated
SNMP engine) has traditionally been called an SNMP manager.
using a service interface defined by this architecture, to procure \
security services to meet the requirements of the version-specific
protocol.
4.1.3. The Interface to Orangelets 3.2. The Naming of Identities
A messageEngine, as a result of the receipt of an SNMP message, may principal <---------------------------------+
initiate a transaction with an Orangelet, such as for an incoming |
request, or an Orangelet may initiate a transaction with a +-------------------------------------|-----+
messageEngine, such as for an outgoing request. The messageEngine | SNMP engine | |
determines to which orangelet a message should be given. | | |
| +-----------------------+ | |
| | Security Model | | |
| | +-------------+ | | |
wire | | | Model | +------------+--+ |
<----------->| Dependent |<-->| | securityName| |
| | | Security ID | +---------------+ |
| | +-------------+ | |
| | | |
| +-----------------------+ |
| |
| |
+-------------------------------------------+
4.1.4. Protocol Instrumentation 3.2.1. Principal
To monitor and manage an SNMP engine, a Management Information Base A principal is the "who" on whose behalf services are provided
for SNMP defines the collection of managed objects which instrument or processing takes place.
the SNMP protocol itself. The messageEngine has the responsibility
for maintaining the instrumentation that is described by the
SNMPv2 MIB module [RFC1907] plus the instrumentation which is
described by the IMFMIB module defined in this document.
A Message Processing and Control model may require support for A principal can be, among other things, an individual acting in
MIB modules related to instrumenting version-specific aspects a particular role; a set of individuals, with each acting in a
of the SNMP protocol. particular role; an application; or a set of applications;
and combinations thereof.
4.2. Security 3.2.2. securityName
Some environments require secure protocol interactions. Security is A securityName is a human readable string representing a principal.
normally applied at two different stages - in the transmission/receipt It has a model independent format, and can be used outside a
of messages, and in the processing of the contents of messages. For particular Security Model.
purposes of this document, "security" refers to message-level security;
"access control" refers to the security applied to protocol operations.
Authentication, encryption, and timeliness checking are common 3.2.3. Model dependent security ID
functions of message level security.
4.3. Orangelets A model dependent security ID is the model specific representation
of a securityName within a particular Security Model.
Orangelets coordinate the processing of management information Model dependent security IDs may or may not be human readable, and
operations. have a model dependent syntax. Examples include community names,
user names, and parties.
This document describes three common types of orangelets The transformation of model dependent security IDs into securityNames
and how they interact within the architecture - 1) an orangelet and vice versa is the responsibility of the relevant Security Model.
may process requests to perform an operation on managed objects,
2) an orangelet may initiate a transaction as the result of a
local event, and 3) an orangelet may act as an intermediary,
forwarding an operation to another network management entity.
Orangelets provide access to MIB information, and coordinate \
the application of access control to management operations.
A discussion of the management information and processing is 3.3. The Naming of Management Information
provided here, but an Orangelet model defines which set of
documents are used to specifically define the structure of management
information, textual conventions, conformance requirements, and
operations supported by the Orangelet.
4.4.1. Structure of Management Information Management information resides at an SNMP entity where a Command
Responder Application has local access to potentially multiple
contexts. Such a Command Responder application uses a contextEngineID
equal to the snmpEngineID of its associated SNMP engine.
Management information is viewed as a collection of managed objects, +--------------------------------------------------------------+
residing in a virtual information store, termed the Management | SNMP entity (identified by snmpEngineID, example: abcd) |
Information Base (MIB). Collections of related objects are defined | |
in MIB modules. | +----------------------------------------------------------+ |
| | SNMP engine (identified by snmpEngineID) | |
| | | |
| | +---------------+ +--------------+ +---------------+ | |
| | | | | | | | | |
| | | Message | | Security | | Access | | |
| | | Processing | | Subsystem | | Control | | |
| | | Subsystem | | | | Subsystem | | |
| | | | | | | | | |
| | +---------------+ +--------------+ +---------------+ | |
| | | |
| +----------------------------------------------------------+ |
| |
| +----------------------------------------------------------+ |
| | Command Responder Application | |
| | (contextEngineID, example: abcd) | |
| | | |
| | example contextNames: | |
| | | |
| | "repeater1" "repeater2" "" (default) | |
| | ----------- ----------- ------------ | |
| | | | | | |
| +-----|-------------------|--------------------|-----------+ |
| | | | |
| +-----|-------------------|--------------------|-----------+ |
| | MIB | instrumentation | | | |
| |-----v------------+ +----v-------------+ +----v-----------| |
| | context | | context | | context | |
| | | | | | | |
| | +--------------+ | | +--------------+ | | +------------+ | |
| | | repeater MIB | | | | repeater MIB | | | | other MIB | | |
| | +--------------+ | | +--------------+ | | +------------+ | |
| | | | | | | |
| | | | | | +------------+ | |
| | | | | | | some MIB | | |
| | | | | | +------------+ | |
| | | | | | | |
+--------------------------------------------------------------+
It is the purpose of a Structure of Management Information \
document to establish the syntax for defining objects, modules, and
other elements of managed information.
An Orangelet model defines which SMI documents are supported 3.3.1. An SNMP Context
by the model.
4.4.2. Textual Conventions An SNMP context, or just "context" for short, is a collection of
management information accessible by an SNMP entity. An item of
management information may exist in more than one context. An SNMP
engine potentially has access to many contexts.
When designing a MIB module, it is often useful to define new types Typically, there are many instances of each managed object type within
similar to those defined in the SMI, but with more precise semantics, a management domain. For simplicity, the method for identifying
or which have special semantics associated with them. These newly instances specified by the MIB module does not allow each instance to
defined types are termed textual conventions. be distinguished amongst the set of all instances within a management
domain; rather, it allows each instance to be identified only within
some scope or "context", where there are multiple such contexts within
the management domain. Often, a context is a physical device, or
perhaps, a logical device, although a context can also encompass
multiple devices, or a subset of a single device, or even a subset of
multiple devices, but a context is always defined as a subset of a
single SNMP entity. Thus, in order to identify an individual item of
management information within the management domain, its contextName
and contextEngineID must be identified in addition to its object type
and its instance.
An Orangelet model defines which Textual Conventions documents For example, the managed object type ifDescr [RFC1573], is defined as
are supported by the model. the description of a network interface. To identify the description
of device-X's first network interface, four pieces of information are
needed: the snmpEngineID of the SNMP entity which provides access to
device-X, the contextName (device-X), the managed object type
(ifDescr), and the instance ("1").
4.4.3. Conformance Statements Each context has (at least) one unique identification within the
management domain. The same item of management information can exist
in multiple contexts. So, an item of management information can have
multiple unique identifications, either because it exists in multiple
contexts, and/or because each such context has multiple unique
identifications.
It may be useful to define the acceptable lower-bounds of The combination of a contextEngineID and a contextName unambiguously
implementation, along with the actual level of implementation identifies a context within an administrative domain.
achieved. It is the purpose of Conformance Statements to define
the notation used for these purposes.
An Orangelet model defines which Conformance Statement documents 3.3.2. contextEngineID
are supported by the model.
4.4.4. Protocol Operations Within an administrative domain, a contextEngineID uniquely
identifies an SNMP entity that may realize an instance of a
context with a particular contextName.
SNMP messages encapsulate a Protocol Data Unit (PDU). It is the 3.3.3. contextName
purpose of a Protocol Operations document to define the operations
of the protocol with respect to the processing of the PDUs.
An Orangelet model defines which Protocol Operations documents A contextName is used to name a context. Each contextName
are supported by the model. MUST be unique within an SNMP entity.
4.5. Access Control 3.3.4. scopedPDU
During processing, it may be required to control access to certain \
instrumentation for certain operations. The determination of
access rights requires the means to identify the access allowed for
the security-identity on whose behalf a request is generated.
An Access Control model provides an advisory service for an A scopedPDU is a block of data containing a contextEngineID,
Orangelet. The determination of whether to check access control a contextName, and a PDU.
policy is the responsibility of the Orangelet model. The mechanism
by which access control is checked is defined by the Access Control
model.
4.6. Coexistence The PDU is an SNMP Protocol Data Unit containing information
named in the context which is unambiguously identified within
an administrative domain by the combination of the contextEngineID
and the contextName. See, for example, RFC1905 for more information
about SNMP PDUs.
The purpose of an evolutionary architecture is to permit new models 3.4. Other Constructs
to replace or supplement existing models. The interactions between
models could result in incompatibilities, security "holes", and
other undesirable effects.
The purpose of a Coexistence document is to detail recognized anomalies 3.4.1. maxSizeResponseScopedPDU
and to describe required and recommended behaviors for resolving the
interactions between models within the architecture.
It would be very difficult to document all the possible interactions The maxSizeResponseScopedPDU is the maximum size of a scopedPDU to
between a model and all other previously existing models while in the be included in a response message, making allowance for the message
process of developing a new model. header.
Coexistence documents are therefore expected to be prepared separately 3.4.2. Local Configuration Datastore
from model definition documents, to describe and resolve interaction
anomalies between a model definition and one or more other model
definitions.
5. Abstract Data Elements of the Architecture The subsystems, models, and applications within an SNMP entity may
need to retain their own sets of configuration information.
This section contains definitions of abstract data elements used to Portions of the configuration information may be accessible as
transfer data between subsystems. managed objects.
5.1. engineID The collection of these sets of information is referred to
as an entity's Local Configuration Datastore (LCD).
Each SNMP engine, consisting of potentially many subsystems, must be 3.4.3. LoS
able to be uniquely identified. The mechanism by which this can be
done is defined in the IMFMIB module, described in this document,
since it is desirable that engine identification span all frameworks.
5.2. SecurityIdentity This architecture recognizes three levels of security (LoS):
A generic term for an uniquely-identifiable entity on whose behalf - without authentication and without privacy (noAuthNoPriv)
a message can be generated. Each security subsystem may define a - with authentication but without privacy (authNoPriv)
model-specific mechanism for entity identification, such as a - with authentication and with privacy (authPriv)
community [RFC1157] or user [RFC1910] or party-pair [RFC1445].
This model-specific identifier is not guaranteed to be represented
in a character set readable by humans.
5.3. Model Independent Identifier (MIID) These three values are ordered such that noAuthNoPriv is lower than
authNoPriv and authNoPriv is lower than authPriv.
Each security model must also provide a mapping from the model Every message has an associated LoS. All Subsystems (Message
specific identification to an SnmpAdminString representation, Processing, Security, Access Control) and applications are required
called the MIID, which, in combination with the securityModel, to either supply a value of LoS or to abide by the supplied value of
can be used by all other subsystems within an engine to identify LoS while processing the message and its contents.
a security identity, regardless of the security mechanisms used to
provide security services.
The combination of engineID and securityModel and MIID provides a \
globally-unique identifier for an entity on whose behalf a message
can be generated.
5.4. Level of Security 4. Architectural Elements of Procedure
Messages may require different levels of security. The acronym LoS is The architecture described here contains three subsystems, each
used to refer to the level of security. capable of being defined as one or more different models which may
be replaced or supplemented as the growing needs of network management
require. The architecture also includes applications which utilize the
services provided by the subsystems.
This architecture recognizes three levels of security: An SNMP engine deals with SNMP messages, and is responsible for
- without authentication and without privacy (noAuth/noPriv) sending and receiving messages, including having authentication
- with authentication but without privacy (auth/noPriv) and encryption services applied to the messages, and determining
- with authentication and with privacy (auth/Priv) to which application the message contents should be delivered.
Every message has an associated LoS; all subsystems (security, access Applications deal with processing network management operations.
control, orangelets, message processing and control) are required Depending on the network management service needed, an application
to abide the specified LoS while processing the message and its may use the Access Control Subsystem, and may use SNMP messages to
contents. communicate with remote nodes. The network management service may
be requested via the payload of an SNMP message, or may be requested
via a local process.
5.5. Contexts \
An SNMP context is a collection of management information 4.1. Operational Overview
accessible by an SNMP engine. An item of management information
may exist in more than one context. An SNMP engine potentially
has access to many contexts.
5.6. ContextName The following pictures show two communicating SNMP entities using
the conceptual modularity described by the SNMP Architecture.
The pictures represent SNMP entities that have traditionally been
called SNMP manager and SNMP agent respectively. The boxes marked
with an asterisk (*) may be absent.
An octet string used to name a context. Each context must be uniquely (traditional SNMP manager)
named within an engine. +--------------------------------------------------------------------+
| SNMP entity |
| |
| +--------------+ +--------------+ +--------------+ |
| | NOTIFICATION | | NOTIFICATION | | COMMAND | |
| | ORIGINATOR | | RECEIVER | | GENERATOR | |
| | applications | | applications | | applications | |
| +--------------+ +--------------+ +--------------+ |
| ^ ^ ^ |
| | | | |
| v v v |
| +----------------------------------------------------------------+ |
| | Message Processing Application Multiplexor | |
| +----------------------------------------------------------------+ |
| ^ ^ ^ ^ |
| +-----------+ | | | | |
| | | v v v v |
| | Security | +------+ +---------+ +--------+ +-----------+ |
| | Subsystem |<-->| v3MP | | v2cMP * | | v1MP * |...| otherMP * | |
| | | +------+ +---------+ +--------+ +-----------+ |
| +-----------+ ^ ^ ^ ^ |
| | | | | |
| v v v v |
| +----------------------------------------------------------------+ |
| | Message Processing Model selection (incoming only) | |
| +----------------------------------------------------------------+ |
| ^ |
| | |
| v |
| +----------------------------------------------------------------+ |
| | TRANSPORT MAPPING (for example RFC1906) | |
| +----------------------------------------------------------------+ |
+--------------------------------------------------------------------+
+-----+ +-----+ +-------+
| UDP | | IPX | . . . | other |
+-----+ +-----+ +-------+
^ ^ ^
| | |
v v v
+------------------------------+
| Network |
+------------------------------+
5.7. ContextEngineID \
+------------------------------+
| Network |
+------------------------------+
^ ^ ^
| | |
v v v
+-----+ +-----+ +-------+
| UDP | | IPX | . . . | other |
+-----+ +-----+ +-------+ (traditional SNMP agent)
+--------------------------------------------------------------------+
| +----------------------------------------------------------------+ |
| | TRANSPORT MAPPING (for example RFC1906) | |
| +----------------------------------------------------------------+ |
| ^ |
| | |
| v |
| +----------------------------------------------------------------+ |
| | Message Processing Model selection (incoming only) | |
| +----------------------------------------------------------------+ |
| ^ ^ ^ ^ |
| +-----------+ | | | | |
| | | v v v v |
| | Security | +------+ +---------+ +--------+ +-----------+ |
| | Subsystem |<-->| v3MP | | v2cMP * | | v1MP * |...| otherMP * | |
| | | +------+ +---------+ +--------+ +-----------+ |
| +-----------+ ^ ^ ^ ^ |
| | | | | |
| v v v v |
| +----------------------------------------------------------------+ |
| | Message Processing Abstract Service Interface | |
| +----------------------------------------------------------------+ |
| ^ ^ ^ |
| | | | |
| v v v |
| +-------------+ +---------+ +--------------+ +-------------+ |
| | COMMAND | | ACCESS | | NOTIFICATION | | PROXY * | |
| | RESPONDER |<->| CONTROL |<->| ORIGINATOR | | FORWARDER | |
| | application | | | | applications | | application | |
| +-------------+ +---------+ +--------------+ +-------------+ |
| ^ ^ |
| | | |
| v v |
| +----------------------------------------------+ |
| | MIB instrumentation | SNMP entity |
+--------------------------------------------------------------------+
A contextEngineID uniquely identifies an engine that may realize \
an instance of a named context.
5.8. Naming Scope 4.2. Sending and Receiving SNMP Messages
The combination of a contextEngineID and a contextName uniquely 4.2.1. Send a Message to the Network
identifies a context within an administrative domain, and is called
a naming scope.
5.9. Scoped-PDU Applications may request that messages be generated and sent. The
application has the responsibility of providing the information
necessary to generate the message, as detailed below, and of
providing the transport address to which the message should be sent.
A scopedPDU contains a Naming-Scope and a PDU. The engine passes a request for a message to be generated to the
specified Message Processing Model which, utilizing the services of
the selected Security Model, generates the message and prepares it
for sending.
The Naming Scope unambiguously identifies, within the administrative The SNMP engine sends the message to the specified transport address.
domain, the context to which the SNMP management information in It then advises the sending Message Processing Model about the success
the PDU refers. or failure of the sending of the message.
The PDU format is defined by an Orangelet model, or a document 4.2.2. Receive a Message from the Network
referenced by an Orangelet model, which processes the PDU contents.
5.10. PDU-MMS It is the responsibility of the SNMP engine to listen for incoming
messages at the appropriate local addresses. Some local addresses
for listening are recommended by SNMP Transport Mapping documents,
such as [RFC1906].
the maximum size of a scopedPDU to be included in a response message, Upon receipt of an SNMP message, the SNMP engine increments the
given the amount of reserved space in the message for the anticipated snmpInPkts counter [RFC1907].
security parameters.
5.11. Local Configuration Datastore SNMP messages received from the network use a format defined by a
version-specific Message Processing Model, typically identified
by a version field in the message header.
The subsystems and models in an SNMP engine may need to retain their The engine determines the SNMP version of an incoming message by
own, possibly multiple, sets of information to perform their inspecting the serialized values for a recognizable pattern.
processing. To allow these sets of information to be remotely The mechanism by which it makes the determination of version is
configured, portions may need to be accessible as managed objects. implementation-specific, and dependent on the Message Processing
Models supported by the engine.
The collection of these possibly multiple sets of information is If the engine has no Message Processing Model for the determined
referred to collectively as an engine's Local Configuration Datastore version, then the snmpInBadVersions counter [RFC1907] is incremented,
(LCD). and the message is discarded without further processing.
5.11.1. Security Portion of the Local Configuration Datastore The SNMP engine caches the msgID, which is subsequently used for
coordinating all processing regarding this received message, and
caches the origin network address so a possible response can be
sent to the origin address.
Each Security model may need to retain its own set of information about Based on the SNMP version of the message, the engine passes the
security entities, mechanisms, and policies. message to the appropriate version-specific Message Processing Model.
The Message Processing Model extracts the information in the message,
utilizing services of the appropriate Security Model to authenticate
5.11.2. Orangelet Portion of the Local Configuration Datastore \
Each Orangelet model may need to retain its own set of information and decrypt the message as needed.
about contexts, naming scopes, and other configuration data.
5.11.3. Access Control Portion of the Local Configuration Datastore 4.3. Send a Request or Notification Message for an Application
Each Access Control model may need to retain its own set of The Application Multiplexor receives a request for the generation
information about access control policies, and the MIIDs of an SNMP message from an application via the sendPdu primitive:
to which the policies apply.
5.12. Groups sendPdu(
transportDomain -- transport domain to be used
transportAddress -- destination network address
messageProcessingModel -- typically, SNMP version
securityModel -- Security Model to use
securityName -- on behalf of this principal
LoS -- Level of Security requested
contextEngineID -- data from/at this entity
contextName -- data from/in this context
PDU -- SNMP Protocol Data Unit
expectResponse) -- TRUE or FALSE
A Group identifies a set of zero or more MIIDs on whose The SNMP engine checks the "expectResponse" parameter to determine if
behalf SNMP managed objects are being processed, subject to access it is a message which is expected to receive a response, and if so,
control policies common to all members of the group. caches the msgID of the generated message and which application
made the request.
6. Definition of Managed Objects for Internet Management Frameworks The engine sends the message according to the procedure detailed
in section 4.2.1. Send a Message to the Network.
IMF-MIB DEFINITIONS ::= BEGIN 4.4. Receive a Request or Notification Message from the Network
The engine receives the message according to the procedure detailed
in section 4.2.2. Receive a Message from the Network.
The Application Demultiplexor looks into the scopedPDU to determine
the contextEngineID and the PDU type, then determines which
application has registered (see section 4.7) to support that PDU type
for that contextEngineID.
The Application Demultiplexor passes the request or notification
to the registered application using the processPdu primitive:
processPdu(
contextEngineID -- data from/at this SNMP engine
contextName -- data from/in this context
PDU -- SNMP Protocol Data Unit
maxSizeResponseScopedPDU -- maximum size of the Response PDU
securityModel -- Security Model in use
securityName -- on behalf of this principal
LoS -- Level of Security
stateReference) -- reference to state information
-- needed when sending a response
\
4.5. Generate a Response Message for an Application
The Application Multiplexor receives a request for the generation
of an SNMP response message from an application via the
returnResponsePdu primitive:
returnResponsePdu(
contextEngineID -- data from/at this SNMP engine
contextName -- data from/in this context
securityModel -- Security Model in use
securityName -- on behalf of this principal
LoS -- Level of Security
stateReference -- reference to state information
-- as presented with the request
PDU -- SNMP Protocol Data Unit
maxSizeResponseScopedPDU -- maximum size of the Response PDU
statusInformation -- success or errorIndication
) -- error counter OID/value if error
The engine sends the message according to the procedure detailed
in section 4.2.1. Send a Message to the Network.
4.6. Receive a Response Message
The engine receives the message according to the procedure detailed
in section 4.2.2. Receive a Message from the Network.
The Application Demultiplexor looks into the scopedPDU to determine
the contextEngineID and the PDU type.
If the PDU type is a Response PDU, the Demultiplexor matches the
msgID of the incoming response to the cached msgIDs of messages
sent by this SNMP engine.
If a matching cached msgID is found, the cached msgID and the cached
origin network address are released, and the response is passed to the
associated application using the processResponsePdu primitive:
processResponsePdu(
contextEngineID -- data from/at this SNMP engine
contextName -- data from/in this context
PDU -- SNMP Protocol Data Unit
LoS -- Level of Security
statusInformation -- success or errorIndication
)
4.7. Registering to 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 to which application
\
the message should be given.
An Application that wishes to receive asynchronous messages registers
itself with the engine using the registration primitive. The
application registers to handle all incoming messages containing
a particular PDU type regarding a specific contextEngineID.
statusInformation = -- success or errorIndication
registerContextEngineID(
contextEngineID -- take responsibility for this one
pduType -- the pduType(s) to be registered
)
Only one registration per PDU type per contextEngineID is permitted
at the same time. Duplicate registrations are ignored. An
errorIndication will be returned to the application if it attempts
to duplicate an existing registration.
An Application that wishes to stop receiving asynchronous messages
should unregister itself with the SNMP engine.
unregisterContextEngineID(
contextEngineID -- give up responsibility for this one
pduType -- the pduType(s) to be unregistered
)
SNMP does not provide a mechanism for identifying an application,
so the mechanism used to identify which application is registering
is implementation-specific.
\
5. Definition of Managed Objects for Internet Management Frameworks
SNMP-FRAMEWORK-MIB DEFINITIONS ::= BEGIN
IMPORTS IMPORTS
MODULE-IDENTITY, OBJECT-TYPE, snmpModules, MODULE-IDENTITY, OBJECT-TYPE,
Unsigned32, Integer32 FROM SNMPv2-SMI OBJECT-IDENTITY,
snmpModules, Unsigned32, Integer32 FROM SNMPv2-SMI
TEXTUAL-CONVENTION FROM SNMPv2-TC TEXTUAL-CONVENTION FROM SNMPv2-TC
MODULE-COMPLIANCE, OBJECT-GROUP FROM SNMPv2-CONF; MODULE-COMPLIANCE, OBJECT-GROUP FROM SNMPv2-CONF;
imfMIB MODULE-IDENTITY snmpFrameworkMIB MODULE-IDENTITY
LAST-UPDATED "9706160000Z" -- 16 June 1997, midnight LAST-UPDATED "9707110000Z" -- 11 July 1997, midnight
ORGANIZATION "SNMPv3 Working Group" ORGANIZATION "SNMPv3 Working Group"
CONTACT-INFO "WG-email: snmpv3@tis.com CONTACT-INFO "WG-email: snmpv3@tis.com
Subscribe: majordomo@tis.com Subscribe: majordomo@tis.com
In message body: subscribe snmpv3 In message body: subscribe snmpv3
Chair: Russ Mundy Chair: Russ Mundy
Trusted Information Systems Trusted Information Systems
postal: 3060 Washington Rd postal: 3060 Washington Rd
Glenwood MD 21738 Glenwood MD 21738
USA
email: mundy@tis.com email: mundy@tis.com
phone: 301-854-6889 phone: +1-301-854-6889
Co-editor Dave Harrington Co-editor Dave Harrington
Cabletron Systems, Inc Cabletron Systems, Inc
postal: Post Office Box 5005 postal: Post Office Box 5005
MailStop: Durham MailStop: Durham
35 Industrial Way 35 Industrial Way
Rochester NH 03867-5005 Rochester NH 03867-5005
USA
email: dbh@cabletron.com email: dbh@cabletron.com
phone: 603-337-7357 phone: +1-603-337-7357
Co-editor: Bert Wijnen Co-editor: Bert Wijnen
IBM T.J. Watson Research IBM T.J. Watson Research
postal: Schagen 33 postal: Schagen 33
3461 GL Linschoten 3461 GL Linschoten
Netherlands Netherlands
email: wijnen@vnet.ibm.com email: wijnen@vnet.ibm.com
phone: +31-348-412-498 phone: +31-348-432-794
" "
DESCRIPTION "The Internet Management Architecture MIB" DESCRIPTION "The Internet Management Architecture MIB"
::= { snmpModules 99 } ::= { snmpModules 7 } -- DBH: check if this number is indeed OK
-- Textual Conventions used in the Internet Management Architecture *** -- Textual Conventions used in the Internet Management Architecture ***
SnmpEngineID ::= TEXTUAL-CONVENTION SnmpEngineID ::= TEXTUAL-CONVENTION
STATUS current STATUS current
\
DESCRIPTION "An SNMP engine's administratively-unique identifier. DESCRIPTION "An SNMP engine's administratively-unique identifier.
The value for this object may not be all zeros or The value for this object may not be all zeros or
all 'ff'H. all 'ff'H. It may also not be the empty string.
The initial value for this object may be configured The initial value for this object may be configured
via an operator console entry or via an algorithmic via an operator console entry or via an algorithmic
function. In the later case, the following function. In the latter case, the following
guidelines are recommended: example algorithm for a twelve-octet identifier
is recommended:
1) The first four octets are set to the binary 1) The first four octets are set to the binary
equivalent of the agent's SNMP network management equivalent of the entity's SNMP network management
private enterprise number as assigned by the private enterprise number as assigned by the
Internet Assigned Numbers Authority (IANA). Internet Assigned Numbers Authority (IANA).
For example, if Acme Networks has been assigned For example, if Acme Networks has been assigned
{ enterprises 696 }, the first four octets would { enterprises 696 }, the first four octets would
be assigned '000002b8'H. be assigned '000002b8'H.
2) The remaining eight octets are the cookie whose 2) The remaining eight octets are determined via
contents are determined via one or more one or more enterprise specific methods. Such
enterprise specific methods. Such methods must methods must be designed so as to maximize the
be designed so as to maximize the possibility possibility that the value of this object will
that the value of this object will be unique in be unique in the entity's administrative domain.
the agent's administrative domain. For example, For example, it may be the IP address of the SNMP
the cookie may be the IP address of the agent, entity, or the MAC address of one of the
or the MAC address of one of the interfaces, interfaces, with each address suitably padded
with each address suitably padded with random with random octets. If multiple methods are
octets. If multiple methods are defined, then defined, then it is recommended that the first
it is recommended that the cookie be further octet that indicates the method being used and
divided into one octet that indicates the the remaining octets are a function of the method.
method being used and seven octets which are
a function of the method.
" "
SYNTAX OCTET STRING (SIZE (12)) SYNTAX OCTET STRING
SnmpSecurityModel ::= TEXTUAL-CONVENTION SnmpSecurityModel ::= TEXTUAL-CONVENTION
STATUS current STATUS current
DESCRIPTION "An identifier that uniquely identifies a model of DESCRIPTION "An identifier that uniquely identifies a securityModel
security subsystem within the Internet of the Security Subsystem within the Internet
Management Architecture. Management Architecture.
"
SYNTAX INTEGER(0..2147483647)
The values for securityModel are allocated as follows:
- Negative and zero values are 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.
The eight bits allow a maximum of 255 (256-1 reserved)
standards based Security Models. Similarly, they
allow a maximum of 255 Security Models per enterprise.
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 'none'
1 reserved for SNMPv1
2 reserved for SNMPv2c
3 User-Base Security Model (USM)
255 reserved for 'any'
"
SYNTAX INTEGER(0..2147483647)
SnmpLoS ::= TEXTUAL-CONVENTION SnmpLoS ::= TEXTUAL-CONVENTION
STATUS current STATUS current
DESCRIPTION "A level of security at which SNMP messages can be DESCRIPTION "A Level of Security at which SNMP messages can be
sent; in particular, one of: sent or with which operations are being processed;
noAuth - without authentication and without privacy, in particular, one of:
auth - with authentication but without privacy,
priv - with authentication and with privacy. \
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 lower than authNoPriv and authNoPriv is lower than
authPriv.
" "
SYNTAX INTEGER { noAuth(1), auth(2), priv(3) } SYNTAX INTEGER { noAuthNoPriv(1),
authNoPriv(2),
authPriv(3)
}
SnmpAdminString ::= TEXTUAL-CONVENTION SnmpAdminString ::= TEXTUAL-CONVENTION
DISPLAY-HINT "255a"
STATUS current STATUS current
DESCRIPTION "An octet string containing an SNMP administrative DESCRIPTION "An octet string containing administrative information,
string. Preferably this a a human readable string. preferably in human-readable form.
We're still thinking if this could use the UTF8
character set.
"
SYNTAX OCTET STRING (SIZE(1..255))
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
character encoding scheme described in RFC 2044.
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.
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
representation is identical to the US-ASCII encoding.
"
SYNTAX OCTET STRING (SIZE (0..255))
-- Administrative assignments **************************************** -- Administrative assignments ****************************************
imfAdmin OBJECT IDENTIFIER ::= { imfMIB 1 } snmpFrameworkAdmin OBJECT IDENTIFIER ::= { snmpFrameworkMIB 1 }
imfMIBObjects OBJECT IDENTIFIER ::= { imfMIB 2 } snmpFrameworkMIBObjects OBJECT IDENTIFIER ::= { snmpFrameworkMIB 2 }
imfMIBConformance OBJECT IDENTIFIER ::= { imfMIB 3 } snmpFrameworkMIBConformance OBJECT IDENTIFIER ::= { snmpFrameworkMIB 3 }
\
imfEngine OBJECT IDENTIFIER ::= { imfMIBObjects 1 } -- the snmpEngine Group **********************************************
snmpEngine OBJECT IDENTIFIER ::= { snmpFrameworkMIBObjects 1 }
snmpEngineID OBJECT-TYPE snmpEngineID OBJECT-TYPE
SYNTAX SnmpEngineID SYNTAX SnmpEngineID
MAX-ACCESS read-only MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION "An SNMP engine's administratively-unique identifier. DESCRIPTION "An SNMP engine's administratively-unique identifier.
" "
::= { imfEngine 1 } ::= { snmpEngine 1 }
snmpEngineBoots OBJECT-TYPE snmpEngineBoots OBJECT-TYPE
SYNTAX Unsigned32 -- (1..4294967295) SYNTAX Unsigned32 -- (1..4294967295)
MAX-ACCESS read-only MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION "The number of times that the engine has re-initialized DESCRIPTION "The number of times that the SNMP engine has
itself since its initial configuration. (re-)initialized itself since its initial
configuration.
" "
::= { imfEngine 2 } ::= { snmpEngine 2 }
snmpEngineTime OBJECT-TYPE snmpEngineTime OBJECT-TYPE
SYNTAX Integer32 (0..2147483647) SYNTAX Integer32 (0..2147483647)
MAX-ACCESS read-only MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION "The number of seconds since the engine last DESCRIPTION "The number of seconds since the SNMP engine last
incremented the snmpEngineBoots object. incremented the snmpEngineBoots object.
" "
::= { imfEngine 3 } ::= { snmpEngine 3 }
snmpEngineMaxMessageSize OBJECT-TYPE -- Registration Points for IMF Authentication and Privacy Protocols **
SYNTAX Integer32 (484..65507) snmpAuthProtocols OBJECT-IDENTITY
MAX-ACCESS read-only
STATUS current STATUS current
DESCRIPTION "The maximum length in octets of an SNMP message DESCRIPTION "Registration point for standards-track authentication
which this SNMP engine can send or receive and protocols used in the Internet Management Framework.
process, determined as the minimum of the maximum
message size values supported among all of the
transports available to and supported by the engine.
" "
::= { imfEngine 4 } ::= { snmpFrameworkAdmin 1 }
imfAuthProtocols OBJECT IDENTIFIER ::= { imfAdmin 1 }
imfNoAuthProtocol OBJECT IDENTIFIER ::= { imfAuthProtocols 1 }
imfAuthMD5Protocol OBJECT IDENTIFIER ::= { imfAuthProtocols 2 }
DBH to BW: should we have a description of this object to make it
meaningful? ditto for DES below.
imfPrivProtocols OBJECT IDENTIFIER ::= { imfAdmin 2 }
imfNoPrivProtocol OBJECT IDENTIFIER ::= { imfPrivProtocols 1 } snmpPrivProtocols OBJECT-IDENTITY
STATUS current
DESCRIPTION "Registration point for standards-track privacy
protocols used in the Internet Management Framework.
"
::= { snmpFrameworkAdmin 2 }
imfDESPrivProtocol OBJECT IDENTIFIER ::= { imfPrivProtocols 2 } -- Conformance information *******************************************
snmpFrameworkMIBCompliances
imfMIBCompliances \
OBJECT IDENTIFIER ::= { imfMIBConformance 1 } OBJECT IDENTIFIER ::= { snmpFrameworkMIBConformance 1 }
imfMIBGroups snmpFrameworkMIBGroups
OBJECT IDENTIFIER ::= { imfMIBConformance 2 } OBJECT IDENTIFIER ::= { snmpFrameworkMIBConformance 2 }
-- compliance statements -- compliance statements
imfMIBCompliance MODULE-COMPLIANCE snmpFrameworkMIBCompliance MODULE-COMPLIANCE
STATUS current STATUS current
DESCRIPTION "The compliance statement for SNMP engines which DESCRIPTION "The compliance statement for SNMP engines which
implement the IMF MIB. implement the Internet Management Framework MIB.
" "
MODULE -- this module MODULE -- this module
MANDATORY-GROUPS { MANDATORY-GROUPS { snmpEngineGroup }
imfEngineBasicGroup
} ::= { snmpFrameworkMIBCompliances 1 }
::= { imfMIBCompliances 1 }
-- units of conformance -- units of conformance
imfEngineBasicGroup OBJECT-GROUP snmpEngineGroup OBJECT-GROUP
OBJECTS { OBJECTS {
snmpEngineID, snmpEngineID,
snmpEngineMaxMessageSize,
snmpEngineBoots, snmpEngineBoots,
snmpEngineTime snmpEngineTime
} }
STATUS current STATUS current
DESCRIPTION "A collection of objects for identifying and DESCRIPTION "A collection of objects for identifying and
determining the configuration limits of an determining the configuration and current timeliness
SNMP agent. values of an SNMP engine.
" "
::= { imfMIBGroups 1 } ::= { snmpFrameworkMIBGroups 1 }
END
\
END 6. Security Considerations
7. Model Design Requirements This document describes how a framework can use a Security Model and
an Access Control Model to achieve a level of security for network
management messages and controlled access to management information.
The level of security provided is determined by the specific Security
Model implementation(s) and the specific Access Control Model
implementation(s) incorporated into this framework.
Applications have access to data which is not secured. Applications
should take reasonable steps to protect the data from disclosure.
It is the responsibility of the purchaser of a management framework
implementation to ensure that:
1) an implementation of this framework complies with the rules
defined by this architecture,
2) the Security and Access Control Models utilized satisfy the
security and access control needs of the organization,
3) the implementations of the Models and Applications comply with
the model and application specifications,
4) and the implementation protects configuration secrets from
inadvertent disclosure.
\
7. Glossary
8. 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., M. Fedor, M. Schoffstall, and J. Davin,
"The Simple Network Management Protocol", STD 15, RFC 1157,
University of Tennessee at Knoxville, Performance Systems s
International, Performance International, and the MIT Laboratory
for Computer Science, May 1990.
[RFC1212] Rose, M., and K. McCloghrie, "Concise MIB Definitions",
STD 16, RFC 1212, March 1991.
[RFC1901] The SNMPv2 Working Group, Case, J., McCloghrie, K.,
Rose, M., and S., Waldbusser, "Introduction to
Community-based SNMPv2", RFC 1901, January 1996.
[RFC1902] The SNMPv2 Working Group, Case, J., McCloghrie, K.,
Rose, M., and S., Waldbusser, "Structure of Management
Information for Version 2 of the Simple Network Management
Protocol (SNMPv2)", RFC 1905, January 1996.
[RFC1903] The SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M.,
and S. Waldbusser, "Textual Conventions for Version 2 of the Simple
Network Management Protocol (SNMPv2)", RFC 1903, January 1996.
[RFC1904] The SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M.,
and S., Waldbusser, "Conformance Statements for Version 2 of the
Simple Network Management Protocol (SNMPv2)", RFC 1904,
January 1996.
[RFC1905] The SNMPv2 Working Group, 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] The SNMPv2 Working Group, 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] The SNMPv2 Working Group, 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] The SNMPv2 Working Group, 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", RFC1909, February 1996
[RFC1910] Waters, G., Editor, "User-based Security Model for SNMPv2",
RFC1910, February 1996
\
9. Editor's Addresses
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
Co-editor Dave Harrington
Cabletron Systems, Inc
postal: Post Office Box 5005
MailStop: Durham
35 Industrial Way
Rochester NH 03867-5005
USA
email: dbh@cabletron.com
phone: +1-603-337-7357
\
10. Acknowledgements
This document builds on the work of the SNMP Security and
Administrative Framework Evolution team, composed of
David Harrington (Cabletron Systems Inc.)
Jeff Johnson (Cisco)
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)
\
APPENDIX A
A. Guidelines for Model Designers
This appendix describes guidelines for designers of models which
are expected to fit into the architecture defined in this document.
The basic design elements come from SNMPv2u and SNMPv2*, as The basic design elements come from SNMPv2u and SNMPv2*, as
described in RFCs 1909-1910, and from a set of internet drafts. described in RFCs 1909-1910, and from a set of internet drafts.
these are the two most popular de facto "administrative framework" these are the two most popular de facto "administrative framework"
standards that include security and access control for SNMPv2. standards that include security and access control for SNMPv2.
SNMPv1 and SNMPv2c [RFC1901] are two administrative frameworks based SNMPv1 and SNMPv2c [RFC1901] are two administrative frameworks based
on communities to provide trivial authentication and access control. on communities to provide trivial authentication and access control.
SNMPv1 and SNMPv2c Frameworks can coexist with Frameworks designed SNMPv1 and SNMPv2c Frameworks can coexist with Frameworks designed
to fit into this architecture, and modified versions of SNMPv1 and to fit into this architecture, and modified versions of SNMPv1 and
SNMPv2c Frameworks could be fit into this architecture, but this SNMPv2c Frameworks could be fit into this architecture, but this
document does not provide guidelines for that coexistence. document does not provide guidelines for that coexistence.
Within any subsystem model, there should be no reference to any Within any subsystem model, there should be no reference to any
specific model of another subsystem, or to data defined by a specific specific model of another subsystem, or to data defined by a specific
model of another subsystem. model of another subsystem.
Transfer of data between the subsystems is deliberately described as a fixed Transfer of data between the subsystems is deliberately described
set of abstract data elements and primitive functions which can be overloaded
to satisfy the needs of multiple model definitions.
Documents which define models to be used within this architecture are constrained
to using the abstract data elements for transferring data between subsystems,
possibly defining specific mechanisms for converting the abstract data into
model-usable formats. This constraint exists to allow subsystem and model
documents to be written recognizing common borders of the subsystem and model.
Vendors are not constrained to recognize these borders in their implementations.
The architecture defines certain standard services to be provided
between subsystems, and the architecture defines abstract data
elements to transfer the data necessary to perform the services.
Each model definition for a subsystem must support the standard service
interfaces, but whether, or how, or how well, it performs the service
is defined by the model definition.
7.1. Security Model Design Requirements
7.1.1. Threats
Several of the classical threats to network protocols are applicable
to the network management problem and therefore would be applicable
to any security model used in an Internet Management Framework. Other
threats are not applicable to the network management problem. This
section discusses principal threats, secondary threats, and threats
which are of lesser importance.
The principal threats against which any security model used within
this architecture should provide protection are:
Modification of Information as a fixed set of abstract data elements and primitive functions
The modification threat is the danger that some unauthorized which can be overloaded to satisfy the needs of multiple model
entity may alter in-transit SNMP messages generated on behalf definitions.
of an authorized security-identity in such a way as to effect
unauthorized management operations, including falsifying the
value of an object.
Masquerade Documents which define models to be used within this architecture
The masquerade threat is the danger that management operations SHOULD use the standard primitives between subsystems, possibly
not authorized for some security-identity may be attempted by defining specific mechanisms for converting the abstract data elements
assuming the identity of another security-identity that has the into model-usable formats. This constraint exists to allow subsystem
appropriate authorizations. and model documents to be written recognizing common borders of the
subsystem and model. Vendors are not constrained to recognize these
borders in their implementations.
Message Stream Modification The architecture defines certain standard services to be provided
The SNMPv3 protocol is typically based upon a connectionless between subsystems, and the architecture defines abstract service
transport service which may operate over any subnetwork service. interfaces to request the services.
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 Each model definition for a subsystem SHOULD support the standard
The disclosure threat is the danger of eavesdropping on the service interfaces, but whether, or how, or how well, it performs
exchanges between SNMP engines. Protecting against this threat the service is defined by the model definition.
may be required as a matter of local policy.
There are at least two threats against which a security model used A.1. Security Model Design Requirements
by a framework within this architecture need not protect.
Denial of Service A.1.1. Threats
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 network management protocol must cope as a matter of
course.
Traffic Analysis A document describing a Security Model MUST describe how the model
A security model need not attempt to address traffic analysis protects against the threats described under "Security Requirements
attacks. Many traffic patterns are predictable - agents may be of this Architecture", section 1.4.
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.
7.1.2. Security Processing \
Received messages must be validated by a model of the security A.1.2. Security Processing
subsystem. Validation includes authentication and privacy processing
Received messages MUST be validated by a Model of the Security
Subsystem. Validation includes authentication and privacy processing
if needed, but it is explicitly allowed to send messages which do if needed, but it is explicitly allowed to send messages which do
not require authentication or privacy. not require authentication or privacy.
A received message will contain a specified Level of Security to be A received message contains a specified Level of Security to be
used during processing. All messages requiring privacy must also used during processing. All messages requiring privacy MUST also
require authentication. require authentication.
A security model specifies rules by which authentication and privacy A Security Model specifies rules by which authentication and privacy
are to be done. A model may define mechanisms to provide additional are to be done. A model may define mechanisms to provide additional
security features, but the model definition is constrained to using security features, but the model definition is constrained to using
(possibly a subset of) the abstract data elements defined in this (possibly a subset of) the abstract data elements defined in this
document for transferring data between subsystems. document for transferring data between subsystems.
Each Security model may allow multiple security mechanisms to be used Each Security Model may allow multiple security mechanisms to be used
concurrently within an implementation of the model. Each Security model concurrently within an implementation of the model. Each Security Model
defines how to determine which protocol to use, given the LoS and the defines how to determine which protocol to use, given the LoS and the
security parameters relevant to the message. Each Security model, with security parameters relevant to the message. Each Security Model, with
its associated protocol(s) defines how the sending/receiving entities its associated protocol(s) defines how the sending/receiving entities
are identified, and how secrets are configured. are identified, and how secrets are configured.
Authentication and Privacy protocols supported by security models Authentication and Privacy protocols supported by Security Models are
are uniquely identified using Object Identifiers. IETF standard uniquely identified using Object Identifiers. IETF standard protocol
protocol for authentication or privacy should have an identifier for authentication or privacy should have an identifier defined within
defined within the ImfAuthenticationProtocols or ImfPrivacyProtocols the snmpAuthProtocols or the snmpPrivProtocols subtrees. Enterprise
subtrees. Enterprise-specific protocol identifiers should be defined specific protocol identifiers should be defined within the enterprise
within the enterprise subtree. subtree.
For privacy, the Security model defines what portion of the message For privacy, the Security Model defines what portion of the message
is encrypted. is encrypted.
The persistent data used for security should be SNMP-manageable, but The persistent data used for security should be SNMP-manageable, but
the Security model defines whether an instantiation of the MIB is a the Security Model defines whether an instantiation of the MIB is a
conformance requirement. conformance requirement.
Security models are replaceable within the security subsystem. Multiple Security Models are replaceable within the Security Subsystem.
Security model Implementations may exist concurrently within an engine. Multiple Security Model implementations may exist concurrently within
The number of Security models defined by the SNMP community should an SNMP engine. The number of Security Models defined by the SNMP
remain small to promote interoperability. It is required that an community should remain small to promote interoperability.
implementation of the User-Based Security model be used in all
engines to ensure at least a minimal level of interoperability.
7.1.3. validate the security-stamp in a received message A.1.3. validate the security-stamp in a received message
given a message, the MMS, LoS, and the security parameters from that The Message Processing Model requests that the Security Model verify
message, verify the message has not been altered, and authenticate that the message has not been altered, and authenticate the
the identification of the security-identity for whom the message was identification of the principal for whom the message was generated.
generated. If encrypted, decrypt the message.
If encrypted, decrypt the message \
Additional requirements may be defined by the model, and additional Additional requirements may be defined by the model, and additional
services provided by the model, but the model is constrained to use services provided by the model, but the model is constrained to use
only the defined abstract data elements for transferring data between the following primitives for transferring data between subsystems.
subsystems. Implementations are no so constrained. Implementations are not so constrained.
return a MIID identifying the security-identity for whom
the message was generated and return the portions of the message
needed for further processing:
a PDU - a PDU containing varbinds and a verb according to
the rules of the Local Processing model to be used.
LoS - the level of security required. The same level of
security must also be used during application of access
control.
MMS - the maximum size of a message able to be generated
by this engine for the destination agent.
PDU-MMS - the maximum size of a PDU to be included in a
response message, given the amount of
reserved space in the message for the anticipated
security parameters.
7.1.4. Security Identity
Different security models define identifiers which represent some
<thing> which somehow exists, and is capable of using SNMP.
The <thing> may be person, or a network-management platform, or
an aggregate of persons, or an aggregation of persons and devices,
or some other abstraction of entities that are recognized as
being able to use SNMP-defined services.
This document will refer to that abstraction as a security-identity.
7.1.5. Model Dependent Identifier
Each Security model defines how security-identities are identified
within the model, i.e. how they are named. Model-dependent identifiers
must be unique within the model. The combination of engineID,
securityModel, and the correct model-dependent identifier can be
used to uniquely identify a security-identity.
For example, David Harrington may be represented on a particular
engine by multiple security models - as the user "davidh", the
community "david", and the foobar "david". It is legal to use
"david" in more than one model, since uniqueness is only guaranteed
within the model, but there cannot be two "david" communities.
The combination of the engineID, the <user> model, and the user
"davidh" uniquely identifies the security-entity David Harrington.
7.1.6. Model Independent Identifier
It is desirable to be able to refer to a security-entity using a human
readable identifier, such as for audit trail entries.
Therefore, each Security model is required to define a mapping between
a model-dependent identifier and an identifier restricted to a human The Message Processing Model uses the following primitive:
readable character set. This identifier is called a MIID.
The type of a MIID is a human-readable OCTET STRING following the processMsg(
conventions of the SnmpAdminString TEXTUAL-CONVENTION, defined below. messageProcessingModel -- typically, SNMP version
msgID -- of the received message
mms -- of the sending SNMP entity
msgFlags -- for the received message
securityParameters -- for the received message
securityModel -- for the received message
LoS -- Level of Security
wholeMsg -- as received on the wire
wholeMsgLength -- length as received on the wire
)
The combination of engineID and securityModel and MIID can be used as a The Security Model uses the following primitive to respond:
globally-unique identifier for a security-identity.
It is important to note that since the MIID may be accessible outside returnProcessedMsg(
the engine, care must be taken to not disclose sensitive data, such securityName -- identification of the principal
as by including passwords in open text in the MIID. scopedPDU, -- message (plaintext) payload
maxSizeResponseScopedPDU -- maximum size of the Response PDU
securityStateReference -- reference to security state
-- information, needed for response
statusInformation -- errorIndication or success
) -- error counter OID/value if error
7.1.5. Security MIBs A.1.5. Security MIBs
Each Security model defines the MIB modules required for security Each Security Model defines the MIB modules required for security
processing, including any MIB modules required for the security processing, including any MIB modules required for the security
mechanism(s) supported. The MIB modules must be defined concurrently mechanism(s) supported. The MIB modules SHOULD be defined concurrently
with the procedures which use the MIB module. The MIB modules are with the procedures which use the MIB module. The MIB modules are
subject to normal security and access control rules. subject to normal security and access control rules.
The mapping between the model-dependent identifier and the MIID The mapping between the model-dependent identifier and the securityName
must be able to be determined using SNMP, if the model-dependent MUST be able to be determined using SNMP, if the model-dependent
MIB is instantiated and access control policy allows. MIB is instantiated and access control policy allows access.
7.1.6. Security State Cacheing A.1.6. Security State Cache
For each message received, the security subsystem caches the state information For each message received, the Security Subsystem caches the state
such that a response message can be generated using the same security information such that a Response message can be generated using the
state information, even if the security portion of the Local Configuration same security state information, even if the Local Configuration
Datastore is altered between the time of the incoming request and the Datastore is altered between the time of the incoming request and
outgoing response. the outgoing response.
The Orangelet subsystem has the responsibility for explicitly releasing \
the cached data. To enable this, an abstract state_reference data element
is passed from the security subsystem to the message processing and control
subsystem, which passes it to the orangelet subsystem.
The cached security data must be implicitly released via the generation of a Applications have the responsibility for explicitly releasing the
response, or explicitly released by using the state_release() primitive: cached data. To enable this, an abstract stateReference data element
is passed from the Security Subsystem to the Message Processing
Subsystem, which passes it to the application.
state_release( state_reference ) The cached security data may be implicitly released via the
generation of a response, or explicitly released by using the
stateRelease primitive:
7.2. MessageEngine and Message Processing and Control Model Requirements stateRelease(
stateReference -- handle of reference to be released
)
A messageEngine may contain multiple version-specific Message Processing and \
Control models.
Within any version-specific Message Processing and Control model, there may be A.2. SNMP engine and Message Processing Model Requirements
an explicit binding to a particular security model but there should be no
reference to any data defined by a specific security model. there should be
no reference to any specific Orangelet model, or to any data defined by a An SNMP engine contains a Message Processing Subsystem which may
specific Orangelet model; there should be no reference to any specific Access contain multiple version-specific Message Processing Models.
Control model, or to any data defined by a specific Access Control model.
The Message Processing and Control model must always (conceptually) Within any version-specific Message Processing Model, there may be
pass the complete PDU, i.e. it never forwards less than the complete an explicit binding to a particular Security Model but there should
list of varbinds. be no reference to any data defined by a specific Security Model.
There should be no reference to any specific application, or to any
data defined by a specific application; there should be no reference
to any specific Access Control Model, or to any data defined by a
specific Access Control Model.
7.2.1. Receiving an SNMP Message from the Network The Message Processing Model MUST always (conceptually) pass the
complete PDU, i.e. it never forwards less than the complete list of
varBinds.
Upon receipt of a message from the network, the messageEngine will, A.2.1. Receiving an SNMP Message from the Network
in an implementation-defined manner, establish a mechanism for coordinating
all processing regarding this received message, e.g. it may assign a "handle"
to the message.
DBH: It is no longer valid that the MPC coordinates all processing. But it
still needs to match requests and responses. how does an incoming request get
matched to the outgoing response?
A Message Processing and Control model will specify how to determine the values Upon receipt of a message from the network, the SNMP engine notes the
of the global data (MMS, the securityModel, the LoS), and the security msgID, which is subsequently used for coordinating all processing
parameters block. The Message Processing and Control will call the security regarding this received message.
model to provide security processing for the message using the primitive:
processMsg( globalData, securityParameters, wholeMsg, wholeMsgLen ) A Message Processing Model specifies how to determine the values of
the global data (mms, the securityModel, the LoS), and the security
parameters block. The Message Processing Model calls the Security
Model to provide security processing for the message using the
primitive:
The Security model, after completion of its processing, will return to processMsg(
the Message Processing and Control model the extracted information, using messageProcessingModel -- typically, SNMP version
the returnProcess() primitive: msgID -- of the received message
mms -- of the sending SNMP entity
msgFlags -- for the received message
securityParameters -- for the received message
securityModel -- for the received message
LoS -- Level of Security
wholeMsg -- as received on the wire
wholeMsgLength -- length as received on the wire
)
returnProcess( scopedPDUmms, MIID, cachedSecurityData, scopedPDU, statusCode ) The Security Model uses the following primitive to respond:
7.2.2. Send SNMP messages to the network returnProcessedMsg(
securityName -- identification of the principal
scopedPDU, -- message (plaintext) payload
maxSizeResponseScopedPDU -- maximum size of the Response PDU
securityStateReference -- reference to security state
-- information, needed for response
statusInformation -- errorIndication or success
) -- error counter OID/value if error
The Message Processing and Control model will pass a PDU, the \
MIID, and all global data to be included in the message to
A.2.2. Send SNMP messages to the network
The Message Processing Model passes a PDU, the
securityName, and all global data to be included in the message to
the Security model using the following primitives: the Security model using the following primitives:
For requests and notifications: For requests and notifications:
generateRequestMessage( globalData, scopedPDU, MIID, engineID ) generateRequestMsg(
messageProcessingModel -- typically, SNMP version
DBH: why do we need engineID? isn't that implicit? msgID -- for the outgoing message
mms -- of the sending SNMP entity
msgFlags -- for the outgoing message
securityParameters -- filled in by Security Module
securityModel -- for the outgoing message
securityName -- on behalf of this principal
LoS -- Level of Security requested
snmpEngineID -- authoritative SNMP engine
scopedPDU -- message (plaintext) payload
)
For response messages: For response messages:
generateResponseMessage( globalData, scopedPDU, MIID, cachedSecurityData ) generateResponseMsg(
messageProcessingModel -- typically, SNMP version
msgID -- for the outgoing message
mms -- of the sending SNMP entity
msgFlags -- for the outgoing message
securityParameters -- filled in by Security Module
securityModel -- for the outgoing message
scopedPDU -- message (plaintext) payload
securityStateReference -- reference to security state
-- information, as received in
) -- processPdu primitive
The Security model will construct the message, and return the completed The Security model constructs the message, and returns the completed
message to the messageEngine using the returngenerate() primitive: message to the Message Processing Model using the returnGeneratedMsg
primitive:
returnGenerate( wholeMsg, wholeMsglen, statusCode ) returnGeneratedMsg(
wholeMsg -- complete generated message
wholeMsgLength -- length of the generated message
statusInformation -- errorIndication or success
)
The messageEngine will send the message to the desired address using the The SNMP engine sends the message to the desired address using the
appropriate transport. appropriate transport.
7.2.3. Generate a Request or Notification Message for an Orangelet A.2.3. Generate Request or Notification Message for an Application
The messageEngine will receive a request for the generation of an SNMP message \
from an orangelet via the send_pdu primitive:
send_pdu( transportDomain, transportAddress, snmpVersion, The SNMP engine receives a request for the generation of an SNMP
LoS, securityModel, MIID, contextEngineID, message from an application via the sendPdu primitive:
contextName, PDU,
The messageEngine checks the verb in the PDU to determine if it is a message sendPdu(
which may receive a response, and if so, caches the msgID of the generated transportDomain -- transport domain to be used
message and the associated orangelet. transportAddress -- destination network address
messageProcessingModel -- typically, SNMP version
securityModel -- Security Model to use
securityName -- on behalf of this principal
LoS -- Level of Security requested
contextEngineID -- data from/at this entity
contextName -- data from/in this context
PDU -- SNMP Protocol Data Unit
expectResponse -- TRUE or FALSE
)
The messageEngine will generate the message according to the process described The SNMP engine checks the "expectResponse" parameter to determine if
in 7.2.2. it is a message which is expected to receive a response, and if so,
caches the msgID of the generated message and the associated
application.
7.2.4. Forward Received Response Message to an Orangelet The Message Processing Model generates the message according to the
process described in A.2.2.
The Message Processing and Control will receive the SNMP message A.2.4. Pass Received Response Message to an Application
according to the process described in 7.2.1.
The Message Processing and Control will determine which orangelet is The Message Processing Model receives the SNMP message according to
awaiting a response, using the msgID and the cached information from the process described in A.2.1.
step 7.2.3
The messageEngine matches the msgID of an incoming response to the cached The Message Processing Model determines which application is awaiting
msgIDs of messages sent by this messageEngine, and forwards the response to the this response, using the msgID and the cached information from
associated Orangelet using the process_pdu() primitive: step A.2.3
process_pdu( contextEngineID, contextName, pdu, LoS, scopedPdu-MMS, The Message Processing Model matches the msgID of an incoming response
securityModel, MIID, state-reference ) to the cached msgIDs of messages sent by this SNMP engine, and
forwards the response to the associated application using the
processResponsePdu primitive:
7.2.5. Forward Received Request or Notification Message to an Orangelet processResponsePdu( -- process Response PDU
contextEngineID -- data from/at this SNMP entity
contextName -- data from/in this context
PDU -- SNMP Protocol Data Unit
LoS -- Level of Security
statusInformation -- success or errorIndication
)
The messageEngine will receive the SNMP message according to the process A.2.5. Pass Received Request or Notification Message to Application
described in 7.2.1.
The messageEngine will look into the scopedPDU to determine the contextEngineID, The Message Processing Model receives the SNMP message according to
then determine which orangelet has registered to support that contextEngineID, the process described in A.2.1.
and forwards the request or notification to the registered Orangelet using the
process_pdu() primitive:
process_pdu( contextEngineID, contextName, pdu, LoS, scopedPdu-MMS, \
securityModel, MIID, state-reference )
7.2.6. Generate a Response Message for an Orangelet The SNMP engine looks into the scopedPDU to determine the
contextEngineID, then determine which application has registered to
support that contextEngineID, and forwards the request or notification
to the registered application using the processPdu primitive:
The messageEngine will receive a request for the generation of an SNMP response processPdu( -- process Request/Notification PDU
message from an orangelet via the return_pdu primitive: contextEngineID -- data from/at this SNMP engine
contextName -- data from/in this context
PDU -- SNMP Protocol Data Unit
maxSizeResponseScopedPDU -- maximum size of the Response PDU
securityModel -- Security Model in use
securityName -- on behalf of this principal
LoS -- Level of Security
stateReference -- reference to state information
) -- needed when sending a response
return_pdu( contextEngineID, contextName, LoS, MIID, state_reference, A.2.6. Generate a Response Message for an Application
PDU, PDU-MMS, status_code )
The messageEngine will generate the message according to the process described The SNMP engine receives a request for the generation of an SNMP
in 7.2.2. response message from an application via the returnResponsePdu
primitive:
7.3. Orangelet Model Design Requirements returnResponsePdu(
contextEngineID -- data from/at this SNMP engine
contextName -- data from/in this context
PDU -- SNMP Protocol Data Unit
maxSizeResponseScopedPDU -- maximum size of the Response PDU
securityModel -- Security Model in use
securityName -- on behalf of this principal
LoS -- Level of Security
stateReference -- reference to state information
-- as presented with the request
statusInformation -- success or errorIndication
) -- error counter OID/value if error
Within an Orangelet model, there may be an explicit binding to a specific The SNMP engine generates the message according to the process
SNMP message version, i.e. a specific Message Processing and Control model, described in A.2.2.
and to a specific Access Control model, but there should be no reference to
any data defined by a specific Message Processing and Control model or Access
Control model.
Within an Orangelet model, there should be no reference to any A.3. Application Design Requirements
specific Security model, or any data defined by a specific Security
model.
An Orangelet determines whether explicit or implicit access control Within an application, there may be an explicit binding to a specific
should be applied to the operation, and, if access control is needed, SNMP message version, i.e. a specific Message Processing Model, and to
which Access Control model should be used. 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.
An orangelet has the responsibility to define any MIB modules used Within an application, there should be no reference to any specific
to provide orangelet-specific services. Security Model, or any data defined by a specific Security Model.
Orangelets interact with the messageEngine to initiate messages, receive \
responses, receive asynchronous messages, and send responses.
7.3.1. Orangelets that Initiate Messages An application determines whether explicit or implicit access control
should be applied to the operation, and, if access control is needed,
which Access Control Model should be used.
Orangelets may request that the messageEngine send messages containing SNMP An application has the responsibility to define any MIB modules used
polling requests or notifications using the send_pdu() primitive: to provide application-specific services.
send_pdu( transportDomain, transportAddress, snmpVersion, Applications interact with the SNMP engine to initiate messages,
LoS, securityModel, MIID, contextEngineID, receive responses, receive asynchronous messages, and send responses.
contextName, PDU,
[DBH: I rearranged these parameters into groups of related data organized A.3.1. Applications that Initiate Messages
roughly by order of locality - transport/engine/contextEngine/PDU.]
Applications may request that the SNMP engine send messages containing
SNMP commands or notifications using the sendPdu primitive:
sendPdu(
transportDomain -- transport domain to be used
transportAddress -- destination network address
messageProcessingModel -- typically, SNMP version
securityModel -- Security Model to use
securityName -- on behalf of this principal
LoS -- Level of Security requested
contextEngineID -- data from/at this entity
contextName -- data from/in this context
PDU -- SNMP Protocol Data Unit
expectResponse -- TRUE or FALSE
)
If it is desired that a message be sent to multiple targets, it is the If it is desired that a message be sent to multiple targets, it is the
reponsibility of the orangelet to provide the iteration. responsibility of the application to provide the iteration.
The messageEngine assumes necessary access control has been applied The SNMP engine assumes necessary access control has been applied
to the PDU, and provides no access control services. to the PDU, and provides no access control services.
The SNMP engine looks at the "expectResponse" parameter, and for
operations which elicit a response, the msgID and the associated
application are cached.
The messageEngine looks at the verb, and for operations which will elicit a A.3.2. Applications that Receive Responses
response, the msgID and the associated orangelet are cached.
7.3.2. Orangelets that Receive Responses The SNMP engine matches the msgID of an incoming response to the
cached msgIDs of messages sent by this SNMP engine, and forwards the
response to the associated application using the processResponsePdu
primitive:
The messageEngine matches the msgID of an incoming response to the cached processResponsePdu( -- process Response PDU
msgIDs of messages sent by this messageEngine, and forwards the response to the contextEngineID -- data from/at this SNMP entity
associated Orangelet using the process_pdu() primitive: contextName -- data from/in this context
PDU -- SNMP Protocol Data Unit
LoS -- Level of Security
statusInformation -- success or errorIndication
process_pdu( contextEngineID, contextName, pdu, LoS, scopedPdu-MMS, \
securityModel, MIID, state-reference ) )
DBH: should the MPC release the state_reference when it receives a response? The SNMP engine then releases its own state information about this
There isn't much reason to force the orangelet to handle this if the MPC message.
already knows it is a response message, i.e. the end of a transaction.
7.3.3. Orangelets that Receive Asynchronous Messages A.3.3. Applications that Receive Asynchronous Messages
When a messageEngine receives a message that is not the response to a request When an SNMP engine receives a message that is not the response to a
from this messageEngine, it must determine to which Orangelet the message request from this SNMP engine, it must determine to which application
should be given. the message should be given.
An Orangelet that wishes to receive asynchronous messages registers An Application that wishes to receive asynchronous messages registers
itself with the messageEngine using the registration primitive. itself with the engine using the registration primitive.
An Orangelet that wishes to stop receiving asynchronous messages An Application that wishes to stop receiving asynchronous messages
should un-register itself with the messageEngine. should unregister itself with the SNMP engine.
register_contextEngineID ( contextEngineID ) statusInformation = -- success or errorIndication
unregister_contextEngineID ( contextEngineID ) registerContextEngineID(
contextEngineID -- take responsibility for this one
pduType -- the pduType(s) to be registered
)
Only one registration per contextEngineID is permitted at the same unregisterContextEngineID(
time. Duplicate registrations are ignored. contextEngineID -- give up responsibility for this one
pduType -- the pduType(s) to be unregistered
)
[DBH: there is no provision for an error for this. Is the second Only one registration per PDU type per contextEngineID is permitted
just ignored?] 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 referencing a registered contextEngineID All asynchronously received messages containing a registered
will be sent to the orangelet which registered to support that contextEngineID. PDU type and contextEngineID are sent to the application which
This includes incoming requests, incoming notifications, and proxies. registered to support that combination.
It forwards the PDU to the registered Orangelet, using the process_pdu() The engine forwards the PDU to the registered application, using the
primitive: processPdu primitive:
process_pdu( contextEngineID, contextName, PDU, PDU-MMS, processPdu( -- process Request/Notification PDU
LoS, securityModel, MIID, state_reference ) contextEngineID -- data from/at this SNMP engine
contextName -- data from/in this context
PDU -- SNMP Protocol Data Unit
maxSizeResponseScopedPDU -- maximum size of the Response PDU
securityModel -- Security Model in use
securityName -- on behalf of this principal
LoS -- Level of Security
stateReference -- reference to state information
) -- needed when sending a response
7.3.4. Orangelets that Send Responses A.3.4. Applications that Send Responses
Request operations require responses. These operations include Get requests, \
set requests, and inform requests. An Orangelet sends a response via the
return_pdu primitive:
return_pdu( contextEngineID, contextName, LoS, MIID, state_reference, Request operations require responses. These operations include Get
PDU, PDU-MMS, status_code ) requests, Set requests, and Inform requests. An application sends a
response via the returnResponsePdu primitive:
The contextEngineID, contextName, LoS, MIID, and state_reference parameters returnResponsePdu(
are from the initial process_pdu() primitive. The PDU and status_code are contextEngineID -- data from/at this SNMP engine
the results of processing. contextName -- data from/in this context
PDU -- SNMP Protocol Data Unit
maxSizeResponseScopedPDU -- maximum size of the Response PDU
securityModel -- on behalf of this principal
securityName -- on behalf of this principal
LoS -- Level of Security
stateReference -- reference to state information
-- as presented with the request
statusInformation -- success or errorIndication
) -- error counter OID/value if error
DBH: in the v2adv approach, a handle was passed so the messageEngine The contextEngineID, contextName, securityModel, securityName, LoS, and
could match the response to the incoming request. How is it done now? stateReference parameters are from the initial processPdu primitive.
The PDU and statusInformation are the results of processing.
7.4. Access Control Model Design Requirements A.4. Access Control Model Design Requirements
An Access Control model must determine whether the specified An Access Control Model determines whether the specified
MIID is allowed to perform the requested operation on securityName is allowed to perform the requested operation on
a specified managed object. The Access Control model specifies the a specified managed object. The Access Control Model specifies the
rules by which access control is determined. rules by which access control is determined.
A model may define mechanisms to provide additional processing
features, but is constrained to using the abstract data elements
defined in this document for transferring data between subsystems.
The persistent data used for access control should be manageable The persistent data used for access control should be manageable
using SNMP, but the Access Control model defines whether an using SNMP, but the Access Control model defines whether an
instantiation of the MIB is a conformance requirement. instantiation of the MIB is a conformance requirement.
8. Security Consideration The following primitive is used to invoke the access control service:
This document describes how a framework can use a Security model statusInformation = -- success or errorIndication
and a Local Processing model to achieve a level of security for isAccessAllowed(
network management messages and controlled access to data. securityModel -- Security Model in use
securityName -- principal who wants to access
LoS -- Level of Security
viewType -- read, write, or notify view
contextName -- context containing variableName
variableName -- OID for the managed object
)
The level of security provided is determined by the specific Security \
model implementation(s) and the specific Local Processing model
implementation(s) incorporated into this framework.
Orangelets have access to data which is not secured. Orangelets APPENDIX B
should take reasonable steps to protect the data from disclosure.
It is the responsibility of the purchaser of a management framework B. An Evolutionary Architecture - Design Goals
implementation to ensure that:
1) an implementation of this framework is fully compliant with
the rules defined by this architecture,
2) the implementation of the Security model complies with the
rules of the Security model,
3) the implementation of the Local Processing model complies
with the rules of the Local Processing model,
4) the implementation of associated orangelets comply
with the rules of this framework relative to orangelets,
5) the Security model of the implementation(s) incorporated into
the framework satisfy the security needs of the organization,
6) the Local Processing model of the implementation(s) incorporated
into the framework satisfy the access control policies of the
organization,
7) the implementation of the Security model protects against
inadvertently revealing security secrets in its design of
implementation-specific data structures,
8) the implementation of the Local Processing model protects against
inadvertently revealing configuration secrets in its design of
implementation-specific data structures,
9) and implementation of the orangelets protect security and
access control configuration secrets from disclosure.
9. Glossary The goals of the architectural design are to use encapsulation,
cohesion, hierarchical rules, and loose coupling to reduce complexity
of design and make the evolution of portions of the architecture
possible.
10. References B.1. Encapsulation
[RFC1155] Rose, M., and K. McCloghrie, "Structure and Identification of Encapsulation describes the practice of hiding the details that are
Management Information for TCP/IP-based internets", STD 16, RFC used internal to a process. Some data is required for a given
1155, May 1990. procedure, but isn't needed by any other part of the process.
[RFC1157] Case, J., M. Fedor, M. Schoffstall, and J. Davin, The Simple In networking, the concept of a layered stack reflects this approach.
Network Management Protocol", RFC 1157, University of Tennessee The transport layer contains data specific to its processing; the data
at Knoxville, Performance Systems International, Performance is not visible to the other layers. In programming this is reflected
International, and the MIT Laboratory for Computer in language elements such as "file static" variables in C, and
Science, May 1990. "private" in C++, etc.
[RFC1212] Rose, M., and K. McCloghrie, "Concise MIB Definitions", In this architecture, all data used for processing only within
STD 16, RFC 1212, March 1991. a functional portion of the architecture should have its visibility
restricted to that portion if possible. The data should be accessed
only by that functionality defined with the data. No reference to the
data should be made from outside the functional portion of the
architecture, except through predefined public interfaces.
[RFC1445] Galvin, J., and McCloghrie, K., "Administrative Model for B.2. Cohesion
version 2 of the Simple Network Management Protocol (SNMPv2)",
RFC 1445, Trusted Information Systems, Hughes LAN Systems,
April 1993.
[RFC1901] The SNMPv2 Working Group, Case, J., McCloghrie, K., Similar functions can be grouped together and their differences
Rose, M., and S., Waldbusser, "Introduction to ignored, so they can be dealt with as a single entity. It is important
Community-based SNMPv2", RFC 1901, January 1996. that the functions which are grouped together are actually similar.
Similarity of the data used to perform functions can be a good
indicator of the similarity of the functions.
[RFC1902] The SNMPv2 Working Group, Case, J., McCloghrie, K., For example, authentication and encryption are both security functions
Rose, M., and S., Waldbusser, "Structure of Management which are applied to a message. Access control, while similar in some
Information for Version 2 of the Simple Network Management ways, is dissimilar in that it is not applied to a message, it is
Protocol (SNMPv2)", RFC 1905, January 1996. applied to a (proposed) request for a management operation.
The data required to perform authentication and encryption are
different than the data needed to perform access control, and the
two sets of services can be described independently.
[RFC1903] The SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., Similar functions, especially those that use the same data elements,
and S. Waldbusser, "Textual Conventions for Version 2 of the Simple should be defined together. The security functions which operate at
Network Management Protocol (SNMPv2)", RFC 1903, January 1996. the message level should be defined in a document together with the
definitions for those data elements that are used only by those
security functions. For example, a MIB with authentication keys is
used only by authentication functions; they should be defined together.
[RFC1904] The SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., \
and S., Waldbusser, "Conformance Statements for Version 2 of the
Simple Network Management Protocol (SNMPv2)", RFC 1904,
January 1996.
[RFC1905] The SNMPv2 Working Group, Case, J., McCloghrie, K., B.3. Hierarchical Rules
Rose, M., and S., Waldbusser, "Protocol Operations for
Version 2 of the Simple Network Management Protocol (SNMPv2)",
RFC 1905, January 1996.
[RFC1906] The SNMPv2 Working Group, Case, J., McCloghrie, K., Functionality can be grouped into hierarchies where each element in the
Rose, M., and S. Waldbusser, "Transport Mappings for hierarchy receives general characteristics from its direct superior,
Version 2 of the Simple Network Management Protocol (SNMPv2)", and passes on those characteristics to each of its direct subordinates.
RFC 1906, January 1996.
[RFC1907] The SNMPv2 Working Group, Case, J., McCloghrie, K., This architecture uses the hierarchical approach by defining
Rose, M., and S. Waldbusser, "Management Information Base for subsystems, which specify the general rules of a portion of the system,
Version 2 of the Simple Network Management Protocol (SNMPv2)", models which define the specific rules to be followed by an
RFC 1907 January 1996. implementation of the portion of the system, and implementations which
encode those rules into reality for a portion of the system.
[RFC1908] The SNMPv2 Working Group, Case, J., McCloghrie, K., Within portions of the system, hierarchical relationships are used to
Rose, M., and S. Waldbusser, "Coexistence between Version 1 compartmentalize, or modularize, the implementation of specific
and Version 2 of the Internet-standard Network Management functionality. For example, within the security portion of the system,
Framework", RFC 1908, January 1996. authentication and privacy may be contained in separate modules, and
multiple authentication and privacy mechanisms may be supported by
allowing supplemental modules that provide protocol-specific
authentication and privacy services.
[RFC1909] McCloghrie, K., Editor, "An Administrative Infrastructure B.4. Coupling
for SNMPv2", RFC1909, February 1996
[RFC1910] Waters, G., Editor, "User-based Security Model for SNMPv2", Coupling describes the amount of interdependence between parts of
RFC1910, February 1996 a system. Loose coupling indicates that two sub-systems are relatively
independent of each other; tight coupling indicates a high degree of
mutual dependence.
11. Editor's Addresses To make it possible to evolve the architecture by replacing only part
of the system, or by supplementing existing portions with alternate
mechanisms for similar functionality, without obsoleting the complete
system, it is necessary to limit the coupling of the parts.
Co-editor: Bert Wijnen Encapsulation and cohesion help to reduce coupling by limiting the
IBM T.J. Watson Research visibility of those parts that are only needed within portions of a
postal: Schagen 33 system. Another mechanism is to constrain the nature of interactions
3461 GL Linschoten between various parts of the system.
Netherlands
email: wijnen@vnet.ibm.com
phone: +31-348-412-498
Co-editor Dave Harrington This can be done by defining fixed, generic, flexible interfaces
Cabletron Systems, Inc for transferring data between the parts of the system. The concept of
postal: Post Office Box 5005 plug-and-play hardware components is based on that type of interface
MailStop: Durham between the hardware component and system into which it is "plugged."
35 Industrial Way
Rochester NH 03867-5005
email: dbh@cabletron.com
phone: 603-337-7357
12. Acknowledgements This approach has been chosen so individual portions of the system
can be upgraded over time, while keeping the overall system intact.
This document builds on the work of the SNMP Security and To avoid specifying fixed interfaces, which would constrain a vendor's
Administrative Framework Evolution team, comprised of choice of implementation strategies, a set of abstract data elements
is used for (conceptually) transferring data between subsystems in
documents which describe subsystem or model interactions. Documents
describing the interaction of subsystems or models should use only
the abstract data elements provided for transferring data but vendors
David Harrington (Cabletron Systems Inc.) \
Jeff Johnson (Cisco)
David Levi (SNMP Research Inc.) are not constrained to using the described data elements for
John Linn (Openvision) transferring data between portions of their implementation.
Russ Mundy (Trusted Information Systems) chair
Shawn Routhier (Epilogue) Loose coupling works well with the IETF standards process. If we
Glenn Waters (Nortel) separate message-handling from security and from local processing,
Bert Wijnen (IBM T.J. Watson Research) then the separate portions of the system can move through the standards
process with less dependence on the status of the other portions of the
standard. Security models may be able to be re-opened for discussion
due to patents, new research, export laws, etc., as is clearly expected
by the WG, without needing to reopen the documents which detail the
message format or the local processing of PDUs. Thus, the standards
track status of related, but independent, documents is not affected.
\
Table of Contents Table of Contents
0. Issues 3 0. Issues 2
0.1. Issues to be resolved 3 0.1. Issues to be resolved 2
0.1.1. Issues discussed at second Interim Meeting: 2
0.2. Change Log 3 0.2. Change Log 3
1. Introduction 5 1. Introduction 7
1.1. A Note on Terminology 5 1.1. Target Audience 7
2. Overview 6 1.2. Management Systems 7
3. An Evolutionary Architecture - Design Goals 7 1.3. Goals of this Architecture 8
3.1. Encapsulation 7 1.4. Security Requirements of this Architecture 9
3.2. Cohesion 7 1.5. Design Decisions 10
3.3. Hierarchical Rules 8 2. Documentation Overview 12
3.4. Coupling 8 2.1. Document Roadmap 13
4. Abstract Functionality 10 2.2. Applicability Statement 13
4.1. The messageEngine 10 2.3. Coexistence and Transition 13
4.1.1. Transport Mappings 10 2.4. Transport Mappings 14
4.1.2. SNMP-Based Message Formats 10 2.5. Message Processing 14
4.1.3. The Interface to Orangelets 11 2.6. Security 14
4.1.4. Protocol Instrumentation 11 2.7. Access Control 14
4.2. Security 11 2.8. Applications 15
4.3. Orangelets 11 2.9. Structure of Management Information 15
4.4.1. Structure of Management Information 12 2.10. Textual Conventions 15
4.4.2. Textual Conventions 12 2.11. Conformance Statements 15
4.4.3. Conformance Statements 12 2.12. Protocol Operations 16
4.4.4. Protocol Operations 12 2.13. Management Information Base Modules 16
4.5. Access Control 13 2.13.1. SNMP Instrumentation MIBs 16
4.6. Coexistence 13 2.14. SNMP Framework Documents 16
5. Abstract Data Elements of the Architecture 14 3. Naming 18
5.1. engineID 14 3.1. The Naming of Entities 18
5.2. SecurityIdentity 14 3.1.1. SNMP entity 19
5.3. Model Independent Identifier (MIID) 14 3.1.2. SNMP engine 19
5.4. Level of Security 14 3.1.3. snmpEngineID 19
5.5. Contexts 15 3.1.4. Message Processing Subsystem 19
5.6. ContextName 15 3.1.5. Message Processing Model 19
5.7. ContextEngineID 15 3.1.6. Security Subsystem 20
5.8. Naming Scope 15 3.1.7. Security Model 20
5.9. Scoped-PDU 15 3.1.8. Security Protocol 20
5.10. PDU-MMS 15 3.1.9. Access Control Subsystem 21
5.11. Local Configuration Datastore 15 3.1.10. Access Control Model 21
5.11.1. Security Portion of the Local Configuration Datastore 16 3.1.11. Applications 21
5.11.2. Orangelet Portion of the Local Configuration Datastore 16 3.1.12. SNMP Agent 21
5.11.3. Access Control Portion of the Local Configuration Datastore 16 3.1.13. SNMP Manager 21
5.12. Groups 16 3.2. The Naming of Identities 22
6. Definition of Managed Objects for Internet Management Frameworks 17 3.2.1. Principal 22
7. Model Design Requirements 24 3.2.2. securityName 22
7.1. Security Model Design Requirements 24 3.2.3. Model dependent security ID 22
7.1.1. Threats 24 3.3. The Naming of Management Information 23
7.1.2. Security Processing 25 3.3.1. An SNMP Context 24
7.1.3. validate the security-stamp in a received message 26 3.3.2. contextEngineID 24
7.1.4. Security Identity 27 3.3.3. contextName 24
7.1.5. Model Dependent Identifier 27 3.3.4. scopedPDU 24
7.1.6. Model Independent Identifier 27 3.4. Other Constructs 25
7.1.5. Security MIBs 28
7.1.6. Security State Cacheing 28 \^L
7.2. MessageEngine and Message Processing and Control Model Requirements 28
7.2.1. Receiving an SNMP Message from the Network 29 3.4.1. maxSizeResponseScopedPDU 25
7.2.2. Send SNMP messages to the network 29 3.4.2. Local Configuration Datastore 25
7.2.3. Generate a Request or Notification Message for an Orangelet 30 3.4.3. LoS 25
7.2.4. Forward Received Response Message to an Orangelet 30 4. Architectural Elements of Procedure 26
7.2.5. Forward Received Request or Notification Message to an Orangelet 30 4.1. Operational Overview 27
7.2.6. Generate a Response Message for an Orangelet 31 4.2. Sending and Receiving SNMP Messages 29
7.3. Orangelet Model Design Requirements 31 4.2.1. Send a Message to the Network 29
7.3.1. Orangelets that Initiate Messages 31 4.2.2. Receive a Message from the Network 29
7.3.2. Orangelets that Receive Responses 32 4.3. Send a Request or Notification Message for an Application 30
7.3.3. Orangelets that Receive Asynchronous Messages 32 4.4. Receive a Request or Notification Message from the Network 30
7.3.4. Orangelets that Send Responses 32 4.5. Generate a Response Message for an Application 31
7.4. Access Control Model Design Requirements 33 4.6. Receive a Response Message 31
8. Security Consideration 34 4.7. Registering to Receive Asynchronous Messages 31
9. Glossary 35 5. Definition of Managed Objects for Internet Management Frameworks 33
10. References 36 6. Security Considerations 39
11. Editor's Addresses 38 7. Glossary 40
12. Acknowledgements 39 8. References 40
9. Editor's Addresses 42
10. Acknowledgements 43
A. Guidelines for Model Designers 44
A.1. Security Model Design Requirements 44
A.1.1. Threats 44
A.1.2. Security Processing 45
A.1.3. validate the security-stamp in a received message 45
A.1.5. Security MIBs 46
A.1.6. Security State Cache 46
A.2. SNMP engine and Message Processing Model Requirements 48
A.2.1. Receiving an SNMP Message from the Network 48
A.2.2. Send SNMP messages to the network 49
A.2.3. Generate Request or Notification Message for an Application 49
A.2.4. Pass Received Response Message to an Application 50
A.2.5. Pass Received Request or Notification Message to Application 50
A.2.6. Generate a Response Message for an Application 51
A.3. Application Design Requirements 51
A.3.1. Applications that Initiate Messages 52
A.3.2. Applications that Receive Responses 52
A.3.3. Applications that Receive Asynchronous Messages 53
A.3.4. Applications that Send Responses 53
A.4. Access Control Model Design Requirements 54
 End of changes. 326 change blocks. 
966 lines changed or deleted 2045 lines changed or added

This html diff was produced by rfcdiff 1.33. The latest version is available from http://tools.ietf.org/tools/rfcdiff/