tech-invite   World Map
3GPP     Specs     Glossaries     UICC       IETF     RFCs     Groups     SIP     ABNFs       T+       Search     Home

RFC 2571

 
 
 

An Architecture for Describing SNMP Management Frameworks

Part 3 of 3, p. 38 to 62
Prev RFC Part

 


prevText      Top      Up      ToC       Page 38 
5.  Managed Object Definitions for SNMP Management Frameworks

   SNMP-FRAMEWORK-MIB DEFINITIONS ::= BEGIN

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

   snmpFrameworkMIB MODULE-IDENTITY
       LAST-UPDATED "9901190000Z"            -- 19 January 1999
       ORGANIZATION "SNMPv3 Working Group"
       CONTACT-INFO "WG-EMail:   snmpv3@tis.com
                     Subscribe:  majordomo@tis.com
                                 In message body:  subscribe snmpv3

                     Chair:      Russ Mundy
                                 TIS Labs at Network Associates
                     postal:     3060 Washington Rd
                                 Glenwood MD 21738
                                 USA
                     EMail:      mundy@tis.com
                     phone:      +1 301-854-6889

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

                     Co-editor   Randy Presuhn
                                 BMC Software, Inc.
                     postal:     965 Stewart Drive
                                 Sunnyvale, CA 94086
                                 USA
                     EMail:      randy_presuhn@bmc.com
                     phone:      +1 408-616-3100

                     Co-editor:  Bert Wijnen
                                 IBM T.J. Watson Research
                     postal:     Schagen 33
                                 3461 GL Linschoten

Top      Up      ToC       Page 39 
                                 Netherlands
                     EMail:      wijnen@vnet.ibm.com
                     phone:      +31 348-432-794
                    "
       DESCRIPTION  "The SNMP Management Architecture MIB"
   -- Revision History

       REVISION     "9901190000Z"            -- 19 January 1999
       DESCRIPTION  "Updated editors' addresses, fixed typos.
                     Published as RFC2571.
                    "
       REVISION     "9711200000Z"            -- 20 November 1997
       DESCRIPTION  "The initial version, published in RFC 2271.
                    "
       ::= { snmpModules 10 }

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

   SnmpEngineID ::= TEXTUAL-CONVENTION
       STATUS       current
       DESCRIPTION "An SNMP engine's administratively-unique identifier.
                    Objects of this type are for identification, not for
                    addressing, even though it is possible that an
                    address may have been used in the generation of
                    a specific value.

                    The value for this object may not be all zeros or
                    all 'ff'H or the empty (zero length) string.

                    The initial value for this object may be configured
                    via an operator console entry or via an algorithmic
                    function.  In the latter case, the following
                    example algorithm is recommended.

                    In cases where there are multiple engines on the
                    same system, the use of this algorithm is NOT
                    appropriate, as it would result in all of those
                    engines ending up with the same ID value.

                    1) The very first bit is used to indicate how the
                       rest of the data is composed.

                       0 - as defined by enterprise using former methods
                           that existed before SNMPv3. See item 2 below.

                       1 - as defined by this architecture, see item 3
                           below.

Top      Up      ToC       Page 40 
                       Note that this allows existing uses of the
                       engineID (also known as AgentID [RFC1910]) to
                       co-exist with any new uses.

                    2) The snmpEngineID has a length of 12 octets.

                       The first four octets are set to the binary
                       equivalent of the agent's SNMP management
                       private enterprise number as assigned by the
                       Internet Assigned Numbers Authority (IANA).
                       For example, if Acme Networks has been assigned
                       { enterprises 696 }, the first four octets would
                       be assigned '000002b8'H.

                       The remaining eight octets are determined via
                       one or more enterprise-specific methods. Such
                       methods must be designed so as to maximize the
                       possibility that the value of this object will
                       be unique in the agent's administrative domain.
                       For example, it may be the IP address of the SNMP
                       entity, or the MAC address of one of the
                       interfaces, with each address suitably padded
                       with random octets.  If multiple methods are
                       defined, then it is recommended that the first
                       octet indicate the method being used and the
                       remaining octets be a function of the method.

                    3) The length of the octet strings varies.

                       The first four octets are set to the binary
                       equivalent of the agent's SNMP management
                       private enterprise number as assigned by the
                       Internet Assigned Numbers Authority (IANA).
                       For example, if Acme Networks has been assigned
                       { enterprises 696 }, the first four octets would
                       be assigned '000002b8'H.

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

                       The fifth octet indicates how the rest (6th and
                       following octets) are formatted. The values for
                       the fifth octet are:

                         0     - reserved, unused.

                         1     - IPv4 address (4 octets)

Top      Up      ToC       Page 41 
                                 lowest non-special IP address

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

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

                         4     - Text, administratively assigned
                                 Maximum remaining length 27

                         5     - Octets, administratively assigned
                                 Maximum remaining length 27

                         6-127 - reserved, unused

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

   SnmpSecurityModel ::= TEXTUAL-CONVENTION
       STATUS       current
       DESCRIPTION "An identifier that uniquely identifies a
                    securityModel of the Security Subsystem within the
                    SNMP Management Architecture.

                    The values for securityModel are allocated as
                    follows:

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

                      enterpriseID * 256 + security model within
                      enterprise

                      For example, the fourth Security Model defined by
                      the enterprise whose enterpriseID is 1 would be
                      260.

Top      Up      ToC       Page 42 
                    This scheme for allocation of securityModel
                    values allows for a maximum of 255 standards-
                    based Security Models, and for a maximum of
                    255 Security Models per enterprise.

                    It is believed that the assignment of new
                    securityModel values will be rare in practice
                    because the larger the number of simultaneously
                    utilized Security Models, the larger the
                    chance that interoperability will suffer.
                    Consequently, it is believed that such a range
                    will be sufficient.  In the unlikely event that
                    the standards committee finds this number to be
                    insufficient over time, an enterprise number
                    can be allocated to obtain an additional 255
                    possible values.

                    Note that the most significant bit must be zero;
                    hence, there are 23 bits allocated for various
                    organizations to design and define non-standard
                    securityModels.  This limits the ability to
                    define new proprietary implementations of Security
                    Models to the first 8,388,608 enterprises.

                    It is worthwhile to note that, in its encoded
                    form, the securityModel value will normally
                    require only a single byte since, in practice,
                    the leftmost bits will be zero for most messages
                    and sign extension is suppressed by the encoding
                    rules.

                    As of this writing, there are several values
                    of securityModel defined for use with SNMP or
                    reserved for use with supporting MIB objects.
                    They are as follows:

                        0  reserved for 'any'
                        1  reserved for SNMPv1
                        2  reserved for SNMPv2c
                        3  User-Based Security Model (USM)
                   "
       SYNTAX       INTEGER(0 .. 2147483647)

   SnmpMessageProcessingModel ::= TEXTUAL-CONVENTION
       STATUS       current
       DESCRIPTION "An identifier that uniquely identifies a Message
                    Processing Model of the Message Processing
                    Subsystem within a SNMP Management Architecture.

Top      Up      ToC       Page 43 
                    The values for messageProcessingModel are
                    allocated as follows:

                    - Values between 0 and 255, inclusive, are
                      reserved for standards-track Message Processing
                      Models and are managed by the Internet Assigned
                      Numbers Authority (IANA).

                    - Values greater than 255 are allocated to
                      enterprise-specific Message Processing Models.
                      An enterprise messageProcessingModel value is
                      defined to be:

                      enterpriseID * 256 +
                           messageProcessingModel within enterprise

                      For example, the fourth Message Processing Model
                      defined by the enterprise whose enterpriseID
                      is 1 would be 260.

                    This scheme for allocating messageProcessingModel
                    values allows for a maximum of 255 standards-
                    based Message Processing Models, and for a
                    maximum of 255 Message Processing Models per
                    enterprise.

                    It is believed that the assignment of new
                    messageProcessingModel values will be rare
                    in practice because the larger the number of
                    simultaneously utilized Message Processing Models,
                    the larger the chance that interoperability
                    will suffer. It is believed that such a range
                    will be sufficient.  In the unlikely event that
                    the standards committee finds this number to be
                    insufficient over time, an enterprise number
                    can be allocated to obtain an additional 256
                    possible values.

                    Note that the most significant bit must be zero;
                    hence, there are 23 bits allocated for various
                    organizations to design and define non-standard
                    messageProcessingModels.  This limits the ability
                    to define new proprietary implementations of
                    Message Processing Models to the first 8,388,608
                    enterprises.

                    It is worthwhile to note that, in its encoded
                    form, the messageProcessingModel value will

Top      Up      ToC       Page 44 
                    normally require only a single byte since, in
                    practice, the leftmost bits will be zero for
                    most messages and sign extension is suppressed
                    by the encoding rules.

                    As of this writing, there are several values of
                    messageProcessingModel defined for use with SNMP.
                    They are as follows:

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

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

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

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

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

                    To facilitate internationalization, this
                    information is represented using the ISO/IEC
                    IS 10646-1 character set, encoded as an octet
                    string using the UTF-8 transformation format

Top      Up      ToC       Page 45 
                    described in [RFC2279].

                    Since additional code points are added by
                    amendments to the 10646 standard from time
                    to time, implementations must be prepared to
                    encounter any code point from 0x00000000 to
                    0x7fffffff.  Byte sequences that do not
                    correspond to the valid UTF-8 encoding of a
                    code point or are outside this range are
                    prohibited.

                    The use of control codes should be avoided.

                    When it is necessary to represent a newline,
                    the control code sequence CR LF should be used.

                    The use of leading or trailing white space should
                    be avoided.

                    For code points not directly supported by user
                    interface hardware or software, an alternative
                    means of entry and display, such as hexadecimal,
                    may be provided.

                    For information encoded in 7-bit US-ASCII,
                    the UTF-8 encoding is identical to the
                    US-ASCII encoding.

                    UTF-8 may require multiple bytes to represent a
                    single character / code point; thus the length
                    of this object in octets may be different from
                    the number of characters encoded.  Similarly,
                    size constraints refer to the number of encoded
                    octets, not the number of characters represented
                    by an encoding.

                    Note that when this TC is used for an object that
                    is used or envisioned to be used as an index, then
                    a SIZE restriction MUST be specified so that the
                    number of sub-identifiers for any object instance
                    does not exceed the limit of 128, as defined by
                    [RFC1905].

                    Note that the size of an SnmpAdminString object is
                    measured in octets, not characters.
                   "
       SYNTAX       OCTET STRING (SIZE (0..255))

Top      Up      ToC       Page 46 
   -- Administrative assignments ***************************************

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

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

   snmpEngine OBJECT IDENTIFIER ::= { snmpFrameworkMIBObjects 1 }

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

   snmpEngineBoots  OBJECT-TYPE
       SYNTAX       INTEGER (1..2147483647)
       MAX-ACCESS   read-only
       STATUS       current
       DESCRIPTION "The number of times that the SNMP engine has
                    (re-)initialized itself since snmpEngineID
                    was last configured.
                   "
       ::= { snmpEngine 2 }

   snmpEngineTime   OBJECT-TYPE
       SYNTAX       INTEGER (0..2147483647)
       UNITS        "seconds"
       MAX-ACCESS   read-only
       STATUS       current
       DESCRIPTION "The number of seconds since the value of
                    the snmpEngineBoots object last changed.
                    When incrementing this object's value would
                    cause it to exceed its maximum,
                    snmpEngineBoots is incremented as if a
                    re-initialization had occurred, and this
                    object's value consequently reverts to zero.
                   "
       ::= { snmpEngine 3 }

   snmpEngineMaxMessageSize OBJECT-TYPE
       SYNTAX       INTEGER (484..2147483647)

Top      Up      ToC       Page 47 
       MAX-ACCESS   read-only
       STATUS       current
       DESCRIPTION "The maximum length in octets of an SNMP message
                    which this SNMP engine can send or receive and
                    process, determined as the minimum of the maximum
                    message size values supported among all of the
                    transports available to and supported by the engine.
                   "
       ::= { snmpEngine 4 }


   -- Registration Points for Authentication and Privacy Protocols **

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

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

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

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

   -- compliance statements

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

       ::= { snmpFrameworkMIBCompliances 1 }

   -- units of conformance

Top      Up      ToC       Page 48 
   snmpEngineGroup OBJECT-GROUP
       OBJECTS {
                 snmpEngineID,
                 snmpEngineBoots,
                 snmpEngineTime,
                 snmpEngineMaxMessageSize
               }
       STATUS       current
       DESCRIPTION "A collection of objects for identifying and
                    determining the configuration and current timeliness
                    values of an SNMP engine.
                   "
       ::= { snmpFrameworkMIBGroups 1 }

   END


6.  IANA Considerations

   This document defines three number spaces administered by IANA, one
   for security models, another for message processing models, and a
   third for SnmpEngineID formats.

6.1.  Security Models

   The SnmpSecurityModel TEXTUAL-CONVENTION values managed by IANA are
   in the range from 0 to 255 inclusive, and are reserved for
   standards-track Security Models.  If this range should in the future
   prove insufficient, an enterprise number can be allocated to obtain
   an additional 255 possible values.

   As of this writing, there are several values of securityModel defined
   for use with SNMP or reserved for use with supporting MIB objects.
   They are as follows:
                        0  reserved for 'any'
                        1  reserved for SNMPv1
                        2  reserved for SNMPv2c
                        3  User-Based Security Model (USM)

6.2.  Message Processing Models

   The SnmpMessageProcessingModel TEXTUAL-CONVENTION values managed by
   IANA are in the range 0 to 255, inclusive.  Each value uniquely
   identifies a standards-track Message Processing Model of the Message
   Processing Subsystem within a SNMP Management Architecture.

   Should this range prove insufficient in the future, an enterprise
   number may be obtained for the standards committee to get an

Top      Up      ToC       Page 49 
   additional 256 possible values.

   As of this writing, there are several values of
   messageProcessingModel defined for use with SNMP.  They are as
   follows:
                        0  reserved for SNMPv1
                        1  reserved for SNMPv2c
                        2  reserved for SNMPv2u and SNMPv2*
                        3  reserved for SNMPv3

6.3.  SnmpEngineID Formats

   The SnmpEngineID TEXTUAL-CONVENTION's  fifth octet contains a format
   identifier.  The values managed by IANA are in the range 6 to 127,
   inclusive.  Each value uniquely identifies a standards-track
   SnmpEngineID format.

7.  Intellectual Property

   The IETF takes no position regarding the validity or scope of any
   intellectual property or other rights that might be claimed to
   pertain to the implementation or use of the technology described in
   this document or the extent to which any license under such rights
   might or might not be available; neither does it represent that it
   has made any effort to identify any such rights.  Information on the
   IETF's procedures with respect to rights in standards-track and
   standards-related documentation can be found in BCP-11.  Copies of
   claims of rights made available for publication and any assurances of
   licenses to be made available, or the result of an attempt made to
   obtain a general license or permission for the use of such
   proprietary rights by implementors or users of this specification can
   be obtained from the IETF Secretariat.

   The IETF invites any interested party to bring to its attention any
   copyrights, patents or patent applications, or other proprietary
   rights which may cover technology that may be required to practice
   this standard.  Please address the information to the IETF Executive
   Director.

8.  Acknowledgements

   This document is the result of the efforts of the SNMPv3 Working
   Group.  Some special thanks are in order to the following SNMPv3 WG
   members:

       Harald Tveit Alvestrand (Maxware)
       Dave Battle (SNMP Research, Inc.)
       Alan Beard (Disney Worldwide Services)

Top      Up      ToC       Page 50 
       Paul Berrevoets (SWI Systemware/Halcyon Inc.)
       Martin Bjorklund (Ericsson)
       Uri Blumenthal (IBM T.J. Watson Research Center)
       Jeff Case (SNMP Research, Inc.)
       John Curran (BBN)
       Mike Daniele (Compaq Computer Corporation)
       T. Max Devlin (Eltrax Systems)
       John Flick (Hewlett Packard)
       Rob Frye (MCI)
       Wes Hardaker (U.C.Davis, Information Technology - D.C.A.S.)
       David Harrington (Cabletron Systems Inc.)
       Lauren Heintz (BMC Software, Inc.)
       N.C. Hien (IBM T.J. Watson Research Center)
       Michael Kirkham (InterWorking Labs, Inc.)
       Dave Levi (SNMP Research, Inc.)
       Louis A Mamakos (UUNET Technologies Inc.)
       Joe Marzot (Nortel Networks)
       Paul Meyer (Secure Computing Corporation)
       Keith McCloghrie (Cisco Systems)
       Bob Moore (IBM)
       Russ Mundy (TIS Labs at Network Associates)
       Bob Natale (ACE*COMM Corporation)
       Mike O'Dell (UUNET Technologies Inc.)
       Dave Perkins (DeskTalk)
       Peter Polkinghorne (Brunel University)
       Randy Presuhn (BMC Software, Inc.)
       David Reeder (TIS Labs at Network Associates)
       David Reid (SNMP Research, Inc.)
       Aleksey Romanov (Quality Quorum)
       Shawn Routhier (Epilogue)
       Juergen Schoenwaelder (TU Braunschweig)
       Bob Stewart (Cisco Systems)
       Mike Thatcher (Independent Consultant)
       Bert Wijnen (IBM T.J. Watson Research Center)

   The document is based on recommendations of the IETF Security and
   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)

Top      Up      ToC       Page 51 
   As recommended by the Advisory Team and the SNMPv3 Working Group
   Charter, the design incorporates as much as practical from previous
   RFCs and drafts. As a result, special thanks are due to the authors
   of 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.  Security Considerations

   This document describes how an implementation can include a Security
   Model to protect management messages and an Access Control Model to
   control access to management information.

   The level of security provided is determined by the specific Security
   Model implementation(s) and the specific Access Control Model
   implementation(s) used.

   Applications have access to data which is not secured.  Applications
   SHOULD take reasonable steps to protect the data from disclosure.

   It is the responsibility of the purchaser of an implementation to
   ensure that:

      1) an implementation 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.

   This document also contains a MIB definition module.  None of the
   objects defined is writable, and the information they represent is
   not deemed to be particularly sensitive.  However, if they are deemed

Top      Up      ToC       Page 52 
   sensitive in a particular environment, access to them should be
   restricted through the use of appropriately configured Security and
   Access Control models.

10.  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,
                May 1990.

   [RFC1212]    Rose, M. and K. McCloghrie, "Concise MIB Definitions",
                STD 16, RFC 1212, March 1991.

   [RFC1901]    The SNMPv2 Working Group, Case, J., McCloghrie, K.,
                Rose, M.  and S. Waldbusser, "Introduction to
                Community-based SNMPv2", RFC 1901, January 1996.

   [RFC2578]    McCloghrie, K., Perkins, D. and J. Schoenwaelder,
                "Structure of Management Information Version 2 (SMIv2)",
                STD 58, RFC 2578, April 1999.

   [RFC2579]    McCloghrie, K., Perkins, D. and J. Schoenwaelder,,
                "Textual Conventions for SMIv2", STD 58, RFC 2579, April
                1999.

   [RFC2580]    McCloghrie, K., Perkins, D. and J. Schoenwaelder,
                "Conformance Statements for SMIv2", STD 58, RFC 2580,
                April 1999.

   [RFC1905]    The SNMPv2 Working Group, Case, J., McCloghrie, K.,
                Rose, M. and S. Waldbusser, "Protocol Operations for
                Version 2 of the Simple Network Management Protocol
                (SNMPv2)", RFC 1905, January 1996.

   [RFC1906]    The SNMPv2 Working Group, Case, J., McCloghrie, K.,
                Rose, M. and S. Waldbusser, "Transport Mappings for
                Version 2 of the Simple Network Management Protocol
                (SNMPv2)", RFC 1906, January 1996.

   [RFC1907]    The SNMPv2 Working Group, Case, J., McCloghrie, K.,
                Rose, M. and S. Waldbusser, "Management Information Base
                for Version 2 of the Simple Network Management Protocol
                (SNMPv2)", RFC 1907 January 1996.

Top      Up      ToC       Page 53 
   [RFC1908]    The SNMPv2 Working Group, Case, J., McCloghrie, K.,
                Rose, M. and S. Waldbusser, "Coexistence between Version
                1 and Version 2 of the SNMP-standard Network Management
                Framework", RFC 1908, January 1996.

   [RFC1909]    McCloghrie, K., Editor, "An Administrative
                Infrastructure for SNMPv2", RFC 1909, February 1996.

   [RFC1910]    Waters, G., Editor, "User-based Security Model for
                SNMPv2", RFC 1910, February 1996.

   [RFC2279]    Yergeau, F., "UTF-8, a transformation format of ISO
                10646", RFC 2279, January, 1998.

   [RFC2119]    Bradner, S., "Key words for use in RFCs to Indicate
                Requirement Levels", BCP 14, RFC 2119, March 1997.

   [BCP-11]     Hovey, R. and S. Bradner, "The Organizations Involved in
                the IETF Standards Process", BCP 11, RFC 2028, October
                1996.

   [RFC2233]    McCloghrie, K. and F. Kastenholz.  "The Interfaces Group
                MIB using SMIv2", RFC 2233, November 1997.

   [RFC2572]    Case, J., Harrington, D., Presuhn, R.  and B. Wijnen,
                "Message Processing and Dispatching for the Simple
                Network Management Protocol (SNMP)", RFC 2572, April
                1999.

   [RFC2574]    Blumenthal, U.  and B. Wijnen, "The User-Based Security
                Model for Version 3 of the Simple Network Management
                Protocol (SNMPv3)", RFC 2574, April 1999.

   [RFC2575]    Wijnen, B., Presuhn, R.  and K. McCloghrie, "View-based
                Access Control Model for the Simple Network Management
                Protocol (SNMP)", RFC 2575, April 1999.

   [RFC2573]    Levi, D. B., Meyer, P.  and B. Stewart, "SNMP
                Applications", RFC 2573, April 1999.

   [RFC2570]    Case, J., Mundy, R., Partain, D. and B. Stewart,
                "Introduction to Version 3 of the Internet-standard
                Network Management Framework", RFC 2570, April 1999.

   [SNMP-COEX]  Frye, R., Levi, D. and B. Wijnen, "Coexistence between
                Version 1, Version 2, and Version 3 of the Internet-
                standard Network Management Framework", Work in
                Progress.

Top      Up      ToC       Page 54 
11.  Editor's Addresses

   Bert Wijnen
   IBM T.J. Watson Research
   Schagen 33
   3461 GL Linschoten
   Netherlands

   Phone:      +31 348-432-794
   EMail:      wijnen@vnet.ibm.com


   Dave Harrington
   Cabletron Systems, Inc
   Post Office Box 5005
   Mail Stop: Durham
   35 Industrial Way
   Rochester, NH 03867-5005
   USA

   Phone:      +1 603-337-7357
   EMail:      dbh@ctron.com


   Randy Presuhn
   BMC Software, Inc.
   965 Stewart Drive
   Sunnyvale, CA 94086
   USA

   Phone:      +1 408-616-3100
   Fax:        +1 408-616-3101
   EMail:      randy_presuhn@bmc.com

Top      Up      ToC       Page 55 
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.

   SNMPv1 and SNMPv2c are two SNMP frameworks which use communities to
   provide trivial authentication and access control. SNMPv1 and SNMPv2c
   Frameworks can coexist with Frameworks designed according to this
   architecture, and modified versions of SNMPv1 and SNMPv2c Frameworks
   could be designed to meet the requirements of this architecture, but
   this document does not provide guidelines for that coexistence.

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

   Transfer of data between the subsystems is deliberately described as
   a fixed set of abstract data elements and primitive functions which
   can be overloaded to satisfy the needs of multiple model definitions.

   Documents 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 these 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 dependent on the model definition.

A.1.  Security Model Design Requirements

A.1.1.  Threats

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

Top      Up      ToC       Page 56 
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 securityLevel 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 protocols to be used
   concurrently within an implementation of the model. Each Security
   Model defines how to determine which protocol to use, given the
   securityLevel 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 protocols
   for authentication or privacy should have an identifier defined
   within the snmpAuthProtocols or the snmpPrivProtocols subtrees.
   Enterprise specific protocol identifiers should be defined within the
   enterprise subtree.

   For privacy, the Security Model defines what portion of the message
   is encrypted.

   The persistent data used for security should be SNMP-manageable, but
   the Security Model defines whether an instantiation of the MIB is a
   conformance requirement.

   Security Models are replaceable within the Security Subsystem.
   Multiple Security Model implementations may exist concurrently within
   an SNMP engine.  The number of Security Models defined by the SNMP
   community should remain small to promote interoperability.

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

   A Message Processing Model requests that a Security Model:
     - verifies that the message has not been altered,

Top      Up      ToC       Page 57 
     - authenticates the identification of the principal for whom the
       message was generated.
     - decrypts the message if it was encrypted.

   Additional requirements may be defined by the model, and additional
   services may be provided by the model, but the model is constrained
   to use the following primitives for transferring data between
   subsystems. Implementations are not so constrained.

   A Message Processing Model uses the processIncomingMsg primitive as
   described in section 4.4.2.

A.1.4.  Security MIBs

   Each Security Model defines the MIB module(s) required for security
   processing, including any MIB module(s) required for the security
   protocol(s) supported.  The MIB module(s) SHOULD be defined
   concurrently with the procedures which use the MIB module(s).  The
   MIB module(s) are subject to normal access control rules.

   The mapping between the model-dependent security ID and the
   securityName MUST be able to be determined using SNMP, if the model-
   dependent MIB is instantiated and if access control policy allows
   access.

A.1.5.  Cached Security Data

   For each message received, the Security Model caches the state
   information such that a Response message can be generated using the
   same security information, even if the Local Configuration Datastore
   is 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 Security Model to the Message Processing Model.

   The cached security data may be implicitly released via the
   generation of a response, or explicitly released by using the
   stateRelease primitive, as described in section 4.5.1.

A.2.  Message Processing Model Design Requirements

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

Top      Up      ToC       Page 58 
   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 a message from the network, the Dispatcher in the
   SNMP engine determines the version of the SNMP message and interacts
   with the corresponding Message Processing Model to determine the
   abstract data elements.

   A Message Processing Model specifies the SNMP Message format it
   supports and describes how to determine the values of the abstract
   data elements (like msgID, msgMaxSize, msgFlags,
   msgSecurityParameters, securityModel, securityLevel etc). A Message
   Processing Model interacts with a Security Model to provide security
   processing for the message using the processIncomingMsg primitive, as
   described in section 4.4.2.

A.2.2.  Sending an SNMP Message to the Network

   The Dispatcher in the SNMP engine interacts with a Message Processing
   Model to prepare an outgoing message. For that it uses the following
   primitives:

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

      -  for response messages:  prepareResponseMessage, as described in
         section 4.2.2.

   A Message Processing Model, when preparing an Outgoing SNMP Message,
   interacts with a Security Model to secure the message. For that it
   uses the following primitives:

      -  for requests and notifications:  generateRequestMsg, as
         described in section 4.4.1.

      -  for response messages:  generateResponseMsg as described in
         section 4.4.3.

      Once the SNMP message is prepared by a Message Processing Model,
      the Dispatcher sends the message to the desired address using the
      appropriate transport.

Top      Up      ToC       Page 59 
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, 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 the operation, and, if access control is needed,
   which Access Control Model should be used.

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

   Applications interact with the SNMP engine to initiate messages,
   receive responses, receive asynchronous messages, and send responses.


A.3.1.  Applications that Initiate Messages

   Applications may request that the SNMP engine send messages
   containing SNMP commands or notifications using the sendPdu primitive
   as described in section 4.1.1.

   If it is desired that a message be sent to multiple targets, it is
   the responsibility of the application to provide the iteration.

   The SNMP engine assumes necessary access control has been applied to
   the PDU, and provides no access control services.

   The SNMP engine looks at the "expectResponse" parameter, and if a
   response is expected, then the appropriate information is cached such
   that a later response can be associated to this message, and can then
   be returned to the application. A sendPduHandle is returned to the
   application so it can later correspond the response with this message
   as well.

A.3.2.  Applications that Receive Responses

   The SNMP engine matches the incoming response messages to outstanding
   messages sent by this SNMP engine, and forwards the response to the
   associated application using the processResponsePdu primitive, as
   described in section 4.1.4.

Top      Up      ToC       Page 60 
A.3.3.  Applications that Receive Asynchronous Messages

   When an SNMP engine receives a message that is not the response to a
   request from this SNMP engine, it must determine to which application
   the message should be given.

   An Application that wishes to receive asynchronous messages registers
   itself with the engine using the primitive registerContextEngineID as
   described in section 4.1.5.

   An Application that wishes to stop receiving asynchronous messages
   should unregister itself with the SNMP engine using the primitive
   unregisterContextEngineID as described in section 4.1.5.

   Only one registration per combination of PDU type and contextEngineID
   is permitted at the same time. Duplicate registrations are ignored.
   An errorIndication will be returned to the application that attempts
   to duplicate a registration.

   All asynchronously received messages containing a registered
   combination of PDU type and contextEngineID are sent to the
   application which registered to support that combination.

   The engine forwards the PDU to the registered application, using the
   processPdu primitive, as described in section 4.1.2.

A.3.4.  Applications that Send Responses

   Request operations require responses.  An application sends a
   response via the returnResponsePdu primitive, as described in section
   4.1.3.

   The contextEngineID, contextName, securityModel, securityName,
   securityLevel, and stateReference parameters are from the initial
   processPdu primitive. The PDU and statusInformation are the results
   of processing.

A.4.  Access Control Model Design Requirements

   An Access Control Model determines whether the specified securityName
   is allowed to perform the requested operation on a specified managed
   object. The Access Control Model specifies the rules by which access
   control is determined.

   The persistent data used for access control should be manageable
   using SNMP, but the Access Control Model defines whether an
   instantiation of the MIB is a conformance requirement.

Top      Up      ToC       Page 61 
   The Access Control Model must provide the primitive isAccessAllowed.

Top      Up      ToC       Page 62 
B.  Full Copyright Statement

   Copyright (C) The Internet Society (1999).  All Rights Reserved.

   This document and translations of it may be copied and furnished to
   others, and derivative works that comment on or otherwise explain it
   or assist in its implementation may be prepared, copied, published
   and distributed, in whole or in part, without restriction of any
   kind, provided that the above copyright notice and this paragraph are
   included on all such copies and derivative works.  However, this
   document itself may not be modified in any way, such as by removing
   the copyright notice or references to the Internet Society or other
   Internet organizations, except as needed for the purpose of
   developing Internet standards in which case the procedures for
   copyrights defined in the Internet Standards process must be
   followed, or as required to translate it into languages other than
   English.

   The limited permissions granted above are perpetual and will not be
   revoked by the Internet Society or its successors or assigns.

   This document and the information contained herein is provided on an
   "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING
   TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING
   BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION
   HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF
   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

Acknowledgement

   Funding for the RFC Editor function is currently provided by
   the Internet Society.