stracts.txt''
                     An Architecture for Describing
                       SNMP Management Frameworks

                              1 August 1997

                              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-04.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 Internet-Drafts Shadow
Directories on ds.internic.net (US East Coast), nic.nordu.net (Europe),
ftp.isi.edu (US West Coast), or munnari.oz.au (Pacific Rim).

                              Abstract

This document describes an architecture for describing Internet SNMP Management
Frameworks. The architecture is designed to be modular to allow the
evolution of the SNMP protocol standards over time. The major portions
of the architecture are an SNMP engine containing a Message Processing
subsystem,
Subsystem, a Security Subsystem and an Access Control Subsystem, and
possibly multiple SNMP applications which provide specific functional
processing of network management data. These SNMP applications are
of various types, including Command Generator and Command Responder
applications, Notification Originator and Notification Receiver
applications, and Proxy Forwarding applications.

Harrington/Wijnen         Expires  December 1997  February 1998              [Page  1]
\

0. Issues

0.1. Resolved Issues to be resolved
  . OID or Integer for auth/priv protocol identifiers
    second interim meeting reached consensus on OIDs
    some mailing list members still say Integers preferred
  . forward references need to be handled
 . Is Glossary needed to describe primitive parameters, or is the
    expanded template adequate for this purpose? contextEngineID in reportPDU = snmpEngineID of report generator
 . state_reference releases returnResponsePDU - are these consistently defined?
    check documents. all parameters needed? overrides allowed?
    all parameters kept for future flexibility
    overrides not supported by SNMPv3
 . discuss utf8. -  probably open WG discussion use of IN/OUT indicators in Munich per NMAD
    discuss tomorrow; remains open issue. primitives accepted
 . NT/Unix-like access control - can be defined as future model
 . user-friendly names? yes, but with limits
 . SnmpAdminString as index? yes, but restrict sizes
 . need mechanism to discover securityModels supported both MMS and maxSizeResponseScopedPDU? yes.
 . new SnmpEngineID format rules synchronous vs. asynchronous primitives? synchronous preferred
 . should we change MIB naming? no, it is acceptable
 . is it ok that USM is bound to SNMPv3? while undesirable, it is
   acceptable. A cleaner model may be discussed yet. defined in the future.
 . needs changes to meet STDGUIDE guidelines should securityModel "any" be supported? for ACM use, not SNMPv3
 . add what defines SNMPv3? a "Decision History" section (as document will be published after Munich
 . Is an appendix?) application-level handle needed for request/response matching?
   yes. create sendPduhandle
 . Is wildcard contextEngineID/pduType registration needed? No. This is
   an internal interface, and wildcarding can be supported by an
   implementation, but is not required in the standard.
 . Should indices be integers or SnmpAdminStrings? SnmpAdminStrings
   is the consensus.
 . Should protocols be identified as OIDs or Integers? OIDs
 . terminology:
    securityLevel rather than LoS
    msgXXXX to identify message fields in SNMPv3
 . OID or Integer for auth/priv protocol identifiers
   Consensus: use OID
 . Is Glossary needed to describe primitive parameters, or is the
   expanded template adequate for this purpose?
   Consensus: Terms are basically all defined in section 3.
 . state_reference releases
   Consensus: documents checked; we think it is OK now
 . new SnmpEngineID format rules to be discussed yet.
   Consensus: Limit size to be 1..32
 . needs changes to meet STDGUIDE guidelines
   We think we're meeting them now
 . we punted snmpEngineMaxMessageSize at 2nd interim because that
   info travels in each SNMPv3 message. However, we may want to
   re-introduce it so that SNMPv1/v2c managers can learn the value!!
   Consensus: Nobody picked up on this, so it seems not needed.
 . Do we need a mechanism to discover securityModels supported
   Can be decided after Munich
 . add a "Decision History" section (as an appendix?)
   Can be decided after Munich

Harrington/Wijnen         Expires  February 1998              [Page  2]

0.1.1. Issues discussed at second Interim Meeting:

 . A "readable" introduction supplement may be done after Munich.
 . Applications are responsible for retries, but implementations may
     differ.
 . TCs should not be defined just to describe primitive parameters.
   If they cannot be described adequately in text, they can be defined
   in a Glossary. Avoid describing implementation details.
 . 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  February 1998              [Page  2]
\  3]

0.2.  Change Log

[version 4.4] 4.14]
 . Fixed one error in the MIB (found with SMICng) formatting
 . Reformatted text for SnmpAdminString, no change in text. pagination
[version 4.13]
 . Changed text for SnmpEngineID..  this is still under discussion.
   But this new text seems to be getting close to what we want. acknowledgements
 . Added an issue w.r.t. snmpEngineMaxMessageSize updated references
 . adapt Primitive names and parameters to very latest (july 11) names updated issues list
 . removed blank lines before the .p page controls.

[version 4.3] ordered security, editors, acknowledgements, references sections
 . some minor editing adjustments checked line lengths
[version 4.2] 4.12]
 . modify abstract so there is no requirement for one entity
    to contain both a command generator and a notification receiver. cleanup
 . modify Introduction list of entities which are meant added expectResponse to be
   supported processIncomingMsg to address Levi-raised
   concern
 . reorganized sections 1 through 4 for more consistency in contents. acknowledgements
 . described section contents in Introduction:Target Audience MIB checked by SMICng
 . move documentation descriptions post to section 2 snmpv3 mailing list
[version 4.11]
 . rewrite section 4 Change Primitives between MP and SEC to be more like a real elements try and address the issue
   of procedure. architectural binding to message format.
 . modified SnmpSecurityModel Added securityName and SnmpEngineID definitions securityLevel to the returnResponsePdu
   primitive so that architecturally it could be different for a
   request and a response.
 . replaced MIB with Bert's replacement Rename processMsg primitive to processIncomingMsg

[version 4.10]
 . added Randy's TC for SnmpAdminString spell check

[version 4.9]
 . modified the example algorithm text for editorial changes
 . fix SnmpEngineID TC
 . rewrote security considerations for brevity. add a note to SnmpAdminString
 . modified "context" rename title of section 1.1
 . expand description of Dispatcher a bit

[version 4.8]
 . moved "Threats" to Goals/Requirements Added parameter pduVersion on primitives:
         sendPdu
         processPdu
         returnResponsePdu
         processResponsePdu
         prepareDataElements
         prepareOutgoingMessage
         prepareResponseMessage
 . eliminated snmpEngineMaxMessageSize object Added parameter messageProcessingModel on the primitive:
         processPdu
         processResponsePdu
         returnResponsePdu
 . posted Removed messageProcessingModel parameter from primitives:
         registerContextEngineID

Harrington/Wijnen         Expires  February 1998              [Page  4]
         unregisterContextEngineID
 . Renamed SNMP Version Multiplexer to snmpv3 (by DBH)

[version 4.1] Dispatcher
 . Adopt "abstract" Renamed Version Multiplexer to new terminology Message Multiplexer
 . Addressed all comments I (BW) made Renamed Application Multiplexer to DBH PDU Dispatcher
 . Rearranged some parameters in an earlier email various Primitives so the sequence
   of parameters is now more consistent.

[version 4.7]
 . Changed Introduction section editorial cleanup
 . changed asterisk text
 . modified snmpv3 framework description to new terminology eliminate dependencies
 . reorder 4.2.x to reflect transaction order
 . changed wording for "implementation" SnmpEngineID size to indicate it may contain
   multiple models. 1..32

[version 4.6]
 . Section 2. Started some wording on Goals and Design decisions Changes to use synchronous primitives where possible
 . Added the overview picture of a traditional agent and a
   traditional manager. This is in section 2. Changes to describe SNMP Version Multiplexer
 . Changed overview Remove (empty) glossary
 . Redraw documentation figure in
 . Redraw Operational Overview Figure
 . Remove old section 3. 4 (Architectural Elements of Procedure)
   These moved to address the comments
   by Dave Levi. It now lists MP document into the type SNMP Version Multiplexer
   section.
 . Move Overview of applications all primitives from Appendix to Section 4.
 . At various places ensure that text (easily) fits within 72
   columns as required by RFC-editors Simplify Appendix A to just described Model Designer Guidelines document.
   and refer back to section 4 for specific primitives
 . 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. Remove Appendix B (An Evolutionary Architecture - Design Goals)
 . Section 2.4 (new section) gives overview of SNMP entities based
   on modified Dave Levi figure. I (Bert) wonder however if added design decision regarding security
 . Included latest Snmp SecurityModel TC (as it would

Harrington/Wijnen         Expires  December 1997              [Page  3]
\
   not be better was actually posted
   to move it the SNMPv3 mailing list).

[version 4.5]
 . start with <draft-ietf-snmpv3-next-gen-arch-03.txt>
 . change vendor to after section 3.1.13 implementor
 . Section 3. Added more figures... please let us know if you find
   then useful and/or helpful. We could also move these back change LoS to
   section 2 if such makes more sense. securityLevel
 . Added a picture in section 3.2.
   It also shows some remove mention of access control, so not sure it really fits
   here, although it does map principal enterprise
 . change Internet Management Framework to model dependent security
   ID to securityName
 . Replace "<" with "is lower than" in section 3.4.3 which seems
   better in a text document. SNMP Management Framework
 . Renamed section 4.1 to "SNMP engine processing" instead modify usage 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 "frameworks" to a improve internal consistency.
 . change Message Processing Subsystem. Abstract Service Interface to
   Application Multiplexor
 . "bulletized" some stuff in section 4.2 change description of SNMP engine
 . moved "one-to-one association" for entity and 4.3.
   Dave, this is just how I (Bert) like it better. Feel free engine to
   undo it if you strongly disagree discussion
   of engine.
 . Section 4.3 changed "initiate a transaction" distributing to "originate a
   notification". dispatching
 . 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 added asterisks to lump SMI,
   TC and Conformance together. indicate v3* items are also not required.
 . Inserted a title for section 4.5 named "Operational Model" changed "community access control" to
   get "other access control"
 . added TC for SnmpMessageProcessingModel
 . modified Security Considerations
 . modified acknowledgements

[version 4.4]

Harrington/Wijnen         Expires  February 1998              [Page  5]
 . Fixed one error in sync with the the lumping together of ProtoOps and Transport
   Mappings MIB (found with SMICng)
 . Reformatted text for SnmpAdminString, no change in document overview text.
 . Renumber section 4.4.4 Changed text for SnmpEngineID..  this is still under discussion.
   But this new text seems to 4,5,1 and added 4.5.2 be getting close to follow the
   document overview figure. If we really want to follow it, then
   maybe what we should also reorder some of these sections. Like
   Access Control seems specifically misplaced. So I decided want.
 . Added an issue w.r.t. snmpEngineMaxMessageSize
 . adapt Primitive names and parameters to move
   it very latest (july 11) names
 . removed blank lines before applications as section 4.3, so the 4.x above should
   all be read .p page controls.
 . publish as 4.x+1 <draft-ietf-snmpv3-next-gen-arch-03.txt>

[version 4.3]
 . Removed size from SnmpEngineID TC... why did you limit it to
   (0..2048). Did we not decide to leave it open? some minor editing adjustments
[version 4.2]
 . Should we not remove snmpEngineMaxMessageSize from the MIB.
   That was agreed at 2nd interim. It travels in every message and modify abstract so
   seems there is no requirement for one entity
    to be useless. However, I think it could indeed still help
   SNMPv1 or SNMPv2c managers. contain both a command generator and a notification receiver.
 . I kept your definitions modify Introduction list 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 entities which are meant to be done
   supported
 . reorganized sections 1 through 4 for more consistency in SEC document. contents.
 . Modified Security Considerations. Was still talking about LPM. described section contents in Introduction:Target Audience
 . Appendix. I am still wondering if we need move documentation descriptions to use capitals for
   things section 2
 . rewrite section 4 to be more like "Security Model" "Subsystem" a real elements of procedure.
 . modified SnmpSecurityModel 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). SnmpEngineID definitions
 . Appendix, renamed imf to snmpFramework replaced MIB with Bert's replacement
 . Appendix, changed state_reference and state_release added Randy's TC for SnmpAdminString
 . modified the example algorithm text for SnmpEngineID
 . rewrote security considerations for brevity.
 . modified "context" description
 . moved "Threats" to
   stateReference and stateRelease Goals/Requirements
 . eliminated snmpEngineMaxMessageSize object
 . posted to be consistent with other names
   for abstract data and primitives.

Harrington/Wijnen         Expires  December 1997              [Page  4]
\ snmpv3 (by DBH)
[version 4.1]
 . A.2 changed MessageEngine Adopt "abstract" to SNMP engine new terminology
 . Fixed ASI primitives Addressed all comments I (BW) made to be DBH in sync with SEC document.
   I also thought that our ARCH document-outline wanted an earlier email
 . Changed Introduction section to at least
   have the primitives listed within the main body of the text, no? new terminology
 . Adapted send_pdu changed wording for "implementation" to sendPdu primitive as reconciled by Randy
   In fact I made sure all primitives are in-line with current
   agreement indicate it may contain
   multiple models.
 . Section 2. Started some wording on names Goals and parameters. Design decisions
 . Rename title Added the overview picture of A.2.4 a traditional agent and A.2.5 so it fits on 1 line in contents
 . I did not look at appendix B. That is your (DBH) specialty a
   traditional manager. This is it
   not ?  ;-).
 . Quick simple spell check done with "spell" on AIX

[version 4.0] in section 2.
 . move Changed overview figure in section 7 - Model Requirements 3. to an appendix
 . move Section 3 - Design Goals to an appendix
 . modified Section 5 - Naming address the comments
   by Dave Levi. It now lists the type of applications
 . remove "possibly multiple" At various places ensure that text (easily) fits within 72
   columns as required by RFC-editors Guidelines document.
 . moved Section 5 to Section 3
 . change orangelets to applications 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.
 . modify description Section 2.4 (new section) gives overview of applications
 . change scopedPDU-MMS and PDU-MMS SNMP entities based
   on modified Dave Levi figure. I (Bert) wonder however if it would
   not be better to maxSizeResponseScopedPDU
 . change Scoped-PDU and ScopedPDU move it to scopedPDU (no dash, lower case S) after section 3.1.13
 . change imfxxx Section 3. Added more figures... please let us know if you find
   then useful and/or helpful. We could also move these back to snmpFrameworkxxx
   section 2 if such makes more sense.

Harrington/Wijnen         Expires  February 1998              [Page  6]
 . change security-entity to 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
 . change securityIdentity to securityName
 . change MIID model dependent security
   ID 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 Replace "<" with "is lower than" in MIBs - securityIdentity TC etc section 3.4.3 which seems
   better in a text document.
 . changed Message Renamed section 4.1 to "SNMP engine processing" instead of
   "The Message Processing Subsystem" because the transport
   mappings, mpc multiplexor and Control 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.
 . changed future tense "bulletized" some stuff in section 4.2 and 4.3.
   Dave, this is just how I (Bert) like it better. Feel free to present tense
 . eliminate messageEngine
   undo it if you strongly disagree
 . added/updated primitives Section 4.3 changed "initiate a transaction" to "originate a
   notification".
 . addressed issues raised on Inserted title line for section 4.4 (I think it was missing)
   I have named it "Information Model" in accordance with the mailing list

[version 3.1]
 . change securityIdentity to MIID
 . write text to explain
   I made (after Russ's comments) in the differences between security-identities,
   model-dependent identifiers, document figure to lump SMI,
   TC and model-independent identifiers. Conformance together.
 . write text Inserted a title for section 4.5 named "Operational Model" to explain distinction within the LCD of
   get in sync with the security
   data, the access control data, lumping together of ProtoOps and the orangelet data.
 . identify issues
 . publish as <draft-ietf-snmpv3-next-gen-arch-02.txt>

[version 3.0]
 . add section on threats for message security Transport
   Mappings in document overview
 . add Renumber section on threats for access control
 . change application to orangelet
 . remove references to F-Ts
 . change securityIdentity 4.4.4 to security-identity

Harrington/Wijnen         Expires  December 1997              [Page  5]
\
 . change securityCookie 4,5,1 and added 4.5.2 to securityIdentity
 . the format of securityIdentity is defined by follow the model
 . add securityModel
   document overview figure. If we really want to passed parameters 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 needed section 4.3, so the 4.x above should
   all be read as 4.x+1
 . eliminate group Removed size from passed parameters
 . remove unused IMPORTS
 . add glossary section with initial set of words SnmpEngineID TC... why did you limit it to define
   (0..2048). Did we not decide to leave it open?
 . differentiate the messageEngine Should we not remove snmpEngineMaxMessageSize from the contextEngine
 . eliminate the term SNMPng 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.
 . rewrote 1.1. A Note on Terminology 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.
 . eliminated assumptions Modified Security Considerations. Was still talking about SNMP processing always being
    message related LPM.
 . rewrote 4.x Appendix. I am still wondering if we need to reflect new thinking 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).
 . rewrote 5.x Appendix, renamed imf to reflect new thinking snmpFramework
 . rewrote 6.x (the MIB) Appendix, changed state_reference and state_release to reflect new thinking
   stateReference and stateRelease to be consistent with other names
   for abstract data and primitives.
 . added MIB objects at this level (previously only TCs)
 . rewrote 7.x
 . sent to v3edit list

Harrington/Wijnen         Expires  December 1997              [Page  6]
\

1. Introduction

1.1. Target Audience

This document will have as its audience persons with varying levels
of technical understanding of SNMP.

This document does not provide a general introduction A.2 changed MessageEngine to SNMP. Other
documents and books can provide a much better introduction SNMP engine
 . Fixed ASI primitives 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 sync with SEC document.
   I also provides
a minimal roadmap thought that our ARCH document-outline wanted to the documents which at least
   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 primitives listed within this
architecture.

Section 4 describes the elements main body of procedure followed by an SNMP
engine in coordinating the processing of messages text, no?

Harrington/Wijnen         Expires  February 1998              [Page  7]
 . Adapted send_pdu to sendPdu primitive as reconciled by the subsystems Randy
   In fact I made sure all primitives are in-line with current
   agreement on names and parameters.
 . Rename title of the engine A.2.4 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 A.2.5 so it fits on 1 line 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 contents
 . I did not look at appendix B. That is your (DBH) specialty is it
   not ?  ;-).
 . Quick simple spell check done with an SNMP entity
      containing command responder and notification originator
      applications, which have access "spell" on AIX
[version 4.0]
 . move section 7 - Model Requirements to management instrumentation;

Harrington/Wijnen         Expires  December 1997              [Page  7]
\ an appendix
 . move Section 3 - at least one SNMP entity containing command generator and/or
      notification receiver applications; and, Design Goals to an appendix
 . modified Section 5 - a management protocol, used Naming
 . remove "possibly multiple"
 . moved Section 5 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 Section 3
 . change orangelets to their management
  information.

  Operations applications
 . modify description of the protocol are carried out under an administrative
  framework which defines minimum requirements for standard services,
  such as sending applications
 . change scopedPDU-MMS and receiving messages, countering security threats PDU-MMS to messages, controlling access maxSizeResponseScopedPDU
 . change Scoped-PDU and ScopedPDU to managed objects, 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 processing
  various types of requests.

  It is Control to Message Processing
 . changed future tense to present tense
 . eliminate messageEngine
 . added/updated primitives
 . addressed issues raised on the purpose of this document mailing list

[version 3.1]
 . change securityIdentity to define an architecture which
  can evolve MIID
 . write text to realize effective network management in a variety explain the differences between security-identities,
   model-dependent identifiers, and model-independent identifiers.
 . write text to explain distinction within the LCD of configurations the security
   data, the access control data, and environments. The architecture has been
  designed the orangelet data.
 . identify issues
 . publish as <draft-ietf-snmpv3-next-gen-arch-02.txt>

[version 3.0]
 . add section on threats for message security
 . add section on threats for access control
 . change application to meet orangelet
 . remove references to F-Ts
 . change securityIdentity to security-identity
 . change securityCookie to securityIdentity
 . the needs format of implementations of:
    - minimal SNMP entities securityIdentity is defined by the model
 . add securityModel to passed parameters as needed
 . eliminate group from passed parameters
 . remove unused IMPORTS

Harrington/Wijnen         Expires  February 1998              [Page  8]
 . add glossary section with command responder and/or notification
      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.3. Goals initial set 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 words to move portions of define
 . differentiate the architecture forward
     in messageEngine from the standards track, even if consensus has not been reached
     on all pieces.
   - Define an architecture that allows for longevity of contextEngine
 . eliminate the term SNMPng
 . rewrote 1.1. A Note on Terminology
 . eliminated assumptions about 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 processing always being
    message related
 . rewrote 4.x to deploy a minimal conformant
     implementation
   - Make it possible reflect new thinking
 . rewrote 5.x to upgrade portions of a framework as reflect new
     approaches become available, without disrupting the entire
     framework.
   - Make it possible thinking
 . rewrote 6.x (the MIB) to support features required in large networks,
     but make the expense reflect new thinking
 . added MIB objects at this level (previously only TCs)
 . rewrote 7.x
 . sent to v3edit list

Harrington/Wijnen         Expires  February 1998              [Page  9]

1. Introduction

1.1. Overview

This document assumes an audience with varying levels of supporting technical
understanding of SNMP.

This document does not provide a feature directly related 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 defines a vocabulary for describing SNMP Management
Frameworks, and an architecture for describing the support major portions of
SNMP Management Frameworks.

Section 1 describes the feature.

1.4. Security Requirements purpose, goals, and design decisions of
this Architecture

Several architecture.

Section 2 describes various types of the classical threats to network protocols are applicable
to the network management problem documents which define SNMP
Frameworks, and therefore would be applicable
to any Security Model used in an Internet Management Framework. Other
threats are not applicable how they fit into this architecture. It also provides
a minimal roadmap to the network management problem. documents which have previously defined
SNMP frameworks.

Section 3 details the vocabulary of this architecture and its pieces.
This section discusses principal threats, secondary threats, is important for understanding the remaining sections,
and threats for understanding documents which are of lesser importance.

The principal threats against which any Security Model used written to fit within this architecture SHOULD provide protection are:

Modification of Information
    The modification threat is
architecture.

Section 4 describes the danger that some unauthorized SNMP
    entity may alter in-transit primitives used for the abstract service
interfaces between the various subsystems, models and applications
within this architecture.

Section 5 defines a collection of managed objects used to instrument
SNMP messages generated on behalf entities within this architecture.

Sections 6, 7, 8, and 9 are administrative in nature.

Appendix A contains guidelines for designers of Models which are
expected to fit within this architecture.

1.2. SNMP Management Systems

  An SNMP management system contains:
    - several (potentially many) nodes, each with an authorized principal in such SNMP entity
      containing command responder and notification originator
      applications, which have access to management instrumentation;
    - at least one SNMP entity containing command generator and/or
      notification receiver applications; and,
    - a way 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 effect unauthorized their management operations, including falsifying
  information.

  It is the value purpose of this document to define an object.

Masquerade
    The masquerade threat is the danger that architecture which
  can evolve to realize effective network management operations
    not authorized for some principal may be attempted by assuming
    the identity in a variety
  of another principal that configurations and environments. The architecture has been
  designed to meet the appropriate
    authorizations.

Message Stream Modification
    The needs of implementations of:
    - minimal SNMP protocol is typically based upon a connectionless
    transport service which may operate over any subnetwork service.
    The re-ordering, delay entities with command responder and/or notification
      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 replay of messages can
      dual-role entities),
    - SNMP entities with command generator and/or notification
      receiver and does occur
    through the natural operation possibly other types of many such subnetwork services.
    The message stream modification threat applications for managing
      a potentially very large number of managed nodes (traditionally
      called network management stations).

1.3. Goals of this Architecture

This architecture was driven by 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 danger that messages
    may be maliciously re-ordered, delayed or replayed to an extent need for secure SET support, which is greater than can occur through considered
     the natural operation of
    a subnetwork service, most important deficiency in order SNMPv1 and SNMPv2c.
   - Make it possible to effect unauthorized management
    operations.

Disclosure
    The disclosure threat is the danger move portions of eavesdropping 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
    exchanges between SNMP engines.  Protecting against this threat
    may
     Frameworks that have been and will be required as a matter defined.
   - Keep SNMP as simple as possible.
   - Make it relatively inexpensive to deploy a minimal conformant
     implementation
   - Make it possible to upgrade portions of local policy.

Harrington/Wijnen         Expires  December 1997              [Page  9]
\

There SNMP as new approaches
     become available, without disrupting an entire SNMP framework.
   - Make it possible to support features required in large networks,
     but make the expense of supporting a feature directly related
     to the support of the feature.

1.4. Security Requirements of this Architecture

Several of the classical threats to network protocols are at least two applicable
to the network management problem and therefore would be applicable
to any Security Model used in an SNMP 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 a any Security Model used by
a framework within
this architecture need not protect.

Denial SHOULD provide protection are:

Modification of Service
    A Security Model need not attempt to address Information
   The modification threat is the broad range of
    attacks by which service danger that some unauthorized SNMP
   entity may alter in-transit SNMP messages generated on behalf of
   an authorized users is denied.
    Indeed, such denial-of-service attacks are principal in many cases
    indistinguishable from such a way as to effect unauthorized
   management operations, including falsifying the type value of network failures with which any
    viable network an object.

Masquerade
   The masquerade threat is the danger that management protocol must cope as a matter of course.

Traffic Analysis
    A Security Model need operations
   not attempt to address traffic analysis
    attacks.  Many traffic patterns are predictable - authorized for some principal may be attempted by assuming
   the identity of another principal that has the appropriate
   authorizations.

Message Stream Modification
   The SNMP protocol is typically based upon a connectionless
   transport service which may operate over any subnetwork service.
   The re-ordering, delay or replay of messages can and does occur
   through the natural operation of many such subnetwork services.
   The message stream modification threat is the danger that messages
   may be maliciously re-ordered, delayed or replayed to an extent
   which is greater than can occur through the natural operation of
   a subnetwork service, in order to effect unauthorized management
   operations.

Disclosure
   The disclosure threat is the danger of eavesdropping on the
   exchanges between SNMP engines.  Protecting against this threat
   may be required as a matter of local policy.

There are at least two threats against which a Security Model 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: the goals of the
architecture and the security requirements:

   - Architecture
     An architecture should be defined which identifies the conceptual
     boundaries between the documents of a framework. documents. Subsystems should be defined
     which describe the abstract services provided by specific
     portions of the an SNMP framework. Abstract service interfaces, as
     described by service primitives, define the abstract boundaries
     between documents, and the abstract services that are provided
     by the conceptual subsystems of a an SNMP framework.

   - Self-contained Documents
     Elements of procedure plus the MIB objects which are needed for
     processing for a specific portion of a an SNMP 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 SNMP are not directly impacted. This modularity
     allows, for example, Security Models, authentication and privacy
     mechanisms, and message formats to be upgraded and supplemented
     as the need arises. The self-contained documents can move along
     the standards track on different time-lines.

   - Remote Configuration The Security and Access Control Models in the Security Subsystem SHOULD protect
     against the principal threats: modification of information,
     masquerade, message stream modification and disclosure.
     They do not need to protect against denial of service and
     traffic analysis.

   - Remote Configuration
     The Security and Access Control Subsystems add a whole new set
     of SNMP configuration parameters.  The Security Subsystem also
     requires frequent changes of secrets at the various SNMP
     entities. To make this deployable in a large operational

\
     environment, these SNMP parameters must be able to be remotely
     configured.

   - Controlled Complexity
     It is recognized that 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             | |
 | |                   |  |                                         | |
 | | +-------------+   |  | +------------+ +----------+ +---------+ | |
 | | |             |   |  | | +----------------------------------------------------------------+ |
 | | Message Handling                                               | |
 | | +-----------------+  +-----------------+  +-----------------+  | |
 | Protocol | | Transport       |  | Message         |  | Security        |  | Access  | | |
 | |
 | Operations | | Mappings        |  | Processing and  |  |                 |  | Control | | |
 | | +-------------+   | | +------------+ +----------+ +---------+
 | | |                 | +-------------+  | Dispatching     |  |                 |  | |
 | | +-----------------+  +-----------------+  +-----------------+  | | +--------------+           +----------+
 | +----------------------------------------------------------------+ |
 |                                                                    |
 | Transport +----------------------------------------------------------------+ |
 | | PDU Handling                                                   | |
 | | +-----------------+  +-----------------+  +-----------------+  | |
 | | | Mappings Protocol        |  | Applications    |  | Applications Access          | .........  | |
 | | | Operations      | +-------------+  |                 | +--------------+           +----------+  | Control         |  | |
 | | +-----------------+  +-----------------+  +-----------------+  | |
 | +-------------------+  +-----------------------------------------+ +----------------------------------------------------------------+ |
 |                                                                    |
 | +----------------------------------------------------------------+ |
 | | Information Model                                              | |
 | |                                                                | |
 | | +--------------+    +--------------+    +---------------+      | |
 | | | Structure of |    | Textual      |    | Conformance   |      | |
 | | | Management   |    | Conventions  |    | Statements    |      | |
 | | | Information  |    |              |    |               |      | |
 | | +--------------+    +--------------+    +---------------+      | |
 | +----------------------------------------------------------------+ |
 |                                                                    |
 | +----------------------------------------------------------------+ |
 | | MIBs                                                           | |
 | |                                                                | |
 | | +-------------+ +-------------+ +----------+ +----------+      | |
 | | | Standard v1 | | Standard v1 | | Historic | | Draft v2 |      | |
 | | | RFC1157     | | RFC1212     | | RFC14xx  | | RFC19xx  |      | |
 | | | format      | | format      | | format   | | format   |      | |
 | | +-------------+ +-------------+ +----------+ +----------+      | |
 | +----------------------------------------------------------------+ |
 |                                                                    |
 +--------------------------------------------------------------------+

\

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 area of Message and Administration area. PDU handling.

2.1. Document Roadmap

One or more documents may be written that will to describe how sets of documents
taken together form a specific SNMP framework. Frameworks. 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 to 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 SNMP engine will include includes one or more Message Processing Models, and thus
may support sending and receiving multiple SNMP versions of SNMP 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 describes 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. 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.9. 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.

2.10. 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.

2.11. 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.

2.12. Conformance Statements

It may be useful to define the acceptable lower-bounds of
implementation, along with the actual level of implementation
achieved. It 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
portions of SNMP Frameworks.

Throughout the rest of this document, the term "subsystem" refers
to an abstract and incomplete specification of a portion of
a Framework, that is further refined by a model specification.

A "model" describes a specific design of a subsystem, defining
additional constraints and rules for conformance to the model.
A model is sufficiently detailed to make it possible to implement
the specification.

An "implementation" is an instantiation of a subsystem, conforming
to one or more specific models.

SNMP version 1 (SNMPv1), is the original Internet-standard Network
Management Framework, as described in RFCs 1155, 1157, and 1212.

SNMP version 2 (SNMPv2) (SNMPv2), is an updated design of portions of SNMPv1, the SNMPv2 Framework as derived from the
SNMPv1 Framework. It is described in RFCs 1902-1908. 1902-1907. SNMPv2 has an incomplete no
message definition.

Community-based SNMP version 2 (SNMPv2c) (SNMPv2c), is an experimental SNMP
Framework which supplements the incomplete message format of SNMPv2 with
portions of the message format of SNMPv1, Framework, as described in RFC1901.

\

message format.

SNMP version 3 (SNMPv3) Framework (SNMPv3), is a particular configuration of
implemented subsystems, consistent with an extensible SNMP Framework which
supplements the architecture described
in this document. SNMPv2 Framework, by supporting the following:
  - a new SNMP message format,
  - Security for Messages, and
  - Access Control.

Other SNMP Frameworks, i.e. other configurations of implemented
subsystems, are expected to also be consistent with this architecture.

This document does not describe any framework, but describes an
architecture into which multiple frameworks may be fitted.

\

3. Naming

This architecture deals with three kinds of naming:

  1) the naming of entities,
  2) the naming of identities, and
  3) the naming of management information.

This architecture also defines some names for other constructs that
are used in the documentation.

3.1. The Naming of Entities

2.15. Operational Overview

The following picture shows detail about an pictures show two communicating SNMP entity entities using
the conceptual modularity described by this SNMP Architecture.
The pictures represent SNMP entities that have traditionally been
called SNMP manager and how
components within it are named. SNMP agent respectively.
* One or more models may be present.

                      (traditional SNMP manager)
 +--------------------------------------------------------------------+
 |                                                                    |
 | +--------------+  +--------------+  +--------------+   SNMP entity |
 | | NOTIFICATION |  +--------------------------------------------------------------+  | NOTIFICATION |  |   COMMAND    |               |
 | |  SNMP engine (identified by snmpEngineID)  ORIGINATOR  |  |   RECEIVER   |  |  GENERATOR   |               |
 | |  +---------------+  +--------------+  +---------------+ applications |  | applications |  | applications |               |
 | +--------------+  +--------------+  +--------------+               |
 |         ^                ^                 ^                       |
 |         |                |                 |                       |
 |         v                v                 v                       | Message
 |         +-------+--------+-----------------+                       | Security
 |                 ^                                                  | Access
 |                 |     +---------------------+  +-----------------+ |
 |                 |     | Message Processing  |  | Subsystem    |  | Control Security        | |
 | Dispatcher      v     | Subsystem           |  | Subsystem       | |
 | +-------------------+ | Subsystem     +------------+  |  |                 | |
 | | PDU Dispatcher    | |  +->| v1MP     * |<--->| +-------------+ | |
 | |                   | |  |  +---------------+  +--------------+  +---------------+  +------------+  |  | | Other       | | |
 |  +--------------------------------------------------------------+ |                   | |  |  +--------------------------------------------------------------+  +------------+  |  | | Security    | | |
 |  Application(s) |                   | |  +->| v2cMP    * |<--->| | Model       | | |
 |  +-------------+  +--------------+  +--------------+ | Message           | |  |  +------------+  | Command  | +-------------+ | Notification |
 | Proxy | Dispatcher  <--------->+                  |  |                 | |
 | Generator |                   | Receiver |  | Forwarder  +------------+  |  | +-------------+ | |
 |  +-------------+  +--------------+  +--------------+ |                   | |  +->| v3MP     * |<--->| | User-based  | | |
 |  +-------------+  +--------------+  +--------------+ | Transport         | |  |  +------------+  | Command  | | Notification Security    | | Other |
 | | Mapping           | |  | Responder  +------------+  |  | Originator | Model       | | |
 | | (e.g RFC1906)     |  +-------------+  +--------------+  +--------------+ |  +->| otherMP  * |<--->| +-------------+ | |
 | +-------------------+ |     +------------+  |  |  +--------------------------------------------------------------+                 | |
 |
 +--------------------------------------------------------------------+

\

3.1.1. SNMP entity

An SNMP entity is an implementation of this architecture. Each such
SNMP entity consists of an SNMP engine and one or more associated
applications.

3.1.2. SNMP engine

An SNMP engine has three subsystems:

   1) a Message Processing Subsystem,
   2) a Security Subsystem, and
   3) an Access Control Subsystem.

3.1.3. snmpEngineID

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.1.4. Message Processing Subsystem

The Message Processing Subsystem is responsible for preparing and
sending messages, and receiving and distributing messages.

The Message Processing Subsystem potentially contains multiple
Message Processing Models as shown in the next picture. Those
marked with an asterisk (*) may be absent.

 +------------------------------------------------------------------+          ^            +---------------------+  +-----------------+ |
 |          |  Message Processing Subsystem                                                         |
 |          v                                                         |
 +--------------------------------------------------------------------+
 +-----+ +-----+       +-------+
 |  +------------+  +------------+  +------------+  +------------+ UDP | | IPX | . . . | other |          *
 +-----+ +-----+       +-------+
    ^       ^              ^
    |       |          *              |
    v       v              v
 +------------------------------+
 |          *           Network            |
 +------------------------------+
 +------------------------------+
 |           Network            |
 +------------------------------+
    ^       ^              ^
    | SNMPv3       |              | SNMPv1
    v       v              v
 +-----+ +-----+       +-------+
 | UDP | SNMPv2c | IPX | Other . . . | other |
 +-----+ +-----+       +-------+               (traditional SNMP agent)
 +--------------------------------------------------------------------+
 |              ^                                                     | Message
 |              | Message        +---------------------+  +-----------------+ |
 | Message              |        | Message    |  |
 |  | Processing |  | Processing  |  | Processing Security        | | Processing
 | Dispatcher   v        | Subsystem           |  | Model Subsystem       | | Model
 | +-------------------+ | Model     +------------+  |  | Model                 | |
 | | Transport         | |  +->| v1MP     * |<--->| +-------------+ | |
 | | Mapping           | |  |  +------------+  +------------+  +------------+  +------------+  |  | |
 +------------------------------------------------------------------+

3.1.5. Message Processing Model

Each Message Processing Model defines the format of a particular
version of an SNMP message and coordinates the processing of each
version-specific message.

\

3.1.6. Security Subsystem

The Security Subsystem provides security services such as the
authentication and privacy of messages and potentially contains
multiple Security Models as shown in the next picture. Those
marked with an asterisk (*) may be absent.

 +------------------------------------------------------------------+ Other       | | |  Security Subsystem
 | | (e.g. RFC1906)    | |  +------------+  +-------------------+  +---------------------+  |  +------------+  |  | | Security    |                 * | |                   *
 | |                   | | User-Based  +->| v2cMP    * |<--->| | Model       | Community-based | | Other
 | | Message           | | Security  |  +------------+  | Security  | +-------------+ | Security |
 | | Dispatcher  <--------->+                  | Model  |                 | Model |
 | Model |                   | |  |  +------------+  |  | +-------------+ | |
 | |                   |  +------------+  +-------------------+  +---------------------+ |  +->| v3MP     * |<--->| | User-based  |
 +------------------------------------------------------------------+

3.1.7. Security Model

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.

3.1.8. Security Protocol

A Security Protocol defines the mechanisms, procedures, and MIB
data used to provide a security service such as authentication
or privacy.

\

3.1.9. Access Control Subsystem

The Access Control Subsystem provides authorization services by
means of one or more Access Control Models.

 +------------------------------------------------------------------+ | |
 |  Access Control Subsystem |                   | |  |  +------------+  +-------------------+  +---------------------+  |  | | Security    | |                 * |
 |                   * |                   | |  | View-Based  +------------+  |  | Community | Model       | Other | |
 | | Access PDU Dispatcher    | | Access  +->| otherMP  * |<--->| +-------------+ | | Access
 | +-------------------+ |     +------------+  |  | Control                 | | Control
 |              ^        +---------------------+  +-----------------+ | Control
 |              |                                                     |
 | Model              v                                                     |
 | Model      +-------+-------------------------+----------------+          |
 | Model      ^                                 ^                ^          |
 |      |                                 |                |          |
 |      v                                 v                v          |
 |  |
 |  +------------+  +-------------------+  +---------------------+  |
 |                                                                  |
 +------------------------------------------------------------------+

3.1.10. Access Control Model

An Access Control Model defines a particular access decision function
in order to support decisions regarding authorization.

3.1.11. Applications

There are several types of applications, which include:

  - command generator,
  - command responder,
  - notification originator,
  - notification receiver, and
  - proxy forwarder.

These applications make use of the services provided by the Security
and Administration Framework.

3.1.12. SNMP Agent

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.

3.1.13. SNMP Manager

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.

\

3.2. The Naming of Identities

principal  <---------------------------------+
                                             |
       +-------------------------------------|-----+
       |  SNMP engine                        | +-------------+   +---------+   +--------------+   +-------------+ |
 | |   COMMAND   |   |  +-----------------------+ ACCESS  |   | NOTIFICATION |   | Security Model    PROXY  * | |
 | |  RESPONDER  |<->| CONTROL |<->|  ORIGINATOR  |  +-------------+   |  FORWARDER  | |
  wire
 | | application | Model   |    +------------+--+         |
<----------->| Dependent   |<-->|   | securityName| applications |   | application | | Security ID
 |    +---------------+ +-------------+   +---------+   +--------------+   +-------------+ |
 |      ^                                 ^                           |  +-------------+
 |      |                                 |                           |
 |      v                                 v                           |
 |  +-----------------------+ +----------------------------------------------+                   |
 | |             MIB instrumentation              |       SNMP entity |
       +-------------------------------------------+

3.2.1. Principal

A principal is
 +--------------------------------------------------------------------+

3. Elements of the "who" on whose behalf services Architecture

This section describes the various elements of the architecture and
how they are provided
or processing takes place.

A principal can be, among other things, an individual acting in
a particular role; a set named. There are three kinds of individuals, with each acting in a
particular role; an application; or a set naming:

  1) the naming of applications;
and combinations thereof.

3.2.2. securityName

A securityName is a human readable string representing a principal.
It has a model independent format, and can be used outside a
particular Security Model.

3.2.3. Model dependent security ID

A model dependent security ID is entities,
  2) the model specific representation
of a securityName within a particular Security Model.

Model dependent security IDs may or may not be human readable, and
have a model dependent syntax.  Examples include community names,
user names, and parties.

The transformation naming of model dependent security IDs into securityNames identities, and vice versa is
  3) the responsibility naming of management information.

This architecture also defines some names for other constructs that
are used in the relevant Security Model.

\

3.3. documentation.

3.1. The Naming of Management Information

Management information resides at Entities

The following picture shows detail about 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.

    +--------------------------------------------------------------+ and how
components within it are named.

 +--------------------------------------------------------------------+
 |  SNMP entity (identified by snmpEngineID, example: abcd)                                                       |
 |                                                                    |
 | +----------------------------------------------------------+  +--------------------------------------------------------------+  |
 |  |  SNMP engine (identified by snmpEngineID)                    |  |
 |  |                                                              |  |
 |  |  +---------------+  +--------------+  +---------------+  +-------------+ +------------+ +-----------+ +-----------+  |  |
 |  |  |             | |            | |           | |           |  |  |
 |  |  | Dispatcher  | | Message    | | Security  | | Access    |  |  |
 |  |  |             | | Processing | | Subsystem | | Control   |  |  |
 |  |  | Subsystem     |  |             | | Subsystem  | |           | | Subsystem |  |  |
 |  |  |             | |            | |           |  +---------------+  +--------------+  +---------------+  | |           |  |  |
 |  | +----------------------------------------------------------+  +-------------+ +------------+ +-----------+ +-----------+  |  |
 |  | +----------------------------------------------------------+                                                              |  |
 | Command Responder Application  +--------------------------------------------------------------+  |
 |                                                                    |
 | (contextEngineID, example: abcd)  +--------------------------------------------------------------+  |
 |  |  Application(s)                                              |  |
 |  |                                                              | example contextNames:  |
 |  |  +-------------+  +--------------+  +--------------+         |  |
 |  |  | "repeater1"        "repeater2"          "" (default) Command     |  | Notification |  | -----------        -----------          ------------ Proxy        |         |  |
 |  |  | Generator   |  | Receiver     |  | +-----|-------------------|--------------------|-----------+ Forwarder    |         |  |
 |  |  +-------------+  +--------------+  +--------------+         |  | +-----|-------------------|--------------------|-----------+
 |  |                                                              | MIB  |  instrumentation
 |  |  +-------------+  +--------------+  +--------------+         |  |
 | |-----v------------+ +----v-------------+ +----v-----------|  |  | Command     | context  | Notification | context  | Other        | context         |  |
 |  |  | Responder   |  | Originator   |  |              |         |  | +--------------+
 |  |  +-------------+  +--------------+  +--------------+         |  | +------------+ | |
    | | | repeater MIB | | | | repeater MIB |
 |  |                                                              | other MIB  |
 |  +--------------------------------------------------------------+  |
 |                                                                    | +--------------+ | | +--------------+ | | +------------+ | |
    | |                  | |                  | |                | |
    | |                  | |                  | | +------------+ | |
    | |                  | |                  | | | some  MIB  | | |
    | |                  | |                  | | +------------+ | |
    | |                  | |                  | |                | |
    +--------------------------------------------------------------+

\

3.3.1. An
 +--------------------------------------------------------------------+

3.1.1. SNMP Context entity

An SNMP context, or just "context" for short, entity is a collection of
management information accessible by an implementation of this architecture. Each such
SNMP entity. An item entity consists of
management information may exist in more than an SNMP engine and one context. or more associated
applications.

3.1.2. SNMP engine

An SNMP engine potentially has provides services for sending and receiving messages,
authenticating and encrypting messages, and controlling access to many contexts.

Typically, there are many instances of each
managed object type within objects. There is a management domain.  For simplicity, the method for identifying
instances specified by one-to-one association between an SNMP
engine and the MIB module does not allow each instance to
be distinguished amongst SNMP entity which contains it.

The engine contains:

   1) a Dispatcher,
   2) a Message Processing Subsystem,
   3) a Security Subsystem, and
   4) an Access Control Subsystem.

3.1.3. snmpEngineID

Within an administrative domain, an snmpEngineID is the set unique
and unambiguous identifier of all instances within an SNMP engine. Since there is a management
domain; rather,
one-to-one association between SNMP engines and SNMP entities,
it allows each instance to be identified only within
some scope or "context", where there are multiple such contexts within also uniquely and unambiguously identifies the management domain.  Often, a context SNMP entity.

3.1.4. Dispatcher

There 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 only one Dispatcher in an SNMP engine. It allows for
concurrent support of multiple devices, but a context is always defined as a subset versions of a
single SNMP entity.  Thus, messages 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
SNMP engine. It does so by:

  - sending and its instance.

For example, the managed object type ifDescr [RFC1573], is defined as
the description of a network interface.  To identify receiving SNMP messages to/from the description
of device-X's first network interface, four pieces of information are
needed: network,

  - determining the snmpEngineID version of the an SNMP entity which provides access to
device-X, the contextName (device-X), the managed object type
(ifDescr), message and interact
    with the instance ("1").

Each context has (at least) one unique identification within the
management domain. The same item of management information can exist
in multiple contexts. So, corresponding Message Processing Model,

  - providing 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.

The combination of a contextEngineID and a contextName unambiguously
identifies abstract interface to SNMP applications for
    dispatching a context within an administrative domain.

3.3.2. contextEngineID

Within PDU to an administrative domain, a contextEngineID uniquely
identifies application.

  - providing an abstract interface for SNMP entity applications that may realize an instance of
    allows them to send a
context with PDU to a particular contextName.

3.3.3. contextName

A contextName is used to name a context. Each contextName
MUST be unique within an remote SNMP entity.

3.3.4. scopedPDU

\

A scopedPDU

3.1.5. Message Processing Subsystem

The Message Processing Subsystem is a block of data containing a contextEngineID,
a contextName, responsible for preparing
messages for sending, and a PDU. extracting data from received messages.

The PDU is an SNMP Protocol Data Unit containing information
named Message Processing Subsystem potentially contains multiple
Message Processing Models as shown 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 next picture.
* One or more information
about SNMP PDUs.

3.4. Message Processing Models may be present.

 +------------------------------------------------------------------+
 |                                                                  |
 |  Message Processing Subsystem                                    |
 |                                                                  |
 |  +------------+  +------------+  +------------+  +------------+  |
 |  |          * |  |          * |  |          * |  |          * |  |
 |  | SNMPv3     |  | SNMPv1     |  | SNMPv2c    |  | Other Constructs

3.4.1. maxSizeResponseScopedPDU

The maxSizeResponseScopedPDU is      |  |
 |  | Message    |  | Message    |  | Message    |  | Message    |  |
 |  | Processing |  | Processing |  | Processing |  | Processing |  |
 |  | Model      |  | Model      |  | Model      |  | Model      |  |
 |  |            |  |            |  |            |  |            |  |
 |  +------------+  +------------+  +------------+  +------------+  |
 |                                                                  |
 +------------------------------------------------------------------+

3.1.6. Message Processing Model

Each Message Processing Model defines the maximum size format of a scopedPDU to
be included in a response message, making allowance for the message
header.

3.4.2. Local Configuration Datastore

The subsystems, models, and applications within particular
version of an SNMP entity may
need to retain their own sets of configuration information.

Portions of the configuration information may be accessible as
managed objects.

The collection of these sets of information is referred to
as an entity's Local Configuration Datastore (LCD).

3.4.3. LoS

This architecture recognizes three levels of security (LoS):

    - without authentication and without privacy (noAuthNoPriv)
    - with authentication but without privacy (authNoPriv)
    - with authentication and with privacy (authPriv)

These three values are ordered such that noAuthNoPriv is lower than
authNoPriv and authNoPriv is lower than authPriv.

Every message has an associated LoS. All Subsystems (Message
Processing, Security, Access Control) and applications are required
to either supply a value of LoS or to abide by the supplied value of
LoS while processing coordinates the message preparation and its contents.

\

4. Architectural Elements
extraction of Procedure

The architecture described here contains three 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
require. such version-specific messages.

3.1.7. Security Subsystem

The architecture also includes applications which utilize the Security Subsystem provides security services provided by such as the subsystems.

An SNMP engine deals with SNMP messages, and is responsible for
sending and receiving messages, including having
authentication and encryption services applied to the messages, privacy of messages and determining
to which application the message contents should be delivered.

Applications deal with processing network management operations.
Depending on the network management service needed, an application
may use potentially contains
multiple Security Models as shown in the Access Control Subsystem, and may use SNMP messages to
communicate with remote nodes.  The network management service next picture.
* One or more Security Models may be requested via the payload of an SNMP message, or may be requested
via a local process.

\

4.1.  Operational Overview

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.

                      (traditional SNMP manager)
 +--------------------------------------------------------------------+ present.

 +------------------------------------------------------------------+
 | SNMP entity                                                                  |
 |  Security Subsystem                                              |
 | +--------------+         +--------------+         +--------------+                                                                  |
 |  +----------------+  +-----------------+  +-------------------+  | NOTIFICATION
 |  | NOTIFICATION              * |  |   COMMAND               * |  |                 * |  |  ORIGINATOR
 |  |   RECEIVER User-Based     |  |  GENERATOR Other           |  | Other             |  | applications
 |  | applications Security       |  | applications Security        |  | Security          | +--------------+         +--------------+         +--------------+  |
 |         ^                       ^                        ^  | Model          |  | Model           |  | Model             |  |         v                       v                        v
 |  | +----------------------------------------------------------------+                |  |                 |        Message Processing Application Multiplexor  |                   |  | +----------------------------------------------------------------+
 |  +----------------+  +-----------------+  +-------------------+  |                     ^          ^            ^             ^
 |                                                                  | +-----------+
 +------------------------------------------------------------------+

3.1.8. Security Model

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.

3.1.9. Security Protocol

A Security Protocol defines the mechanisms, procedures, and MIB
data used to provide a security service such as authentication
or privacy.

3.1.10. Access Control Subsystem

The Access Control Subsystem provides authorization services by
means of one or more Access Control Models.

 +------------------------------------------------------------------+
 |                                                                  |
 |  Access Control Subsystem                                        |
 |                                                                  |
 |  +---------------+   +-----------------+   +------------------+  |       v          v            v             v
 |  |             * | Security   |    +------+  +---------+  +--------+   +-----------+               * |   |                * | Subsystem |<-->| v3MP  |
 | v2cMP *  | View-Based    | v1MP * |...| otherMP *   | Other           |   | Other            |  |    +------+  +---------+  +--------+   +-----------+
 |  | +-----------+       ^          ^            ^             ^ Access        |   | Access          |   | Access           |  |
 |  |                     v          v            v             v Control       |   | +----------------------------------------------------------------+ Control         |   | Control          |      Message Processing Model selection (incoming only)  |
 |  | +----------------------------------------------------------------+ Model         |   |                           ^ Model           |   | Model            |  |
 |                           v  |               | +----------------------------------------------------------------+   |                 |   |          TRANSPORT MAPPING (for example RFC1906)                  |  |
 | +----------------------------------------------------------------+  +---------------+   +-----------------+   +------------------+  |
 +--------------------------------------------------------------------+
        +-----+ +-----+       +-------+
        | UDP | | IPX | . . . | other |
        +-----+ +-----+       +-------+
           ^       ^              ^
           |       |              |
           v       v              v
        +------------------------------+
        |           Network            |
        +------------------------------+

\
        +------------------------------+
        |           Network            |
        +------------------------------+
           ^       ^              ^
           |       |              |
           v       v              v
        +-----+ +-----+       +-------+
        | UDP | | IPX | . . .
 | other                                                                  |
        +-----+ +-----+       +-------+       (traditional
 +------------------------------------------------------------------+

3.1.11. Access Control Model

An Access Control Model defines a particular access decision function
in order to support decisions regarding access rights.

3.1.12. Applications

There are several types of applications, including:

  - command generators, which monitor and manipulate management data,
  - command responders, which provide access to management data,
  - notification originators, which initiate asynchronous messages,
  - notification receivers, which process asynchronous messages, and
  - proxy forwarders, which forward messages between entities.

These applications make use of the services provided by the SNMP agent)
 +--------------------------------------------------------------------+
 | +----------------------------------------------------------------+ |
engine.

3.1.13. SNMP Agent

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.

3.1.14. SNMP Manager

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.

3.2. The Naming of Identities

principal  <---------------------------------+
                                             |
       +-------------------------------------|-----+
       |          TRANSPORT MAPPING (for example RFC1906)  SNMP engine                        |     |
       | +----------------------------------------------------------------+                                     |     |                           ^
       |  +-----------------------+          |     |
       |  |                           v Security Model        |          | +----------------------------------------------------------------+     |
       |  |      Message Processing Model selection (incoming only)  +-------------+      |          |     | +----------------------------------------------------------------+
  wire |  |                     ^          ^            ^             ^  | Model       | +-----------+    +------------+--+  |
<----------->| Dependent   |<-->| | securityName|  |
       |  |  | Security ID |    +---------------+  |       v          v            v             v
       |  |  +-------------+      | Security                |    +------+  +---------+  +--------+   +-----------+
       |  |                       | Subsystem |<-->| v3MP                |
       | v2cMP *  +-----------------------+                |
       | v1MP * |...| otherMP *                                           |
       |                                           |
       +-------------------------------------------+

3.2.1. Principal

A principal is the "who" on whose behalf services are provided
or processing takes place.

A principal can be, among other things, an individual acting in
a particular role; a set of individuals, with each acting in a
particular role; an application; or a set of applications;
and combinations thereof.

3.2.2. securityName

A securityName is a human readable string representing a principal.
It has a model independent format, and can be used outside a
particular Security Model.

3.2.3. Model dependent security ID

A model dependent security ID is the model specific representation
of a securityName within a particular Security Model.

Model dependent security IDs may or may not be human readable, and
have a model dependent syntax. Examples include community names,
user names, and parties.

The transformation of model dependent security IDs into securityNames
and vice versa is the responsibility of the relevant Security Model.

3.3. The Naming 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.

 +-----------------------------------------------------------------+
 |  SNMP entity (identified by snmpEngineID, example: abcd)        |    +------+  +---------+  +--------+   +-----------+
 |                                                                 | +-----------+       ^          ^            ^             ^
 |  +------------------------------------------------------------+ |
 |  | SNMP engine (identified by snmpEngineID)                   | |
 |  |                     v          v            v             v                                                            | | +----------------------------------------------------------------+
 |  | +-------------+ +------------+ +-----------+ +-----------+ |        Message Processing Abstract Service Interface |
 |  | +----------------------------------------------------------------+ |             |        ^                               ^                ^ |            | |           | |           | |        v                               v                v |
 | +-------------+   +---------+   +--------------+   +-------------+  | | Dispatcher  |   COMMAND | Message    | ACCESS | Security  | NOTIFICATION | Access    |    PROXY  * | |
 |  |  RESPONDER  |<->| CONTROL |<->|  ORIGINATOR |             |  FORWARDER | Processing | | Subsystem | | Control   | | |
 |  | |             | | Subsystem  | |           | | Subsystem | | |
 |  | |             | | application            | |           | | applications           | | application |
 |  | +-------------+   +---------+   +--------------+   +-------------+ +------------+ +-----------+ +-----------+ | |        ^                               ^
 |  |                                                            | |
 |  +------------------------------------------------------------+ |
 |                                                                 |
 |  +------------------------------------------------------------+ |
 |  |  Command Responder Application                             | |
 |  |  (contextEngineID, example: abcd)                          | |
 |  |                                                            | |
 |  |  example contextNames:                                     | |
 |  |                                                            | |
 |  |  "bridge1"          "bridge2"            "" (default)      | |
 |  |  ---------          ---------            ------------      | |
 |  |      |                  |                   |        v                               v              | | +----------------------------------------------+
 |  +------|------------------|-------------------|--------------+ |
 |         |                  |                   |                |
 |  +------|------------------|-------------------|--------------+ |
 |  |  MIB | instrumentation  |       SNMP entity                   |
 +--------------------------------------------------------------------+

\

4.2. Sending and Receiving              | |
 |  |  +---v------------+ +---v------------+ +----v-----------+  | |
 |  |  | context        | | context        | | context        |  | |
 |  |  |                | |                | |                |  | |
 |  |  | +------------+ | | +------------+ | | +------------+ |  | |
 |  |  | | bridge MIB | | | | bridge MIB | | | | other MIB  | |  | |
 |  |  | +------------+ | | +------------+ | | +------------+ |  | |
 |  |  |                | |                | |                |  | |
 |  |  |                | |                | | +------------+ |  | |
 |  |  |                | |                | | | some  MIB  | |  | |
 |  |  |                | |                | | +------------+ |  | |
 |  |  |                | |                | |                |  | |
 +-----------------------------------------------------------------+

3.3.1. An SNMP Messages

4.2.1. Send Context

An SNMP context, or just "context" for short,  is a Message to the Network

Applications may request that messages be generated and sent. The
application has the responsibility collection of providing the
management information
necessary to generate the message, as detailed below, and accessible by an SNMP entity. An item of
providing the transport address to which the message should be sent.

The
management information may exist in more than one context. An SNMP
engine passes potentially has access to many contexts.

Typically, there are many instances of each managed object type within
a request management domain. For simplicity, the method for a message identifying
instances specified by the MIB module does not allow each instance to
be generated to the
specified Message Processing Model which, utilizing distinguished amongst the services set of
the selected Security Model, generates the message and prepares all instances within a management
domain; rather, it
for sending.

The SNMP engine sends the message allows each instance to the specified transport address.
It then advises the sending Message Processing Model about the success be identified only within
some scope or failure of the sending of "context", where there are multiple such contexts within
the message.

4.2.2. Receive management domain.  Often, a Message from the Network

It context is the responsibility a physical device, or
perhaps, a logical device, although a context can also encompass
multiple devices, or a subset 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].

Upon receipt a single device, or even a subset of an SNMP message, the SNMP engine increments the
snmpInPkts counter [RFC1907].

SNMP messages received from the network use
multiple devices, but a format context is always defined by as a
version-specific Message Processing Model, typically identified
by subset of a version field
single SNMP entity.  Thus, in the message header.

The engine determines the SNMP version of order to identify an incoming message by
inspecting the serialized values for a recognizable pattern.
The mechanism by which it makes the determination individual item of version is
implementation-specific, and dependent on the Message Processing
Models supported by the engine.

If the engine has no Message Processing Model for the determined
version, then
management information within the snmpInBadVersions counter [RFC1907] is incremented, management domain, its contextName
and contextEngineID must be identified in addition to its object type
and its instance.

For example, the message managed object type ifDescr [RFC1573], is discarded without further processing.

The SNMP engine caches defined as
the msgID, which is subsequently used for
coordinating all processing regarding this received message, and
caches description of a network interface.  To identify the origin description
of device-X's first network address so a possible response can be
sent to interface, four pieces of information are
needed: the origin address.

Based on snmpEngineID of the SNMP version of entity which provides access to
the message, management information at device-X, the engine passes contextName (device-X),
the
message to managed object type (ifDescr), and the appropriate version-specific Message Processing Model.
The Message Processing Model extracts instance ("1").

Each context has (at least) one unique identification within the
management domain. The same item of management information can exist
in the message,
utilizing services multiple contexts. So, an item of the appropriate Security Model to authenticate

\ management information can have
multiple unique identifications, either because it exists in multiple
contexts, and/or because each such context has multiple unique
identifications.

The combination of a contextEngineID and decrypt the message as needed.

4.3. Send a Request or Notification Message for an Application

The Application Multiplexor receives contextName unambiguously
identifies a request for the generation
of context within an administrative domain.

3.3.2. contextEngineID

Within an administrative domain, a contextEngineID uniquely
identifies an SNMP message from entity that may realize an application via the sendPdu primitive:

sendPdu(
    transportDomain             -- transport domain instance of a
context with a particular contextName.

3.3.3. contextName

A contextName is used to name a context. Each contextName
MUST be used
    transportAddress            -- destination network address
    messageProcessingModel      -- typically, unique within an SNMP version
    securityModel               -- Security Model to use
    securityName                -- on behalf of this principal
    LoS                         -- Level entity.

3.3.4. scopedPDU

A scopedPDU is a block of Security requested
    contextEngineID             -- data from/at this entity
    contextName                 -- data from/in this context containing a contextEngineID,
a contextName, and a PDU.

The PDU                         -- is an SNMP Protocol Data Unit
    expectResponse)             -- TRUE or FALSE

The SNMP engine checks containing information
named in the "expectResponse" parameter to determine if
it is a message context which is expected to receive a response, and if so,
caches unambiguously identified within
an administrative domain by the msgID combination of the generated message contextEngineID
and which application
made the request. contextName. See, for example, RFC1905 for more information
about SNMP PDUs.

3.4. Other Constructs

3.4.1. maxSizeResponseScopedPDU

The engine sends the message according to the procedure detailed
in section 4.2.1. Send a Message to maxSizeResponseScopedPDU is the Network.

4.4. Receive maximum size of a Request or Notification Message from the Network

The engine receives the message according scopedPDU to the procedure detailed
be included in section 4.2.2. Receive a Message from response message, making allowance for the Network. message
header.

3.4.2. Local Configuration Datastore

The Application Demultiplexor looks into the scopedPDU subsystems, models, and applications within an SNMP entity may
need to determine retain their own sets of configuration information.

Portions of the contextEngineID configuration information may be accessible as
managed objects.

The collection of these sets of information is referred to
as an entity's Local Configuration Datastore (LCD).

3.4.3. securityLevel

This architecture recognizes three levels of security:

    - without authentication and the PDU type, then determines which
application without privacy (noAuthNoPriv)
    - with authentication but without privacy (authNoPriv)
    - with authentication and with privacy (authPriv)

These three values are ordered such that noAuthNoPriv is less than
authNoPriv and authNoPriv is less than authPriv.

Every message has registered (see section 4.7) an associated securityLevel. All Subsystems (Message
Processing, Security, Access Control) and applications are required
to support that PDU type
for that contextEngineID.

The Application Demultiplexor passes the request either supply a value of securityLevel or notification to abide by 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 supplied
value of securityLevel while processing the Response PDU
    securityModel               -- Security Model in use
    securityName                -- on behalf of this principal
    LoS                         -- Level of Security
    stateReference)             -- reference message and its contents.

4. Abstract Service Interfaces.

Abstract service interfaces have been defined to state information
                                -- needed when sending a response

\

4.5. Generate a Response Message for an Application

The Application Multiplexor receives a request for describe the generation
of
conceptual interfaces between the various subsystems within an SNMP response message from an application via
entity.

These abstract service interfaces are defined by a set of primitives
that define the
returnResponsePdu primitive:

returnResponsePdu(
    contextEngineID             -- data from/at this SNMP engine
    contextName                 -- services provided and the abstract data from/in this context
    securityModel               -- elements that
are to be passed when the services are invoked.  This section lists
the primitives that have been defined for the various subsystems.

4.1.  Common Primitives

These primitive(s) are provided by multiple Subsystems.

4.1.1.  Release State Reference Information

All Subsystems which pass stateReference information also provide a
primitive to release the memory that holds the referenced state
information:

stateRelease(
  IN   stateReference            -- handle of reference to be released
       )

4.2.  Dispatcher Primitives

The Dispatcher typically provides services to the SNMP applications via
its PDU Dispatcher.  This section describes the primitives provided by
the PDU Dispatcher.

4.2.1.  Generate Outgoing Request or Notification

The PDU Dispatcher provides the following primitive for an application
to send an SNMP Request or Notification to another SNMP entity:

statusInformation =              -- sendPduHandle if success
                                 -- errorIndication if failure
  sendPdu(
  IN   transportDomain           -- transport domain to be used
  IN   transportAddress          -- transport address to be used
  IN   messageProcessingModel    -- typically, SNMP version
  IN   securityModel             -- Security Model in to use
  IN   securityName              -- on behalf of this principal
    LoS
  IN   securityLevel             -- Level of Security
    stateReference requested
  IN   contextEngineID           -- reference data from/at this entity
  IN   contextName               -- data from/in this context
  IN   pduVersion                -- the version of the PDU
  IN   PDU                       -- SNMP Protocol Data Unit
  IN   expectResponse            -- TRUE or FALSE
       )

4.2.2.  Process Incoming Request or Notification PDU

The PDU Dispatcher provides the following primitive to state information pass an incoming
SNMP PDU to an application:

processPdu(                      -- process Request/Notification PDU
  IN   messageProcessingModel    -- typically, SNMP version
  IN   securityModel             -- Security Model in use
  IN   securityName              -- on behalf of this principal
  IN   securityLevel             -- Level of Security
  IN   contextEngineID           -- data from/at this SNMP entity
  IN   contextName               -- data from/in this context
  IN   pduVersion                -- as presented with the request version of the PDU
  IN   PDU                       -- SNMP Protocol Data Unit
  IN   maxSizeResponseScopedPDU  -- maximum size of the Response PDU
    statusInformation
  IN   stateReference            -- success or errorIndication reference to state information
       )                         -- 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 needed when sending a response

4.2.3.  Generate Outgoing 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 PDU Dispatcher provides the scopedPDU following primitive for an application
to determine
the contextEngineID and the return an SNMP Response PDU type.

If to the PDU type is a Response PDU, the Demultiplexor matches the
msgID Dispatcher:

returnResponsePdu(
  IN   messageProcessingModel    -- typically, SNMP version
  IN   securityModel             -- Security Model in use
  IN   securityName              -- on behalf of the this principal
  IN   securityLevel             -- same as on incoming response to the cached msgIDs of messages
sent by request
  IN   contextEngineID           -- data from/at this SNMP engine.

If a matching cached msgID is found, entity
  IN   contextName               -- data from/in this context
  IN   pduVersion                -- the cached msgID and version of the cached
origin network address are released, and PDU
  IN   PDU                       -- SNMP Protocol Data Unit
  IN   maxSizeResponseScopedPDU  -- maximum size of the response is passed Response PDU
  IN   stateReference            -- reference to state information
                                 -- as presented with the
associated application using request
  IN   statusInformation         -- success or errorIndication
       )                         -- error counter OID/value if error

4.2.4.  Process Incoming Response PDU

The PDU Dispatcher provides the processResponsePdu primitive: following primitive to pass an incoming
SNMP Response PDU to an application:

processResponsePdu(              -- process Response PDU
  IN   messageProcessingModel    -- typically, SNMP version
  IN   securityModel             -- Security Model in use
  IN   securityName              -- on behalf of this principal
  IN   securityLevel             -- Level of Security
  IN   contextEngineID           -- data from/at this SNMP engine entity
  IN   contextName               -- data from/in this context
  IN   pduVersion                -- the version of the PDU
  IN   PDU                       -- SNMP Protocol Data Unit
    LoS                         -- Level of Security
  IN   statusInformation         -- success or errorIndication
  IN   sendPduHandle             -- handle from sendPDU
       )

4.7.

4.2.5.  Registering to Receive Asynchronous Messages

When an Responsibility for Handling SNMP engine receives PDUs.

Applications can register/unregister responsibility for a message that is not specific
contextEngineID, for specific pduTypes, with the response PDU Dispatcher
according 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. these primitives:

statusInformation =              -- success or errorIndication
  registerContextEngineID(
  IN   contextEngineID           -- take responsibility for this one
  IN   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(
  IN   contextEngineID           -- give up responsibility for this one
  IN   pduType                   -- the pduType(s) to be unregistered
       )

SNMP does not provide

4.3.  Message Processing Subsystem Primitives

The Dispatcher interacts with a mechanism for identifying Message Processing Model to process a
specific version of an application,
so SNMP Message. This section describes the mechanism
primitives provided by the Message Processing Subsystem.

4.3.1.  Prepare an Outgoing SNMP Request or Notification Message

The Message Processing Subsystem provides this service primitive for
preparing an outgoing SNMP Request or Notification Message:

statusInformation =              -- success or errorIndication
  prepareOutgoingMessage(
  IN   transportDomain           -- transport domain to be used
  IN   transportAddress          -- transport address to identify which application is registering
is implementation-specific.

\

5. Definition be used
  IN   messageProcessingModel    -- typically, SNMP version
  IN   securityModel             -- Security Model to use
  IN   securityName              -- on behalf of Managed Objects for Internet Management Frameworks

SNMP-FRAMEWORK-MIB DEFINITIONS ::= BEGIN

IMPORTS
    MODULE-IDENTITY, OBJECT-TYPE,
    OBJECT-IDENTITY,
    snmpModules, Unsigned32, Integer32    FROM SNMPv2-SMI
    TEXTUAL-CONVENTION                    FROM SNMPv2-TC
    MODULE-COMPLIANCE, OBJECT-GROUP       FROM SNMPv2-CONF;

snmpFrameworkMIB MODULE-IDENTITY
    LAST-UPDATED "9707110000Z" this principal
  IN   securityLevel             -- 11 July 1997, midnight
    ORGANIZATION "SNMPv3 Working Group"
    CONTACT-INFO "WG-email:   snmpv3@tis.com
                  Subscribe:  majordomo@tis.com
                              In message body:  subscribe snmpv3

                  Chair:      Russ Mundy
                              Trusted Information Systems
                  postal:     3060 Washington Rd
                              Glenwood MD 21738
                              USA
                  email:      mundy@tis.com
                  phone:      +1-301-854-6889

                  Co-editor   Dave Harrington
                              Cabletron Systems, Inc
                  postal:     Post Office Box 5005
                              MailStop: Durham
                              35 Industrial Way
                              Rochester NH 03867-5005
                              USA
                  email:      dbh@cabletron.com
                  phone:      +1-603-337-7357

                  Co-editor:  Bert Wijnen
                              IBM T.J. Watson Research
                  postal:     Schagen 33
                              3461 GL Linschoten
                              Netherlands
                  email:      wijnen@vnet.ibm.com
                  phone:      +31-348-432-794
                 "
    DESCRIPTION  "The Internet Management Architecture MIB"
    ::= { snmpModules 7 } Level of Security requested
  IN   contextEngineID           -- DBH: check if data from/at this number is indeed OK entity
  IN   contextName               -- data from/in this context
  IN   pduVersion                -- Textual Conventions used in the Internet Management Architecture ***

SnmpEngineID ::= TEXTUAL-CONVENTION
    STATUS       current

\
    DESCRIPTION "An version of the PDU
  IN   PDU                       -- SNMP engine's administratively-unique identifier.

                 The value for this object may not be all zeros Protocol Data Unit
  IN   expectResponse            -- TRUE or
                 all 'ff'H.  It may also not be FALSE
  IN   sendPduHandle             -- the empty string.

                 The initial value handle for matching
                                 -- incoming responses
  OUT  destTransportDomain       -- destination transport domain
  OUT  destTransportAddress      -- destination transport address
  OUT  outgoingMessage           -- the message to send
  OUT  outgoingMessageLength     -- its length
       )

4.3.2.  Prepare an Outgoing SNMP Response Message

The Message Processing Subsystem provides this object may be configured
                 via service primitive for
preparing an operator console entry outgoing SNMP Response Message:

result =                         -- SUCCESS or via an algorithmic
                 function.  In the latter case, the following
                 example algorithm for a twelve-octet identifier
                 is recommended:

                 1) The first four octets are set to FAILURE
  prepareResponseMessage(
  IN   messageProcessingModel    -- typically, SNMP version
  IN   securityModel             -- same as on incoming request
  IN   securityName              -- same as on incoming request
  IN   securityLevel             -- same as on incoming request
  IN   contextEngineID           -- data from/at this SNMP entity
  IN   contextName               -- data from/in this context
  IN   pduVersion                -- the binary
                    equivalent version of the entity's SNMP network management
                    private enterprise number PDU
  IN   PDU                       -- SNMP Protocol Data Unit
  IN   maxSizeResponseScopedPDU  -- maximum size of the Response PDU
  IN   stateReference            -- reference to state information
                                 -- as assigned by presented with the
                    Internet Assigned Numbers Authority (IANA).
                    For example, request
  IN   statusInformation         -- success or errorIndication
                                 -- error counter OID/value if Acme Networks has been assigned
                    { enterprises 696 }, error
  OUT  destTransportDomain       -- destination transport domain
  OUT  destTransportAddress      -- destination transport address
  OUT  outgoingMessage           -- the first four octets would
                    be assigned '000002b8'H.

                 2) message to send
  OUT  outgoingMessageLength     -- its length
       )

4.3.3. Prepare Data Elements from an Incoming SNMP Message

The remaining eight octets are determined via
                    one Message Processing Subsystem provides this service primitive for
preparing the abstract data elements from an incoming SNMP message:

result =                         -- SUCCESS or more enterprise specific methods. Such
                    methods must be designed so errorIndication
  prepareDataElements(
  IN   transportDomain           -- origin transport domain
  IN   transportAddress          -- origin transport address
  IN   wholeMsg                  -- as to maximize received from the
                    possibility that network
  IN   wholeMsglength            -- as received from the value network
  OUT  messageProcessingModel    -- typically, SNMP version
  OUT  securityModel             -- Security Model to use
  OUT  securityName              -- on behalf of this object will
                    be unique in the entity's administrative domain.
                    For example, it may be principal
  OUT  securityLevel             -- Level of Security requested
  OUT  contextEngineID           -- data from/at this entity
  OUT  contextName               -- data from/in this context
  OUT  pduVersion                -- the IP address version of the PDU
  OUT  PDU                       -- SNMP
                    entity, or the MAC address of one Protocol Data Unit
  OUT  pduType                   -- SNMP PDU type
  OUT  sendPduHandle             -- handle for matched request
  OUT  maxSizeResponseScopedPDU  -- maximum size of the
                    interfaces, with each address suitably padded
                    with random octets.  If multiple methods are
                    defined, then it is recommended that the first
                    octet that indicates the method being used and
                    the remaining octets are Response PDU
  OUT  statusInformation         -- success or errorIndication
                                 -- error counter OID/value if error
  OUT  stateReference            -- reference to state information
                                 -- to be used for a function of possible Response
       )

4.4.  Access Control Subsystem Primitives

Applications are the method.
                "
    SYNTAX       OCTET STRING

SnmpSecurityModel ::= TEXTUAL-CONVENTION
    STATUS       current
    DESCRIPTION "An identifier that uniquely identifies a securityModel typical clients of the Security Subsystem within service(s) of the Internet
                 Management Architecture. Access
Control Subsystem.

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 following primitive is provided by the Internet Assigned Numbers Authority (IANA).
                 - Values greater than 255 are allocated Access Control Subsystem
to enterprise
                   specific Security Models.  An enterprise specific
                   securityModel value check if access is defined to be:

                   enterpriseID * 256 + security model within enterprise

\
                   For example, the fourth allowed:

statusInformation =              -- success or errorIndication
  isAccessAllowed(
  IN   securityModel             -- Security Model defined by
                   the enterprise whose enterpriseID is 1 would be 260.

                 The eight bits allow a maximum in use
  IN   securityName              -- principal who wants to access
  IN   securityLevel             -- Level of 255 (256-1 reserved)
                 standards based Security Models.  Similarly, they
                 allow a maximum of 255
  IN   viewType                  -- read, write, or notify view
  IN   contextName               -- context containing variableName
  IN   variableName              -- OID for the managed object
       )

4.5.  Security Models per enterprise.

                 It Subsystem Primitives

The Message Processing Subsystem is believed that the assignment typical client of new
                 securityModel values will be rare in practice
                 because the larger the number services
of simultaneously
                 utilized Security Models, the larger Security Subsystem.

4.5.1.  Generate a Request or Notification Message

The Security Subsystem provides the chance that
                 interoperability will suffer.  Consequently, it is
                 believed that such following primitive to generate
a range will be sufficient.
                 In Request or Notification message:

statusInformation =
  generateRequestMsg(
  IN   messageProcessingModel    -- typically, SNMP version
  IN   globalData                -- message header, admin data
  IN   maxMessageSize            -- of the unlikely event that sending SNMP entity
  IN   securityModel             -- for the standards committee
                 finds outgoing message
  IN   securityEngineID          -- authoritative SNMP entity
  IN   securityName              -- on behalf of this number to be insufficient over time, an
                 enterprise number can be allocated principal
  IN   securityLevel             -- Level of Security requested
  IN   scopedPDU                 -- message (plaintext) payload
  OUT  securityParameters        -- filled in by Security Module
  OUT  wholeMsg                  -- complete generated message
  OUT  wholeMsgLength            -- length of the generated message
       )

4.5.2.  Process Incoming Message

The Security Subsystem provides the following primitive to obtain process
an
                 additional 255 possible values.

                 Note that incoming message:

statusInformation =              -- errorIndication or success
                                 -- error counter OID/value if error
  processIncomingMsg(
  IN   messageProcessingModel    -- typically, SNMP version
  IN   maxMessageSize            -- of the most significant bit must be zero;
                 hence, there are 23 bits allocated sending SNMP entity
  IN   securityParameters        -- for various
                 organizations to design and define non-standard
                 securityModels.  This limits the ability to define
                 new proprietary implementations received message
  IN   securityModel             -- for the received message
  IN   securityLevel             -- Level of Security Models
                 to
  IN   wholeMsg                  -- as received on the first 8,388,608 enterprises.

                 It is worthwhile to note that, in its encoded form, wire
  IN   wholeMsgLength            -- length as received on the securityModel value will normally require only a
                 single byte since, in practice, wire
  OUT  securityEngineID          -- identification of the leftmost bits will
                 be zero for most messages and sign extension is
                 suppressed by principal
  OUT  securityName              -- identification of the encoding rules.

                 As principal
  OUT  scopedPDU,                -- message (plaintext) payload
  OUT  maxSizeResponseScopedPDU  -- maximum size of this writing, there are several values the Response PDU
  OUT  securityStateReference    -- reference to security state
       )                         -- information, needed for response

4.5.3.  Generate a Response Message

The Security Subsystem provides the following primitive to generate
a Response message:

statusInformation =
  generateResponseMsg(
  IN   messageProcessingModel    -- typically, SNMP version
  IN   globalData                -- message header, admin data
  IN   maxMessageSize            -- of the sending SNMP entity
  IN   securityModel defined             -- for use with the outgoing message
  IN   securityEngineID          -- authoritative SNMP or reserved
                 for use with supporting MIB objects.  They are as
                 follows:

                     0  reserved for 'none'
                     1  reserved for SNMPv1
                     2  reserved entity
  IN   securityName              -- on behalf of this principal
  IN   securityLevel             -- for SNMPv2c
                     3  User-Base the outgoing message
  IN   scopedPDU                 -- message (plaintext) payload
  IN   securityStateReference    -- reference to security state
                                 -- information from original request
  OUT  securityParameters        -- filled in by Security Module
  OUT  wholeMsg                  -- complete generated message
  OUT  wholeMsgLength            -- length of the generated message
       )

4.6.  User Based Security Model (USM)
                   255  reserved Internal Primitives

4.6.1.  User-based Security Model Primitives for 'any'
                "
    SYNTAX       INTEGER(0..2147483647)

SnmpLoS ::= TEXTUAL-CONVENTION
    STATUS       current
    DESCRIPTION "A Level of Authentication

The User-based Security at which SNMP messages can be
                 sent or with which operations are being processed;
                 in particular, one of:

\
                   noAuthNoPriv - without authentication Model provides the following internal
primitives to pass data back and
                                  without privacy,
                   authNoPriv   - with forth between the Security Model
itself and the authentication but
                                  without privacy,
                   authPriv     - with service:

statusInformation =
  authenticateOutgoingMsg(
  IN   authKey                   -- secret key for authentication
  IN   wholeMsg                  -- unauthenticated complete message
  OUT  authenticatedWholeMsg     -- complete authenticated message
       )

statusInformation =
  authenticateIncomingMsg(
  IN   authKey                   -- secret key for authentication
  IN   authParameters            -- as received on the wire
  IN   wholeMsg                  -- as received on the wire
  OUT  authenticatedWholeMsg     -- complete authenticated message
       )

4.6.2.  User-based Security Model Primitives for Privacy

The User-based Security Model provides the following internal
primitives to pass data back and
                                  with privacy.

                 These three values are ordered such that noAuthNoPriv
                 is lower than authNoPriv and authNoPriv is lower than
                 authPriv.
                "
    SYNTAX       INTEGER { noAuthNoPriv(1),
                           authNoPriv(2),
                           authPriv(3)
                         }

SnmpAdminString ::= TEXTUAL-CONVENTION
    DISPLAY-HINT "255a"
    STATUS       current
    DESCRIPTION "An octet string containing administrative information,
                 preferably in human-readable form.

                 To facilitate internationalization, this information
                 is represented using forth between the ISO/IEC IS 10646-1 character
                 set, encoded as an octet string using Security Model
itself and the UTF-8
                 character encoding scheme described privacy service:

statusInformation =
  encryptData(
  IN    encryptKey               -- secret key for encryption
  IN    dataToEncrypt            -- data to encrypt (scopedPDU)
  OUT   encryptedData            -- encrypted data (encryptedPDU)
  OUT   privParameters           -- filled in RFC 2044.

                 Since additional code points are added by amendments
                 to service provider
        )

statusInformation =
  decryptData(
  IN    decryptKey               -- secret key for decrypting
  IN    privParameters           -- as received on 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 wire
  IN    encryptedData            -- encrypted data (encryptedPDU)
  OUT   decryptedData            -- decrypted data (scopedPDU)
        )

4.7. Scenario Diagrams

4.7.1. Command Generator or software, an alternative means
                 of entry and display, such as hexadecimal, may Notification Originator Application

This diagram shows how a Command Generator or Notification Originator
application requests that a PDU be
                 provided.

                 For information encoded in 7-bit US-ASCII, sent, and how the UTF-8
                 representation response is identical
returned (asynchronously) to the US-ASCII encoding.
                "
    SYNTAX       OCTET STRING (SIZE (0..255))

-- Administrative assignments ****************************************

snmpFrameworkAdmin          OBJECT IDENTIFIER ::= { snmpFrameworkMIB 1 }
snmpFrameworkMIBObjects     OBJECT IDENTIFIER ::= { snmpFrameworkMIB 2 }
snmpFrameworkMIBConformance OBJECT IDENTIFIER ::= { snmpFrameworkMIB 3 }

\

-- the snmpEngine Group **********************************************

snmpEngine OBJECT IDENTIFIER ::= { snmpFrameworkMIBObjects 1 }

snmpEngineID     OBJECT-TYPE
    SYNTAX       SnmpEngineID
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION "An SNMP engine's administratively-unique identifier.
                "
    ::= { snmpEngine 1 }

snmpEngineBoots  OBJECT-TYPE
    SYNTAX       Unsigned32 -- (1..4294967295)
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION "The number of times that the application.

Command           Dispatcher                 Message           Security
Generator            |                       Processing           Model
|                    |                       Model                    |
|                    |                          |                     |
|      sendPdu       |                          |                     |
|------------------->|                          |                     |
|                    | prepareOutgoingMessage   |                     |
:                    |------------------------->|                     |
:                    |                          | generateRequestMsg  |
:                    |                          |-------------------->|
:                    |                          |                     |
:                    |                          |<--------------------|
:                    |                          |                     |
:                    |<-------------------------|                     |
:                    |                          |                     |
:                    |------------------+       |                     |
:                    | Send SNMP engine has
                 (re-)initialized itself since its initial
                 configuration.
                "
    ::= { snmpEngine 2 }

snmpEngineTime   OBJECT-TYPE
    SYNTAX       Integer32 (0..2147483647)
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION "The number of seconds since the        |       |                     |
:                    | Request Message  |       |                     |
:                    | to Network       |       |                     |
:                    |                  v       |                     |
:                    :                  :       :                     :
:                    :                  :       :                     :
:                    :                  :       :                     :
:                    |                  |       |                     |
:                    |                  |       |                     |
:                    | Receive SNMP engine last
                 incremented the snmpEngineBoots object.
                "
    ::= { snmpEngine 3 }

-- Registration Points for IMF Authentication and Privacy Protocols **

snmpAuthProtocols OBJECT-IDENTITY
    STATUS        current
    DESCRIPTION  "Registration point     |       |                     |
:                    | Response Message |       |                     |
:                    | from Network     |       |                     |
:                    |<-----------------+       |                     |
:                    |                          |                     |
:                    |   prepareDataElements    |                     |
:                    |------------------------->|                     |
:                    |                          | processIncomingMsg  |
:                    |                          |-------------------->|
:                    |                          |                     |
:                    |                          |<--------------------|
:                    |                          |                     |
:                    |<-------------------------|                     |
| processResponsePdu |                          |                     |
|<-------------------|                          |                     |
|                    |                          |                     |

4.7.2. Scenario Diagram for standards-track authentication
                  protocols used in the Internet Management Framework.
                 "
    ::= { snmpFrameworkAdmin 1 }

snmpPrivProtocols OBJECT-IDENTITY
    STATUS        current
    DESCRIPTION  "Registration point a Command Responder Application

This diagram shows how a Command Responder or Notification Receiver
application registers for standards-track privacy
                  protocols used in handling a pduType, how a PDU is dispatched
to the Internet Management Framework.
                 "
    ::= { snmpFrameworkAdmin 2 }

-- Conformance information *******************************************

snmpFrameworkMIBCompliances

\
               OBJECT IDENTIFIER ::= { snmpFrameworkMIBConformance 1 }
snmpFrameworkMIBGroups
               OBJECT IDENTIFIER ::= { snmpFrameworkMIBConformance 2 }

-- compliance statements

snmpFrameworkMIBCompliance MODULE-COMPLIANCE
    STATUS       current
    DESCRIPTION "The compliance statement for application after a SNMP engines which
                 implement the Internet Management Framework MIB.
                "
    MODULE    -- this module
        MANDATORY-GROUPS { snmpEngineGroup }

    ::= { snmpFrameworkMIBCompliances 1 }

-- units of conformance

snmpEngineGroup OBJECT-GROUP
    OBJECTS {
              snmpEngineID,
              snmpEngineBoots,
              snmpEngineTime
            }
    STATUS       current
    DESCRIPTION "A collection of objects for identifying and
                 determining the configuration message is received, and current timeliness
                 values of an SNMP engine.
                "
    ::= { snmpFrameworkMIBGroups 1 }

END

\

6. Security Considerations

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 the
Response is determined by (asynchronously) send back to the specific network.

Command               Dispatcher             Message           Security
Responder                 |                  Processing           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                    |
|                         |                     |                     |
| registerContextEngineID |                     |                     |
|------------------------>|                     |                     |
|<------------------------|              |      |                     |
|                         | Receive SNMP |      |                     |
:                         | Message      |      |                     |
:                         | 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 |      |                     |
:                         |<-------------+      |                     |
:                         |                     |                     |
:                         | prepareDataElements |                     |
:                         |-------------------->|                     |
:                         |                     | processIncomingMsg  |
:                         |                     |-------------------->|
:                         |                     |                     |
:                         |                     |<--------------------|
:                         |                     |                     |
:                         |<--------------------|                     |
|     processPdu          |                     |                     |
|<------------------------|                     |                     |
|                         |                     |                     |
:                         :                     :                     :
:                         :                     :                     :
|    returnResponsePdu    |                     |                     |
|------------------------>|                     |                     |
:                         |  prepareResponseMsg |                     |
:                         |-------------------->|                     |
:                         |                     | generateResponseMsg |
:                         |                     |-------------------->|
:                         |                     |                     |
:                         |                     |<--------------------|
:                         |                     |                     |
:                         |<--------------------|                     |
:                         |                     |                     |
:                         |--------------+      |                     |
:                         | Send SNMP    |      |                     |
:                         | Message      |      |                     |
:                         | to
    Community-based SNMPv2", RFC 1901, January 1996.

[RFC1902] The SNMPv2 Working Group, Case, J., McCloghrie, K.,
    Rose, M., and S., Waldbusser, "Structure Network   |      |                     |
:                         |              v      |                     |

5. Definition of Management
    Information Managed Objects for Version  2 of the Simple Network SNMP 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 Frameworks

SNMP-FRAMEWORK-MIB DEFINITIONS ::= BEGIN

IMPORTS
    MODULE-IDENTITY, OBJECT-TYPE,
    OBJECT-IDENTITY,
    snmpModules, Unsigned32, Integer32    FROM SNMPv2-SMI
    TEXTUAL-CONVENTION                    FROM SNMPv2-TC
    MODULE-COMPLIANCE, OBJECT-GROUP       FROM SNMPv2-CONF;

snmpFrameworkMIB MODULE-IDENTITY
    LAST-UPDATED "9707260000Z"            -- 26 July 1997, midnight
    ORGANIZATION "SNMPv3 Working Group, Case, J., McCloghrie, K.,
    Rose, M., and S. Waldbusser, "Management Group"
    CONTACT-INFO "WG-email:   snmpv3@tis.com
                  Subscribe:  majordomo@tis.com
                              In message body:  subscribe snmpv3

                  Chair:      Russ Mundy
                              Trusted 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 Systems
                  postal:     Schagen 33
                               3461 GL Linschoten
                               Netherlands     3060 Washington Rd
                              Glenwood MD 21738
                              USA
                  email:      wijnen@vnet.ibm.com      mundy@tis.com
                  phone:      +31-348-432-794      +1-301-854-6889

                  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)

                  Co-editor:  Bert Wijnen (IBM
                              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
described in RFCs 1909-1910, and from a set of internet drafts.
these are the two most popular de facto "administrative framework"
standards that include security and access control for SNMPv2.

SNMPv1 and SNMPv2c [RFC1901] are two administrative frameworks based
on communities to provide trivial authentication and access control.
SNMPv1 and SNMPv2c Frameworks can coexist with Frameworks designed
to fit into this architecture, and modified versions of SNMPv1 and
SNMPv2c Frameworks could be fit into this architecture, but this
document does not provide guidelines for that coexistence.

Within any subsystem model, there should be no reference to any
specific model of another subsystem, or to data defined by a specific
model of another subsystem.

Transfer of data between the subsystems is deliberately described

as a fixed set of abstract data elements and primitive functions
which can be overloaded to satisfy the needs of multiple model
definitions.

Documents which define models to be used within this architecture
SHOULD use the standard primitives between subsystems, possibly
defining specific mechanisms for converting the abstract data elements
into model-usable formats. This constraint exists 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 service
interfaces to request the services.

Each model definition for a subsystem SHOULD support the standard
service interfaces, but whether, or how, or how well, it performs
the service is defined by the model definition.

A.1. Security Model Design Requirements

A.1.1. Threats

A document describing a Security Model MUST describe how the model
protects against the threats described under "Security Requirements
of this Architecture", section 1.4.

\

A.1.2. Security Processing

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
not require authentication or privacy.

A received message contains a specified Level of Security to be
used during processing.  All messages requiring privacy MUST also
require authentication.

A Security Model specifies rules by which authentication and privacy
are to be done.  A model may define mechanisms to provide additional
security features, but the model definition is constrained to using
(possibly a subset of) the abstract data elements defined in this
document for transferring data between subsystems.

Each Security Model may allow multiple security mechanisms to be used
concurrently within an implementation of the model. Each Security Model
defines how to determine which protocol to use, given the LoS and the
security parameters relevant to the message. Each Security Model, with
its associated protocol(s) defines how the sending/receiving entities
are identified, and how secrets are configured.

Authentication and Privacy protocols supported by Security Models are
uniquely identified using Object Identifiers. IETF standard protocol Research
                  postal:     Schagen 33
                              3461 GL Linschoten
                              Netherlands
                  email:      wijnen@vnet.ibm.com
                  phone:      +31-348-432-794
                 "
    DESCRIPTION  "The SNMP Management Architecture MIB"
    ::= { snmpModules 7 }  -- DBH: check if this number is indeed OK

-- Textual Conventions used in the SNMP Management Architecture ***

SnmpEngineID ::= TEXTUAL-CONVENTION
    STATUS       current
    DESCRIPTION "An SNMP engine's administratively-unique identifier.

                 The value for authentication this object may not be all zeros or privacy should have an identifier defined within
the snmpAuthProtocols
                 all 'ff'H or the snmpPrivProtocols subtrees. Enterprise
specific protocol identifiers should empty (zero length) string.

                 The initial value for this object may be defined within the enterprise
subtree.

For privacy, configured
                 via an operator console entry or via an algorithmic
                 function.  In the Security Model defines what portion of latter case, the message following
                 example algorithm is encrypted. recommended.

                 1) The persistent data very first bit is used for security should be SNMP-manageable, but to indicate how the Security Model defines whether an instantiation
                    rest of the MIB data is a
conformance requirement.

Security Models are replaceable within the Security Subsystem.
Multiple Security Model implementations may exist concurrently within
an SNMP engine.  The number of Security Models composed.

                    0 - as defined by the SNMP
community should remain small to promote interoperability.

A.1.3. validate the security-stamp in a received message

The Message Processing Model requests that the Security Model verify enterprise using former methods
                        that the message has not been altered, and authenticate the
identification of the principal for whom the message was generated.
If encrypted, decrypt the message.

\

Additional requirements may be existed before SNMPv3. See item 2 below.

                    1 - as defined by the model, and additional
services provided by the model, but the model is constrained to use
the following primitives for transferring data between subsystems.
Implementations are not so constrained.

The Message Processing Model this architecture, see item 3
                        below.

                    Note that this allows existing uses of the following primitive:

processMsg(
    messageProcessingModel      -- typically, SNMP version
    msgID                       --
                    engineID (also known as AgentID [RFC1910]) to
                    co-exist with any new uses.

                 2) The snmpEngineID has a length of 12 octets.

                    The first four octets are set to the received message
    mms                         -- binary
                    equivalent of the sending agent's SNMP entity
    msgFlags                    -- for the received message
    securityParameters          -- for the received message
    securityModel               -- for the received message
    LoS                         -- Level of Security
    wholeMsg                    -- network management
                    private enterprise number as received on assigned by the wire
    wholeMsgLength              -- length as received on
                    Internet Assigned Numbers Authority (IANA).
                    For example, if Acme Networks has been assigned
                    { enterprises 696 }, the wire
    ) first four octets would
                    be assigned '000002b8'H.

                    The Security Model uses the following primitive remaining eight octets are determined via
                    one or more enterprise specific methods. Such
                    methods must be designed so as to respond:

returnProcessedMsg(
    securityName                -- identification maximize the
                    possibility that the value of this object will
                    be unique in the principal
    scopedPDU,                  -- message (plaintext) payload
    maxSizeResponseScopedPDU    -- maximum size agent's administrative domain.
                    For example, it may be the IP address of the Response PDU
    securityStateReference      -- reference to security state
                                -- information, needed for response
    statusInformation           -- errorIndication SNMP
                    entity, or success
    )                           -- error counter OID/value if error

A.1.5. Security MIBs

Each Security Model defines the MIB modules required for security
processing, including any MIB modules required for MAC address of one of the security
mechanism(s) supported.  The MIB modules SHOULD be defined concurrently
                    interfaces, with each address suitably padded
                    with random octets.  If multiple methods are
                    defined, then it is recommended that the first
                    octet indicate the method being used and the
                    remaining octets be a function of the procedures which use method.

                 3) The length of the MIB module. octet strings varies.

                    The MIB modules first four octets are
subject set to normal security and access control rules.

The mapping between the model-dependent identifier and binary
                    equivalent of the securityName
MUST agent's SNMP network management
                    private enterprise number as assigned by the
                    Internet Assigned Numbers Authority (IANA).
                    For example, if Acme Networks has been assigned
                    { enterprises 696 }, the first four octets would
                    be able assigned '000002b8'H.

                    The very first bit is set to 1. For example, the
                    above value for Acme Networks now changes to be determined using SNMP, if
                    '800002b8'H.

                    The fifth octet indicates how the model-dependent
MIB is instantiated rest (6th and access control policy allows access.

A.1.6. Security State Cache

For each message received,
                    following octets) are formatted. The values for
                    the Security Subsystem caches fifth octet are:

                      0     - reserved, unused.

                      1     - IPv4 address (4 octets)
                              lowest non-special IP address

                      2     - IPv6 address (16 octets)
                              lowest non-special IP address

                      3     - MAC address (6 octets)
                              lowest IEEE MAC address, canonical order

                      4     - Text, administratively assigned
                              Maximum remaining length 27

                      5     - Octets, administratively assigned
                              Maximum remaining length 27

                      6-127 - reserved, unused

                    127-255 - as defined by the state
information such enterprise
                              Maximum remaining length 27
                "
    SYNTAX       OCTET STRING (SIZE(1..32))

SnmpSecurityModel ::= TEXTUAL-CONVENTION
    STATUS       current
    DESCRIPTION "An identifier that uniquely identifies a Response message can be generated using securityModel
                 of the
same Security Subsystem within the SNMP
                 Management Architecture.

                 The values for securityModel are allocated as follows:

                 - The zero value is reserved.
                 - Values between 1 and 255, inclusive, are reserved
                   for standards-track Security Models and are managed
                   by the Internet Assigned Numbers Authority (IANA).
                 - Values greater than 255 are allocated to enterprise
                   specific Security Models.  An enterprise specific
                   securityModel value is defined to be:

                   enterpriseID * 256 + security state information, even if model within enterprise

                   For example, the Local Configuration
Datastore is altered between fourth Security Model defined by
                   the time 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 incoming request and
the outgoing response.

\

Applications have the responsibility for explicitly releasing assignment of new
                 securityModel values will be rare in practice
                 because the
cached data. To enable this, an abstract stateReference data element
is passed from larger the number of simultaneously
                 utilized Security Subsystem to Models, the Message Processing
Subsystem, which passes it to larger the application.

The cached security data may chance that
                 interoperability will suffer.  Consequently, it is
                 believed that such a range will be implicitly released via sufficient.
                 In the
generation of a response, or explicitly released by using unlikely event that the
stateRelease primitive:

stateRelease(
     stateReference             -- handle of reference standards committee
                 finds this number to be released
     )

\

A.2. SNMP engine and Message Processing Model Requirements

An SNMP engine contains a Message Processing Subsystem which may
contain multiple version-specific Message Processing Models.

Within any version-specific Message Processing Model, there may be insufficient over time, an explicit binding
                 enterprise number can be allocated to a particular Security Model but there should obtain an
                 additional 255 possible values.

                 Note that the most significant bit must be no reference zero;
                 hence, there are 23 bits allocated for various
                 organizations to any data defined by a specific design and define non-standard
                 securityModels.  This limits the ability to define
                 new proprietary implementations of Security Model.
There should be no reference Models
                 to any specific application, or the first 8,388,608 enterprises.

                 It is worthwhile to any
data defined by note that, in its encoded form,
                 the securityModel value will normally require only a specific application; there should
                 single byte since, in practice, the leftmost bits will
                 be no reference
to any specific Access Control Model, or to any data defined 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)

SnmpMessageProcessingModel ::= TEXTUAL-CONVENTION
    STATUS       current
    DESCRIPTION "An identifier that uniquely identifies a
specific Access Control Model.

The Message
                 Processing Model MUST always (conceptually) pass the
complete PDU, i.e. it never forwards less than the complete list of
varBinds.

A.2.1. Receiving an SNMP Message from the Network

Upon receipt of Message Processing Subsystem
                 within a message from the network, the SNMP engine notes the
msgID, which is subsequently  used Management Architecture.

                 The values for coordinating all processing
regarding this received message.

A messageProcessingModel are allocated
                 as follows:

                 - Values between 0 and 255, inclusive, are reserved
                   for standards-track Message Processing Model specifies how to determine the values of
the global data (mms, the securityModel, the LoS), Models and
                   are managed by the Internet Assigned Numbers
                   Authority (IANA).
                 - Values greater than 255 are allocated to enterprise
                   specific Message Processing Models.  An enterprise
                   messageProcessingModel value is defined to be:

                   enterpriseID * 256 +
                        messageProcessingModel within enterprise

                   For example, the security
parameters block. The fourth Message Processing Model calls the Security
Model to provide security processing for the message using the
primitive:

processMsg(
    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
                   defined by the wire
    ) enterprise whose enterpriseID is 1
                   would be 260.

                 The Security Model uses the following primitive to respond:

returnProcessedMsg(
    securityName                -- identification eight bits allow a maximum of the principal
    scopedPDU,                  -- message (plaintext) payload
    maxSizeResponseScopedPDU    -- 256 standards based
                 Message Processing Models.  Similarly, they allow a
                 maximum size 256 Message Processing Models per enterprise.

                 It is believed that the assignment of new
                 messageProcessingModel values will be rare in practice
                 because the Response PDU
    securityStateReference      -- reference to security state
                                -- information, needed for response
    statusInformation           -- errorIndication or success
    )                           -- error counter OID/value if error

\

A.2.2. Send SNMP messages to larger the network

The number of simultaneously
                 utilized Message Processing Model passes Models, the larger the
                 chance that interoperability will suffer. It is
                 believed that such a PDU, range will be sufficient.
                 In the
securityName, and all global data unlikely event that the standards committee
                 finds this number to be included in the message insufficient over time, an
                 enterprise number can be allocated to obtain an
                 additional 256 possible values.

                 Note that the Security model using the following primitives:

For requests and notifications:

generateRequestMsg(
    messageProcessingModel      -- typically, SNMP version
    msgID                       -- most significant bit must be zero;
                 hence, there are 23 bits allocated for various
                 organizations to design and define non-standard
                 messageProcessingModels.  This limits the outgoing message
    mms                         -- ability
                 to define new proprietary implementations of Message
                 Processing Models to the sending SNMP entity
    msgFlags                    -- for the outgoing message
    securityParameters          -- filled first 8,388,608 enterprises.

                 It is worthwhile to note that, in by Security Module 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 outgoing message
    securityName                -- on behalf encoding rules.

                 As of this principal
    LoS                         -- Level writing, there are several values of Security requested
    snmpEngineID                -- authoritative SNMP engine
    scopedPDU                   -- message (plaintext) payload
    )

For response messages:

generateResponseMsg(
                 messageProcessingModel      -- typically, SNMP version
    msgID                       -- defined for the outgoing message
    mms                         -- use with SNMP.

                 They are as follows:

                     0  reserved for SNMPv1
                     1  reserved for SNMPv2c
                     2  reserved for SNMPv2u
                     3  reserved for SNMPv3
                "
    SYNTAX       INTEGER(0..2147483647)

SnmpSecurityLevel ::= TEXTUAL-CONVENTION
    STATUS       current
    DESCRIPTION "A Level of the sending Security at which SNMP entity
    msgFlags                    -- for messages can be
                 sent or with which operations are being processed;
                 in particular, one of:

                   noAuthNoPriv - without authentication and
                                  without privacy,
                   authNoPriv   - with authentication but
                                  without privacy,
                   authPriv     - with authentication and
                                  with privacy.

                 These three values are ordered such that noAuthNoPriv
                 is less than authNoPriv and authNoPriv is less than
                 authPriv.
                "
    SYNTAX       INTEGER { noAuthNoPriv(1),
                           authNoPriv(2),
                           authPriv(3)
                         }

SnmpAdminString ::= TEXTUAL-CONVENTION
    DISPLAY-HINT "255a"
    STATUS       current
    DESCRIPTION "An octet string containing administrative information,
                 preferably in human-readable form.

                 To facilitate internationalization, this information
                 is represented using the outgoing message
    securityParameters          -- filled 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 Security Module
    securityModel               -- for amendments
                 to the outgoing message
    scopedPDU                   -- message (plaintext) payload
    securityStateReference      -- reference 10646 standard from time to security state
                                -- information, 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 received hexadecimal, may be
                 provided.

                 For information encoded in
    )                           -- processPdu primitive

The Security model constructs 7-bit US-ASCII, the message, and returns UTF-8
                 representation is identical to the completed
message US-ASCII encoding.

                 Note that when this TC is used for an object that
                 is used or envisioned to be used as an index, then a
                 SIZE restriction must be specified so that the Message Processing Model using number
                 sub-identifiers for any object instance do not exceed
                 the returnGeneratedMsg
primitive:

returnGeneratedMsg(
    wholeMsg limit of 128, as defined by [RFC1905].
                "
    SYNTAX       OCTET STRING (SIZE (0..255))

-- complete generated message
    wholeMsgLength Administrative assignments ****************************************

snmpFrameworkAdmin          OBJECT IDENTIFIER ::= { snmpFrameworkMIB 1 }
snmpFrameworkMIBObjects     OBJECT IDENTIFIER ::= { snmpFrameworkMIB 2 }
snmpFrameworkMIBConformance OBJECT IDENTIFIER ::= { snmpFrameworkMIB 3 }

-- length the snmpEngine Group **********************************************

snmpEngine OBJECT IDENTIFIER ::= { snmpFrameworkMIBObjects 1 }

snmpEngineID     OBJECT-TYPE
    SYNTAX       SnmpEngineID
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION "An SNMP engine's administratively-unique identifier.
                "
    ::= { snmpEngine 1 }

snmpEngineBoots  OBJECT-TYPE
    SYNTAX       Unsigned32 -- (1..4294967295)
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION "The number of times that the generated message
    statusInformation           -- errorIndication or success
    )

The SNMP engine sends the message to the desired address using has
                 (re-)initialized itself since its initial
                 configuration.
                "
    ::= { snmpEngine 2 }

snmpEngineTime   OBJECT-TYPE
    SYNTAX       Integer32 (0..2147483647)
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION "The number of seconds since the
appropriate transport.

A.2.3. Generate Request or Notification Message for an Application

\

The SNMP engine receives a request for the generation of an SNMP
message from an application via last
                 incremented the sendPdu primitive:

sendPdu(
    transportDomain snmpEngineBoots object.
                "
    ::= { snmpEngine 3 }

-- transport domain to be Registration Points for Authentication and Privacy Protocols **

snmpAuthProtocols OBJECT-IDENTITY
    STATUS        current
    DESCRIPTION  "Registration point for standards-track authentication
                  protocols used
    transportAddress            -- destination network address
    messageProcessingModel      -- typically, in SNMP version
    securityModel               -- Security Model to use
    securityName                -- on behalf of this principal
    LoS Management Frameworks.
                 "
    ::= { snmpFrameworkAdmin 1 }

snmpPrivProtocols OBJECT-IDENTITY
    STATUS        current
    DESCRIPTION  "Registration point for standards-track privacy
                  protocols used in SNMP Management Frameworks.
                 "
    ::= { snmpFrameworkAdmin 2 }

-- Level of Security requested
    contextEngineID Conformance information *******************************************

snmpFrameworkMIBCompliances
               OBJECT IDENTIFIER ::= { snmpFrameworkMIBConformance 1 }
snmpFrameworkMIBGroups
               OBJECT IDENTIFIER ::= { snmpFrameworkMIBConformance 2 }

-- data from/at this entity
    contextName compliance statements

snmpFrameworkMIBCompliance MODULE-COMPLIANCE
    STATUS       current
    DESCRIPTION "The compliance statement for SNMP engines which
                 implement the SNMP Management Framework MIB.
                "
    MODULE    -- data from/in this context
    PDU                         -- SNMP Protocol Data Unit
    expectResponse module
        MANDATORY-GROUPS { snmpEngineGroup }

    ::= { snmpFrameworkMIBCompliances 1 }

-- TRUE or FALSE
    )

The SNMP engine checks the "expectResponse" parameter to determine if
it is a message which is expected to receive a response, units of conformance

snmpEngineGroup OBJECT-GROUP
    OBJECTS {
              snmpEngineID,
              snmpEngineBoots,
              snmpEngineTime
            }
    STATUS       current
    DESCRIPTION "A collection of objects for identifying and if so,
caches
                 determining the msgID configuration and current timeliness
                 values of the generated message an SNMP engine.
                "
    ::= { snmpFrameworkMIBGroups 1 }

END

6. Security Considerations

This document describes how an implementation can include a Security
Model to protect network management messages and the associated
application.

The Message Processing an Access Control
Model generates the message according to the
process described in A.2.2.

A.2.4. Pass Received Response Message control access to an Application management information.

The Message Processing Model receives level of security provided is determined by the SNMP message according to specific Security
Model implementation(s) and the process described in A.2.1.

The Message Processing specific Access Control Model determines
implementation(s) used.

Applications have access to data which application is awaiting
this response, using the msgID and not secured.  Applications
should take reasonable steps to protect the cached information data from
step A.2.3

The Message Processing Model matches disclosure.

It is the responsibility of the msgID purchaser of an incoming response implementation to
ensure that:
  1) an implementation complies with the cached msgIDs of messages sent rules defined by this SNMP engine,
      architecture,
  2) the Security and
forwards Access Control Models utilized satisfy the response to
      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. 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

8. Acknowledgements

This document is the associated application using result of the
processResponsePdu primitive:

processResponsePdu(             -- process Response PDU
    contextEngineID             -- data from/at this SNMP entity
    contextName                 -- data from/in this context
    PDU                         -- SNMP Protocol Data Unit
    LoS                         -- Level efforts of Security
    statusInformation           -- success or errorIndication
    )

A.2.5. Pass Received Request or Notification Message to Application

The Message Processing Model receives the SNMP message according SNMPv3 Working Group.
Some special thanks are in order to the process described in A.2.1.

\ following SNMPv3 WG members:

    Dave Battle (SNMP Research, Inc.)
    Uri Blumenthal (IBM T.J. Watson Research Center)
    Jeff Case (SNMP Research, Inc.)
    John Curran (BBN)
    T. Max Devlin (Hi-TECH Connections)
    John Flick (Hewlett Packard)
    David Harrington (Cabletron Systems Inc.)
    N.C. Hien (IBM T.J. Watson Research Center)
    Dave Levi (SNMP Research, Inc.)
    Louis A Mamakos (UUNET Technologies Inc.)
    Paul Meyer (Secure Computing Corporation)
    Keith McCloghrie (Cisco Systems)
    Russ Mundy (Trusted Information Systems, Inc.)
    Bob Natale (ACE*COMM Corporation)
    Mike O'Dell (UUNET Technologies Inc.)
    Dave Perkins (DeskTalk)
    Peter Polkinghorne (Brunel University)
    Randy Presuhn (BMC Software, Inc.)
    David Reid (SNMP Research, Inc.)
    Shawn Routhier (Epilogue)
    Juergen Schoenwaelder (TU Braunschweig)
    Bob Stewart (Cisco Systems)
    Bert Wijnen (IBM T.J. Watson Research Center)

The SNMP engine looks into the scopedPDU to determine document is based on recommendations of the
contextEngineID, then determine which application has registered to
support that contextEngineID, IETF Security and forwards
Administrative Framework Evolution for SNMP Advisory Team.
Members of that Advisory Team were:

    David Harrington (Cabletron Systems Inc.)
    Jeff Johnson (Cisco Systems)
    David Levi (SNMP Research Inc.)
    John Linn (Openvision)
    Russ Mundy (Trusted Information Systems) chair
    Shawn Routhier (Epilogue)
    Glenn Waters (Nortel)
    Bert Wijnen (IBM T. J. Watson Research Center)

As recommended by the request or notification
to Advisory Team and the registered application using SNMPv3 Working Group
Charter, the processPdu primitive:

processPdu(                     -- process Request/Notification PDU
    contextEngineID             -- data from/at this SNMP engine
    contextName                 -- data from/in this context
    PDU                         -- SNMP Protocol Data Unit
    maxSizeResponseScopedPDU    -- maximum size of design incorporates as much as practical from previous
RFCs and drafts. As a result, special thanks are due to the Response PDU
    securityModel               -- Security Model in use
    securityName                -- on behalf authors
of this principal
    LoS                         -- Level previous designs known as SNMPv2u and SNMPv2*:

    Jeff Case (SNMP Research, Inc.)
    David Harrington (Cabletron Systems Inc.)
    David Levi (SNMP Research, Inc.)
    Keith McCloghrie (Cisco Systems)
    Brian O'Keefe (Hewlett Packard)
    Marshall T. Rose (Dover Beach Consulting)
    Jon Saperia (BGS Systems Inc.)
    Steve Waldbusser (International Network Services)
    Glenn W. Waters (Bell-Northern Research Ltd.)

9. References

[RFC1155] Rose, M., and K. McCloghrie, "Structure and Identification
    of Security
    stateReference              -- reference to state information
    )                           -- needed when sending a response

A.2.6. Generate a Response Message Management Information for an Application 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 SNMP engine receives a request 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 the generation Version  2 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
    PDU                         -- SNMP Simple Network Management
    Protocol Data Unit
    maxSizeResponseScopedPDU    -- maximum size of the Response PDU
    securityModel               -- Security Model in use
    securityName                -- on behalf of this principal
    LoS                         -- Level (SNMPv2)", RFC 1902, January 1996.

[RFC1903] The SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M.,
    and S. Waldbusser, "Textual Conventions for Version 2 of Security
    stateReference              -- reference to state information
                                -- as presented with the request
    statusInformation           -- success or errorIndication
    )                           -- error counter OID/value if error Simple
    Network Management Protocol (SNMPv2)", RFC 1903, January 1996.

[RFC1904] The SNMP engine generates the message according to SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M.,
    and S., Waldbusser, "Conformance Statements for Version 2 of the process
described in A.2.2.

A.3. Application Design Requirements

Within an application, there may be an explicit binding to a specific
SNMP message version, i.e. a specific Message Processing Model,
    Simple Network Management Protocol (SNMPv2)", RFC 1904,
    January 1996.

[RFC1905] The SNMPv2 Working Group, Case, J., McCloghrie, K.,
    Rose, M., and to
a specific Access Control Model, but there should be no reference to
any data defined by a specific Message Processing Model or Access
Control Model.

Within an application, there should be no reference to any specific
Security Model, or any data defined by a specific Security Model.

\

An application determines whether explicit or implicit access control
should be applied to S., Waldbusser, "Protocol Operations for
    Version 2 of the operation, and, if access control is needed,
which Access Control Model should be used.

An application has 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 responsibility to define any MIB modules used
to provide application-specific services.

Applications interact with 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 SNMP engine to initiate messages,
receive responses, receive asynchronous messages, Simple Network Management Protocol (SNMPv2)",
    RFC 1907 January 1996.

[RFC1908] The SNMPv2 Working Group, Case, J., McCloghrie, K.,
    Rose, M., and send responses.

A.3.1. Applications that Initiate Messages

Applications may request that S. Waldbusser, "Coexistence between Version 1
    and Version 2 of the SNMP engine send messages containing
SNMP commands or notifications using SNMP-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

[SNMP-MPD] The SNMPv3 Working Group, Case, J., Harrington, D.,
     Wijnen, B., "Message Processing and Dispatching for the sendPdu primitive:

sendPdu(
    transportDomain             -- transport domain to be used
    transportAddress            -- destination network address
    messageProcessingModel      -- typically, SNMP version
    securityModel               -- Simple
     Network Management Protocol (SNMP)",
     draft-ietf-snmpv3-mpc-03.txt, August 1997

[SNMP-USM] The SNMPv3 Working Group, Blumenthal, U., Wijnen, B.,
     "The User-Based Security Model to use
    securityName                -- on behalf of this principal
    LoS                         -- Level for Version 3 of Security requested
    contextEngineID             -- data from/at this entity
    contextName                 -- data from/in this context
    PDU                         -- SNMP the Simple
     Network Management Protocol Data Unit
    expectResponse              -- TRUE or FALSE
    )

If it is desired that a message be sent to multiple targets, it is (SNMPv3)",
     draft-ietf-snmpv3-usm-01.txt, August 1997.

[SNMP-ACM] The SNMPv3 Working Group, Wijnen, B., Presuhn, R.,
     McCloghrie, K., "View-based Access Control Model for the
responsibility Simple
     Network Management Protocol (SNMP)",
     draft-ietf-snmpv3-acm-02.txt, August 1997.

[SNMP-APPL] The SNMPv3 Working Group, Levi, D. B., Meyer, P.,
     Stewart, B., "SNMPv3 Applications",
     <draft-ietf-snmpv3-appl-01.txt>, August 1997

APPENDIX A

A. Guidelines for Model Designers

This appendix describes guidelines for designers of the application models which are
expected to provide fit into the iteration.

The architecture defined in this document.

SNMPv1 and SNMPv2c are two SNMP engine assumes necessary access control has been applied frameworks which use communities to the PDU,
provide trivial authentication and provides no access control services.
The SNMP engine looks at the "expectResponse" parameter, control. SNMPv1 and for
operations which elicit a response, the msgID SNMPv2c
Frameworks can coexist with Frameworks designed according to this
architecture, and modified versions of SNMPv1 and SNMPv2c Frameworks
could be designed to meet the associated
application are cached.

A.3.2. Applications requirements of this architecture, but
this document does not provide guidelines for that Receive Responses

The SNMP engine matches the msgID
coexistence.

Within any subsystem model, there should be no reference to any
specific model of an incoming response another subsystem, or to data defined by a specific
model of another subsystem.

Transfer of data between the
cached msgIDs subsystems is deliberately described as
a fixed set of messages sent by this SNMP engine, abstract data elements and forwards primitive functions which
can be overloaded to satisfy the
response needs of multiple model definitions.

Documents which define models to be used within this architecture
SHOULD use the associated application using standard primitives between subsystems, possibly
defining specific mechanisms for converting the processResponsePdu
primitive:

processResponsePdu(             -- process Response PDU
    contextEngineID             -- data from/at this SNMP entity
    contextName                 -- abstract data from/in this context
    PDU                         -- SNMP Protocol Data Unit
    LoS                         -- Level of Security
    statusInformation           -- success or errorIndication

\
    )

The SNMP engine then releases its own state information about this
message.

A.3.3. Applications that Receive Asynchronous Messages

When an SNMP engine receives a message that is elements
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 response architecture defines abstract service
interfaces to a request from this SNMP engine, these services.

Each model definition for a subsystem SHOULD support the standard
service interfaces, but whether, or how, or how well, it must determine to which application performs
the message should be given.

An Application that wishes to receive asynchronous messages registers
itself with service is dependent on the engine using model definition.

A.1. Security Model Design Requirements

A.1.1. Threats

A document describing a Security Model MUST describe how the registration primitive.
An Application that wishes to stop receiving asynchronous messages
should unregister itself with model
protects against the SNMP engine.

statusInformation =             -- success or errorIndication
    registerContextEngineID(
        contextEngineID         -- take responsibility for threats described under "Security Requirements
of this one
        pduType                 -- the pduType(s) to Architecture", section 1.4.

A.1.2. Security Processing

Received messages MUST be registered
        )

unregisterContextEngineID(
        contextEngineID         -- give up responsibility for this one
        pduType                 -- validated by a Model of the pduType(s) Security
Subsystem.  Validation includes authentication and privacy processing

if needed, but it is explicitly allowed to send messages which do not
require authentication or privacy.

A received message contains a specified Level of Security to be unregistered
        )

Only one registration per PDU type per contextEngineID is permitted
at the same time. Duplicate registrations used
during processing.  All messages requiring privacy MUST also require
authentication.

A Security Model specifies rules by which authentication and privacy
are ignored. An
errorIndication will to be returned done.  A model may define mechanisms to provide additional
security features, but the application that attempts model definition is constrained to duplicate a registration.

All asynchronously received messages containing using
(possibly a registered
PDU type and contextEngineID are sent subset of) the abstract data elements defined in this
document for transferring data between subsystems.

Each Security Model may allow multiple security protocols to be used
concurrently within an implementation of the application model. Each Security
Model defines how to determine which
registered protocol to support that combination.

The engine forwards use, given the PDU
securityLevel and the security parameters relevant to the registered application, message.
Each Security Model, with its associated protocol(s) defines how the
sending/receiving entities are identified, and how secrets are
configured.

Authentication and Privacy protocols supported by Security Models are
uniquely identified using Object Identifiers. IETF standard protocols
for authentication or privacy should have an identifier defined within
the
processPdu primitive:

processPdu(                     -- process Request/Notification PDU
    contextEngineID             -- data from/at this SNMP engine
    contextName                 -- data from/in this context
    PDU                         -- SNMP Protocol Data Unit
    maxSizeResponseScopedPDU    -- maximum size snmpAuthProtocols or the snmpPrivProtocols subtrees. Enterprise
specific protocol identifiers should be defined within the enterprise
subtree.

For privacy, the Security Model defines what portion of the Response PDU
    securityModel               -- message
is encrypted.

The persistent data used for security should be SNMP-manageable, but
the Security Model in use
    securityName                -- on behalf defines whether an instantiation of this principal
    LoS                         -- Level the MIB is a
conformance requirement.

Security Models are replaceable within the Security Subsystem.
Multiple Security Model implementations may exist concurrently within
an SNMP engine.  The number of Security
    stateReference              -- reference Models defined by the SNMP
community should remain small to state information
    )                           -- needed when sending promote interoperability.

A.1.3. Validate the security-stamp in a response

A.3.4. Applications received message

A Message Processing Model requests that Send Responses

\

Request operations require responses. These operations include Get
requests, Set requests, and Inform requests.  An application sends a
response via Security Model:
  - verifies that the returnResponsePdu primitive:

returnResponsePdu(
    contextEngineID             -- data from/at this SNMP engine
    contextName                 -- data from/in this context
    PDU                         -- SNMP Protocol Data Unit
    maxSizeResponseScopedPDU    -- maximum size of message has not been altered,
  - authenticates the Response PDU
    securityModel               -- on behalf of this principal
    securityName                -- on behalf identification of this the principal
    LoS                         -- Level of Security
    stateReference              -- reference to state information
                                -- as presented with for whom the request
    statusInformation           -- success or errorIndication
    )                           -- error counter OID/value
    message was generated.
  - decrypts the message if error

The contextEngineID, contextName, securityModel, securityName, LoS, and
stateReference parameters are from it was encrypted.

Additional requirements may be defined by the initial processPdu primitive.
The PDU model, and statusInformation are additional
services may be provided by the results of processing.

A.4. Access Control Model Design Requirements

An Access Control Model determines whether model, but the specified
securityName model is allowed constrained
to perform use the requested operation on
a specified managed object. following primitives for transferring data between

subsystems. Implementations are not so constrained.

A Message Processing Model uses the processMsg primitive as
described in section 4.5.

A.1.4. Security MIBs

Each Security Model defines the MIB module(s) required for security
processing, including any MIB module(s) required for the security
protocol(s) supported.  The Access Control Model specifies MIB module(s) SHOULD be defined
concurrently with the
rules by procedures which access control is determined. use the MIB module(s).  The persistent data used for
MIB module(s) are subject to normal access control should rules.

The mapping between the model dependent security ID and the
securityName MUST be manageable able to be determined using SNMP, but if the Access Control model defines whether an
instantiation of the
dependent MIB is instantiated and if access control policy allows
access.

A.1.5. Cached Security Data

For each message received, the Security Model caches the state
information such that a conformance requirement.

The following primitive Response message can be generated using the
same security information, even if the Local Configuration Datastore
is used to invoke altered between the time of the incoming request and the outgoing
response.

A Message Processing Model has the responsibility for explicitly
releasing the cached data if such data is no longer needed. To enable
this, an abstract securityStateReference data element is passed from
the access control service:

statusInformation =             -- success or errorIndication
    isAccessAllowed(
        securityModel           -- Security Model in use
        securityName            -- principal who wants to access
        LoS                     -- Level the Message Processing Model.

The cached security data may be implicitly released via the generation
of Security
        viewType                -- read, write, a response, or notify view
        contextName             -- context containing variableName
        variableName            -- OID for explicitly released by using the managed object
        )

\

APPENDIX B

B. An Evolutionary Architecture - stateRelease
primitive, as described in section 4.1.

A.2. Message Processing Model Design Goals Requirements

An SNMP engine contains a Message Processing Subsystem which may
contain multiple Message Processing Models.

The goals of Message Processing Model MUST always (conceptually) pass the
complete PDU, i.e. it never forwards less than the architectural design are to use encapsulation,
cohesion, hierarchical rules, and loose coupling to reduce complexity complete list of design and make
varBinds.

A.2.1. Receiving an SNMP Message from the evolution of portions Network

Upon receipt of a message from the architecture
possible.

B.1. Encapsulation

Encapsulation describes network, the practice of hiding Dispatcher in 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
SNMP engine determines the version of the process.

In networking, SNMP message and interacts
with the concept of a layered stack reflects this approach.
The transport layer contains data specific corresponding Message Processing Model to its processing; determine the
abstract data
is not visible to elements.

A Message Processing Model specifies the other layers. In programming this is reflected
in language elements such as "file static" variables in C, SNMP Message format it
supports and
"private" in C++, etc.

In this architecture, all data used for processing only within
a functional portion describes how to determine the values of the architecture should have its visibility
restricted to that portion if possible. The abstract
data should be accessed
only by that functionality defined elements (like msgID, msgMaxSize, msgFlags, msgSecurityParameters,
securityModel, securityLevel etc). A Message Processing Model interacts
with the data. No reference a Security Model to provide security processing for the
data should be made from outside message
using the functional portion of processMsg primitive, as described in section 4.5.

A.2.2. Sending an SNMP Message to the
architecture, except through predefined public interfaces.

B.2. Cohesion

Similar functions can be grouped together and their differences
ignored, so they can be dealt Network

The Dispatcher in the SNMP engine interacts with as a single entity. It is important Message Processing
Model to prepare an outgoing message. For that it uses the functions which are grouped together are actually similar.
Similarity of the data used to perform functions can be following
primitives:

 - for requests and notifications:
   prepareOutgoingMessage, as described in section 4.4

 - for response messages:
   prepareResponseMessage, as described in section 4.4

A Message Processing Model, when preparing an Outgoing SNMP Message,
interacts with a good
indicator of the similarity of Security Model to secure the functions. message. For example, authentication that it uses
the following primitives:

 - for requests and encryption are both security functions
which are applied to a message. Access control, while similar notifications:
   generateRequestMsg, as described in some
ways, is dissimilar section 4.5.

 - for response messages:
   generateResponseMsg as described in that it is not applied to a message, it section 4.5.

Once the SNMP message is
applied to a (proposed) request for prepared by a management operation.
The data required to perform authentication and encryption are
different than Message Processing Model, the data needed
Dispatcher sends the message to perform access control, and the
two sets of services can be described independently.

Similar functions, especially those that use desired address using the same data elements,
should appropriate
transport.

A.3. Application Design Requirements

Within an application, there may be defined together. The security functions which operate at
the an explicit binding to a specific
SNMP message level version, i.e. a specific Message Processing Model, and to
a specific Access Control Model, but there should be defined in a document together with the
definitions for those no reference to
any data elements that are used only defined by those
security functions. For example, a MIB with authentication keys is
used only by authentication functions; they specific Message Processing Model or Access
Control Model.

Within an application, there should be defined together.

\

B.3. Hierarchical Rules

Functionality can be grouped into hierarchies where each element in the
hierarchy receives general characteristics from its direct superior,
and passes on those characteristics no reference to any specific
Security Model, or any data defined by a specific Security Model.

An application determines whether explicit or implicit access control
should be applied to each of its direct subordinates.

This architecture uses the hierarchical approach by defining
subsystems, operation, and, if access control is needed,
which specify the general rules of a portion of Access Control Model should be used.

An application has the system,
models which responsibility to define any MIB module(s) used
to provide application-specific services.

Applications interact with the specific rules SNMP engine to be followed by an
implementation of initiate messages,
receive responses, receive asynchronous messages, and send responses.

A.3.1. Applications that Initiate Messages

Applications may request that the portion of SNMP engine send messages containing
SNMP commands or notifications using the system, and implementations which
encode those rules into reality for sendPdu primitive as described
in section 4.2.

If it is desired that a portion of message be sent to multiple targets, it is the system.

Within portions
responsibility of the system, hierarchical relationships are used application to
compartmentalize, or modularize, the implementation of specific
functionality. For example, within provide the security portion of iteration.

The SNMP engine assumes necessary access control has been applied to
the system,
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 PDU, and privacy provides no access control services.

B.4. Coupling

Coupling describes

The SNMP engine looks at the amount of interdependence between parts of "expectResponse" parameter, and if a system. Loose coupling indicates
response is expected, then the appropriate information is cached such
that two sub-systems are relatively
independent of each other; tight coupling indicates a high degree of
mutual dependence.

To make it possible later response can be associated to this message, and can then
be returned to evolve the architecture by replacing only part
of application. A sendPduHandle is returned to the system, or by supplementing existing portions
application so it can later correspond the response with alternate
mechanisms for similar functionality, without obsoleting this message
as well.

A.3.2. Applications that Receive Responses

The SNMP engine matches the complete
system, it is necessary incoming response messages to limit the coupling of the parts.

Encapsulation outstanding
messages sent by this SNMP engine, and cohesion help forwards the response to reduce coupling by limiting the
visibility of those parts
associated application using the processResponsePdu primitive, as
described in section 4.2.

A.3.3. Applications that are only needed within portions of Receive Asynchronous Messages

When an SNMP engine receives a
system. Another mechanism message that is to constrain not the nature of interactions
between various parts of response to a
request from this SNMP engine, it must determine to which application
the system.

This can message should be done by defining fixed, generic, flexible interfaces
for transferring data between given.

An Application that wishes to receive asynchronous messages registers
itself with the parts of engine using the system. The concept of
plug-and-play hardware components is based on primitive registerContextEngineID
as described in section 4.2.

An Application that type of interface
between wishes to stop receiving asynchronous messages
should unregister itself with the hardware component SNMP engine using the primitive
unregisterContextEngineID as described in section 4.2.

Only one registration per combination of PDU type and system into which it contextEngineID
is "plugged."

This approach has been chosen so individual portions of permitted at the system
can same time. Duplicate registrations are ignored.
An errorIndication will be upgraded over time, while keeping returned to the overall system intact.

To avoid specifying fixed interfaces, which would constrain application that attempts
to duplicate a vendor's
choice of implementation strategies, registration.

All asynchronously received messages containing 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 registered
combination of subsystems or models should use only
the abstract data elements provided for transferring data but vendors

\ PDU type and contextEngineID are not constrained sent to the
application which registered to support that combination.

The engine forwards the PDU to the registered application, using the
processPdu primitive, as described data elements for
transferring data between portions of their implementation.

Loose coupling works well with in section 4.2.

A.3.4. Applications that Send Responses

Request operations require responses.  An application sends
a response via the IETF standards process. If we
separate message-handling from security returnResponsePdu primitive, as described in
section 4.2.

The contextEngineID, contextName, securityModel, securityName,
securityLevel, and stateReference parameters are from local processing,
then the separate portions of the system can move through the standards
process with less dependence on the status of initial
processPdu primitive. The PDU and statusInformation are the other portions results
of processing.

A.4. Access Control Model Design Requirements

An Access Control Model determines whether the
standard. Security models may be able to be re-opened for discussion
due to patents, new research, export laws, etc., as specified securityName
is clearly expected
by the WG, without needing allowed to reopen perform the documents which detail requested operation on a specified managed
object. The Access Control Model specifies the
message format or rules by which access
control is determined.

The persistent data used for access control should be manageable using
SNMP, but the local processing Access Control Model defines whether an instantiation of PDUs. Thus,
the standards
track status of related, but independent, documents MIB is not affected.

\ a conformance requirement.

The Access Control Model must provide the primitive isAccessAllowed

Table of Contents

0. Issues                                                             2
0.1. Resolved Issues to be resolved                                                  2
0.1.1. Issues discussed at second Interim Meeting:                    2                    3
0.2.  Change Log                                                      3                                                      4
1. Introduction                                                       7                                                      10
1.1. Target Audience                                                  7 Overview                                                        10
1.2. SNMP Management Systems                                               7                                         10
1.3. Goals of this Architecture                                       8                                      11
1.4. Security Requirements of this Architecture                       9                      12
1.5. Design Decisions                                                10                                                13
2.  Documentation Overview                                           12                                           15
2.1. Document Roadmap                                                13                                                16
2.2. Applicability Statement                                         13                                         16
2.3. Coexistence and Transition                                      13                                      16
2.4. Transport Mappings                                              14                                              17
2.5. Message Processing                                              14                                              17
2.6. Security                                                        14                                                        17
2.7. Access Control                                                  14                                                  17
2.8. Applications                                                    15 Protocol Operations                                             18
2.9. Applications                                                    18
2.10. Structure of Management Information                             15
2.10.                            18
2.11. Textual Conventions                                            15
2.11.                                            18
2.12. Conformance Statements                                         15
2.12. Protocol Operations                                            16                                         18
2.13. Management Information Base Modules                            16                            19
2.13.1. SNMP Instrumentation MIBs                                    16                                    19
2.14. SNMP Framework Documents                                       16                                       19
2.15. Operational Overview                                           21
3. Naming                                                            18 Elements of the Architecture                                      23
3.1. The Naming of Entities                                          18                                          23
3.1.1. SNMP entity                                                   19                                                   24
3.1.2. SNMP engine                                                   19                                                   24
3.1.3. snmpEngineID                                                  19                                                  24
3.1.4. Dispatcher                                                    24
3.1.5. Message Processing Subsystem                                  19
3.1.5.                                  25
3.1.6. Message Processing Model                                      19
3.1.6.                                      25
3.1.7. Security Subsystem                                            20
3.1.7.                                            26
3.1.8. Security Model                                                20
3.1.8.                                                26
3.1.9. Security Protocol                                             20
3.1.9.                                             26
3.1.10. Access Control Subsystem                                      21
3.1.10.                                     27
3.1.11. Access Control Model                                         21
3.1.11. Applications                                                 21                                         27
3.1.12. Applications                                                 28
3.1.13. SNMP Agent                                                   21
3.1.13.                                                   28
3.1.14. SNMP Manager                                                 21                                                 28
3.2. The Naming of Identities                                        22                                        29
3.2.1. Principal                                                     22                                                     29
3.2.2. securityName                                                  22                                                  29
3.2.3. Model dependent security ID                                   22                                   29
3.3. The Naming of Management Information                            23                            30
3.3.1. An SNMP Context                                               24                                               31
3.3.2. contextEngineID                                               24                                               31
3.3.3. contextName                                                   24                                                   31

3.3.4. scopedPDU                                                     24                                                     32
3.4. Other Constructs                                                25

\^L                                                32
3.4.1. maxSizeResponseScopedPDU                                      25                                      32
3.4.2. Local Configuration Datastore                                 25                                 32
3.4.3. LoS                                                           25 securityLevel                                                 32
4. Architectural Elements of Procedure                               26 Abstract Service Interfaces.                                      33
4.1.  Operational Overview                                           27  Common Primitives                                              33
4.1.1.  Release State Reference Information                          33
4.2. Sending and Receiving SNMP Messages                             29  Dispatcher Primitives                                          33
4.2.1. Send a Message to the Network                                 29  Generate Outgoing Request or Notification                    33
4.2.2. Receive a Message from the Network                            29  Process Incoming Request or Notification PDU                 34
4.2.3.  Generate Outgoing Response                                   34
4.2.4.  Process Incoming Response PDU                                34
4.2.5.  Registering Responsibility for Handling SNMP PDUs.           35
4.3. Send a  Message Processing Subsystem Primitives                        35
4.3.1.  Prepare an Outgoing SNMP Request or Notification Message for     35
4.3.2.  Prepare an Application       30 Outgoing SNMP Response Message                    36
4.3.3. Prepare Data Elements from an Incoming SNMP Message           36
4.4. Receive  Access Control Subsystem Primitives                            37
4.5.  Security Subsystem Primitives                                  37
4.5.1.  Generate a Request or Notification Message from the Network      30
4.5.                   37
4.5.2.  Process Incoming Message                                     37
4.5.3.  Generate a Response Message                                  38
4.6.  User Based Security Model Internal Primitives                  38
4.6.1.  User-based Security Model Primitives for an Authentication      38
4.6.2.  User-based Security Model Primitives for Privacy             39
4.7. Scenario Diagrams                                               40
4.7.1. Command Generator or Notification Originator Application                  31
4.6. Receive      40
4.7.2. Scenario Diagram for a Response Message                                      31
4.7. Registering to Receive Asynchronous Messages                    31 Command Responder Application          41
5. Definition of Managed Objects for Internet SNMP Management Frameworks  33      42
6. Security Considerations                                           39                                           51
7. Glossary                                                          40
8. References                                                        40
9. Editor's Addresses                                                42
10.                                                52
8. Acknowledgements                                                 43                                                  53
9. References                                                        55
A. Guidelines for Model Designers                                    44                                    57
A.1. Security Model Design Requirements                              44                              57
A.1.1. Threats                                                       44                                                       57
A.1.2. Security Processing                                           45                                           57
A.1.3. validate Validate the security-stamp in a received message             45
A.1.5.             58
A.1.4. Security MIBs                                                 46
A.1.6.                                                 59
A.1.5. Cached Security State Cache                                          46 Data                                          59
A.2. SNMP engine and Message Processing Model Design Requirements           48                    60
A.2.1. Receiving an SNMP Message from the Network                    48                    60
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 Sending an Application              50
A.2.5. Pass Received Request or Notification SNMP Message to Application  50
A.2.6. Generate a Response Message for an Application                51 the Network                        60
A.3. Application Design Requirements                                 51                                 60
A.3.1. Applications that Initiate Messages                           52                           61
A.3.2. Applications that Receive Responses                           52                           61
A.3.3. Applications that Receive Asynchronous Messages               53               61
A.3.4. Applications that Send Responses                              53                              62
A.4. Access Control Model Design Requirements                        54                        62