An Architecture for Describing
                      Internet Management Frameworks
                               D. Harrington
                           Cabletron Systems, Inc.
                              dbh@cabletron.com

                                B. Wijnen
                          IBM T.J. Watson Research
                             wijnen@vnet.ibm.com

                   <draft-ietf-snmpv3-next-gen-arch-02.txt>

                           Status of this Memo

This document is an Internet-Draft. Internet-Drafts are working
documents of the Internet Engineering Task Force (IETF), its areas,
and its working groups. Note that other groups may also distribute
working documents as Internet-Drafts.

Internet-Drafts are draft documents valid for a maximum of six months
and may be updated, replaced, or obsoleted by other documents at any
time. It is inappropriate to use Internet- Drafts as reference material
or to cite them other than as ``work in progress.''

To learn the current status of any Internet-Draft, please check the
``1id-abstracts.txt''stracts.txt'' listing contained in the 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
Management Frameworks. The architecture is designed to be modular
to allow the evolution of the protocol over time. The major portions
of the architecture are a messaging an SNMP engine containing a message
processing and control subsystem and a security Message Processing
subsystem, plus a
data processing engine, called a context engine, which contains Security Subsystem and an
access control subsystem, a MIB access subsystem, Access Control Subsystem, and
possibly multiple orangelets 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 1977 1997              [Page  1]

Harrington/Wijnen         Expires December 1977        [Page  2]
\

0. Issues

0.1. Issues to be resolved
  . Need the "readable" introduction supplement
 . taxonomy:
	orangelets
 . should the scopedPDU be contained in the securityParameters
    SEQUENCE, so encryption can include the PDU and some of the
    security parameters?
 . Who counts SNMP messages? who counts snmpv3 messages?
 . reportPDUs created from an error status or OID returned by the appropriate
	subsystem/model? or Integer for auth/priv protocol identifiers
    second interim meeting reached consensus on OIDs
    some mailing list members still say Integers preferred
  . foward refreences forward references need to be handled
  . some TCs were defined for interface parameters, but aren't part of a mIB.
	move to Glossary?
 . Is AdminString appropriate Glossary needed to describe primitive parameters, or is the
    expanded template adequate for all strings, such as securityidentifier and
	context and group? These had different sizes and semantics. this purpose?
  . AdminString has size (1..255); what about default context of ""? state_reference releases - are these consistently defined?
    check documents.
  . snmpEngineMaxMessageSize maximum size? 65507? what about non-UDP transports? discuss utf8. -  probably open WG discussion in Munich per NMAD
    discuss tomorrow; remains open issue.
  . description of max message size need mechanism to discover securityModels supported
  . definitioon/description of MD5/DES protocol OIDs. new SnmpEngineID format rules to be discussed yet.
  . should needs changes to meet STDGUIDE guidelines
  . add a "Decision History" section (as an appendix?)
  . 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 tree for registering protocols value!!

0.1.1. Issues discussed at second Interim Meeting:

 . A "readable" introduction supplement may be in basicGroup? done after Munich.
 . Applications are responsible for retries, but implementations may
     differ.
 . TCs should User-based not be defined just to describe primitive parameters.
   If they cannot be described adequately in text, they can be defined
   in basicgroup conformance? a Glossary. Avoid describing implementation details.
 . how does MPC match incoming requests with outgoing responses? 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
 . generateRequestMessage( globalData, scopedPDU, MIID, engineID )
	why do we need engineID? isn't that implicit? AdminString has size (0..255); revisit for utf8 discussions
 . I rearranged primitive parameters: transport/engine/contextEngine/PDU securityModel #s - 00 for IETF standards; from v2* documents
 . state_refernce releases protocol IDs - are these consistently defined? integer or OID? voted 13-0 for OID.
 . should the MPC release the state_reference when it receives a response? uniqueness of securityName
 . How mapping between principal and securityName is duplicate registration handled? error or ignore?

0.2.  Change Log

[version 3.1] outside scope of WG.
 . change securityIdentity to MIID principals may have more than one securityName in an entity
 . write text to explain the differences mappings may exist between security-identities,
   model-dependent identifiers, many types of MDID and model-independent identifiers. a single
   securityName
 . write text to explain distinction within mappings may exist between different    (model, Name) and the LCD of same
   securityName by varying the security
   data, model or the access control data, Name.
 . the securityName and a MDID may be identical. This can be defined
   by the oranglet data.
 . identify issues
 . publish as <draft-ietf-snmpv3-next-gen-arch-02.txt>

[version 3.0] Security Model.
   (user,"public") may map to securityName "public"
 . add section on threats for message security
 . add section on threats [securityName, securityModel] yields zero or one MDName, with
   exceptions for access control
 . change application to orangelet
 . remove references to F-Ts
 . change securityIdentity to security-identity
 . change securityCookie to securityIdentity
 . the format of securityIdentity backwards compatibility. The exception is defined
   by the model, and the problems are the province of the model
 . add securityModel to passed parameters as needed
   resolve.

Harrington/Wijnen         Expires  December 1977 1997              [Page  3]  2]
\

0.2.  Change Log

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

[version 4.3]
 . remove unused IMPORTS some minor editing adjustments

[version 4.2]
 . add glossary section with initial set modify abstract so there is no requirement for one entity
    to contain both a command generator and a notification receiver.
 . modify Introduction list of words entities which are meant to define be
   supported
 . differentiate the messageEngine from the contextEngine reorganized sections 1 through 4 for more consistency in contents.
 . eliminate described section contents in Introduction:Target Audience
 . move documentation descriptions to section 2
 . rewrite section 4 to be more like a real elements of procedure.
 . modified SnmpSecurityModel and SnmpEngineID definitions
 . replaced MIB with Bert's replacement
 . added Randy's TC for SnmpAdminString
 . modified the term SNMPng example algorithm text for SnmpEngineID
 . rewrote 1.1. A Note on Terminology security considerations for brevity.
 . eliminated assumptions about SNMP processing always being
    message related modified "context" description
 . rewrote 4.x moved "Threats" to reflect new thinking Goals/Requirements
 . rewrote 5.x eliminated snmpEngineMaxMessageSize object
 . posted to reflect new thinking snmpv3 (by DBH)

[version 4.1]
 . rewrote 6.x (the MIB) Adopt "abstract" to reflect new thinking terminology
 . added MIB objects at this level (previously only T-Cs) Addressed all comments I (BW) made to DBH in an earlier email
 . rewrote 7.x Changed Introduction section to new terminology
 . sent changed wording for "implementation" to v3edit list indicate it may contain
   multiple models.
 . Section 2. Started some wording on Goals and Design decisions
 . Added the overview picture of a traditional agent and a
   traditional manager. This is in section 2.
 . Changed overview figure in section 3. to address the comments
   by Dave Levi. It now lists the type of applications
 . At various places ensure that text (easily) fits within 72
   columns as required by RFC-editors Guidelines document.
 . Section 2.3 (new section) has the documents set overview.
   I verified the claims about standards. Not sure I worded the
   SNMPv2 std correctly,. We'll hear it if we did it wrong.
 . Section 2.4 (new section) gives overview of SNMP entities based
   on modified Dave Levi figure. I (Bert) wonder however if it would

Harrington/Wijnen         Expires  December 1977 1997              [Page  4]

1. Introduction

A management system contains: several (potentially many) nodes, each
with a processing entity, termed an agent, which has access  3]
\
   not be better to
management instrumentation; at least one management station; and, a
management protocol, used move it to convey management information between the
agents and management stations, or between management stations and
other management stations.

Management stations execute management applications which monitor and
control managed elements. Managed elements are devices after section 3.1.13
 . Section 3. Added more figures... please let us know if you find
   then useful and/or helpful. We could also move these back to
   section 2 if such as hosts,
routers, terminal servers, etc., which are monitored and controlled via makes more sense.
 . Added a picture in section 3.2.
   It also shows some of access control, so not sure it really fits
   here, although it does map principal to their management information.

Operations of the protocol are carried out under an administrative
framework which defines minimum requirements for standard services,
such as sending and receiving messages, countering model dependent security threats
   ID to
messages, controlling access securityName
 . Replace "<" with "is lower than" in section 3.4.3 which seems
   better in a text document.
 . Renamed section 4.1 to managed objects, and processing various
types "SNMP engine processing" instead of requests.

It is
   "The Message Processing Subsystem" because the purpose of this document to define an architecture which
can evolve to realize effective network management in a variety
of configurations and environments. The architecture has been
designed to meet the needs of implementors of minimal agents, command
line driven managers, mid-level managers, transport
   mappings, mpc multiplexor and full-function network
enterprise management stations.

1.1. A Note on Terminology

This architecture such is designed to allow an orderly evolution of
portions of SNMP Frameworks.

Throughout the rest of this document, done in ARCH document so
   it is done "in general in the term "subsystem" will
refer to an abstract engine" and incomplete specification of a portion of
a Framework, that will be further refined by a model specification.

A "model" describes it passes a specific design of
   message to a subsystem, defining
additional constraints Message Processing Subsystem.
 . "bulletized" some stuff in section 4.2 and rules for conformance to the model.
A model 4.3.
   Dave, this is sufficiently detailed to make just how I (Bert) like it possible better. Feel free to implement
the specification.

A "implementation" is an instantiation of
   undo it if you strongly disagree
 . Section 4.3 changed "initiate a subsystem, conforming transaction" to "originate a
specific model.

SNMP version 1 (SNMPv1), is
   notification".
 . Inserted title line for section 4.4 (I think it was missing)
   I have named it "Information Model" in accordance with the original Internet-standard Network
Management Framework, as described change
   I made (after Russ's comments) in RFCs 1155, 1157, the document figure to lump SMI,
   TC and 1212.

SNMP version 2 (SNMPv2) is an updated design of portions of SNMPv1,
as described Conformance together.
 . Inserted a title for section 4.5 named "Operational Model" to
   get in RFCs 1902-1908. SNMPv2 has an incomplete message
definition.

Harrington/Wijnen         Expires December 1977        [Page  5]

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

SNMP version 3 (SNMPv3) Framework is a particular configuration of
implemented subsystems, consistent with document overview
 . Renumber section 4.4.4 to 4,5,1 and added 4.5.2 to follow the architecture described
in this document.

Other SNMP Frameworks, i.e. other configurations of implemented
subsystems, are expected
   document overview figure. If we really want to follow it, then
   maybe we should also be consistent with this architecture.

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

2. Overview

The architecture presented here emphasizes the use reorder some of modularity these sections. Like
   Access Control seems specifically misplaced. So I decided to
allow move
   it before applications as section 4.3, so the evolution of portions of SNMP without requiring a redesign
of 4.x above should
   all be read as 4.x+1
 . Removed size from SnmpEngineID TC... why did you limit it to
   (0..2048). Did we not decide to leave it open?
 . Should we not remove snmpEngineMaxMessageSize from the general architecture MIB.
   That was agreed at 2nd interim. It travels in every message and so
   seems to be useless. However, I think it could indeed still help
   SNMPv1 or SNMPv2c managers.
 . I kept your definitions of SNMP.

SNMP processing must 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 performed done in consistently ordered steps, which
fall into general categories of similar functionality. This document
will describe major abstractions of functionality required during
SNMP processing, SEC document.
 . Modified Security Considerations. Was still talking about LPM.
 . Appendix. I am still wondering if we need to use capitals for
   things like "Security Model" "Subsystem" and the abstract interactions between these major
categories of functionality. such. This document will describe how this architecture is meant only
   an appendix... but we better be consistent, no? Anyway
   I changed it so it is consistent (at least I tried).
 . Appendix, renamed imf to allow
modules of functionality corresponding snmpFramework
 . Appendix, changed state_reference and state_release to these abstract categories
   stateReference and stateRelease to be designed to allow the evolution of the whole by modifying discrete
modules within the architecture. consistent with other names
   for abstract data and primitives.

Harrington/Wijnen         Expires  December 1977 1997              [Page  6]

3. An Evolutionary Architecture - Design Goals

The goals of the architectural design are  4]
\
 . A.2 changed MessageEngine to use encapsulation,
cohesion, hierarchical rules, and loose coupling SNMP engine
 . Fixed ASI primitives to reduce complexity
of design and make the evolution of portions of the architecture
possible.

3.1. Encapsulation

Encapsulation describes the practice of hiding the details be in sync with SEC document.
   I also thought that are
used internal our ARCH document-outline wanted to a process. Some data is required for a given
procedure, but isn't needed by any other part of at least
   have the process.

In networking, primitives listed within the concept main body of a layered stack reflects this approach.
The transport layer contains data specific to its processing; the data
is not visible text, no?
 . Adapted send_pdu to the other layers. In programming this is reflected
in language elements such sendPdu primitive as "file static" variables in C, and
"private" in C++, etc. reconciled by Randy
   In this architecture, fact I made sure all data used for processing only within
a functional portion of the architecture should have its visibility
restricted to that portion if possible. The data should be accessed
only by that functionality defined primitives are in-line with the data. No reference to the
data should be made from outside the functional portion current
   agreement on names and parameters.
 . Rename title of the
architecture, except through predefined public interfaces.

3.2. Cohesion

Similar functions can be grouped together A.2.4 and their differences
ignored, A.2.5 so they can be dealt with as a single entity. It it fits on 1 line in contents
 . I did not look at appendix B. That is important
that the functions which are grouped together are actually similar.
Similarity of the data used your (DBH) specialty is it
   not ?  ;-).
 . Quick simple spell check done with "spell" on AIX

[version 4.0]
 . move section 7 - Model Requirements to perform functions can be a good
indicator of the similarity an appendix
 . move Section 3 - Design Goals to an appendix
 . modified Section 5 - Naming
 . remove "possibly multiple"
 . moved Section 5 to Section 3
 . change orangelets to applications
 . modify description of the functions.

For example, authentication applications
 . change scopedPDU-MMS and encryption are both security functions
which are applied PDU-MMS to a message. Access control, while similar in some
ways, is dissimilar in that it is not applied maxSizeResponseScopedPDU
 . change Scoped-PDU and ScopedPDU to a message, it is
applied scopedPDU (no dash, lower case S)
 . change imfxxx to a (proposed) request for a management operation.
The data required snmpFrameworkxxx
 . change security-entity to perform authentication 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 encryption are
different than Control to Message Processing
 . changed future tense to present tense
 . eliminate messageEngine
 . added/updated primitives
 . addressed issues raised on the data needed mailing list

[version 3.1]
 . change securityIdentity to perform access control, MIID
 . write text to explain the differences between security-identities,
   model-dependent identifiers, and model-independent identifiers.
 . write text to explain distinction within the
two sets LCD of services can be described independently.

Similar functions, especially those that use the same data elements,
should be defined together. The security functions which operate at
   data, the message level should be defined in a document together with access control data, and the
definitions for those data elements that are used only by those
security functions. For example, a MIB with authentication keys is
used only by authentication functions; they should be defined together. 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 orangelet
 . remove references to F-Ts
 . change securityIdentity to security-identity

Harrington/Wijnen         Expires  December 1977 1997              [Page  7]

3.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  5]
\
 . change securityCookie to each of its direct subordinates.

This architecture uses securityIdentity
 . the hierarchical approach format of securityIdentity is defined by defining
subsystems, which specify the general rules of a portion model
 . add securityModel to passed parameters as needed
 . eliminate group from passed parameters
 . remove unused IMPORTS
 . add glossary section with initial set of the system,
models which words to define
 . differentiate the specific rules messageEngine from the contextEngine
 . eliminate the term SNMPng
 . rewrote 1.1. A Note on Terminology
 . eliminated assumptions about SNMP processing always being
    message related
 . rewrote 4.x to be followed by an
implementation reflect new thinking
 . rewrote 5.x to reflect new thinking
 . rewrote 6.x (the MIB) to reflect new thinking
 . 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 the portion technical understanding of the system, SNMP.

This document does not provide a general introduction to SNMP. Other
documents and implementations which
encode those rules into reality for books can provide a portion of the system.

It is expected that within portions of the system, hierarchical
relationships will be used much better introduction to compartmentalize, or modularize, the
implementation of specific functionality. For example, it is expected
that within the security portion SNMP.
Nor does this document provide a history of the system, authentication and
privacy will probably SNMP. That also can be contained
found in separate modules, and that
multiple authentication books and privacy mechanisms will be supported by
allowing supplemental modules that provide protocol-specific
authentication other documents.

This document does define a vocabulary for describing Internet
Management Frameworks, and privacy services.

3.4. Coupling

Coupling describes an architecture for describing the amount
major portions of interdependence between parts Internet Management Frameworks.

Section 1 describes the purpose, goals, and design decisions of
a system. Loose coupling indicates that two sub-systems are relatively
independent
the architecture.

Section 2 describes various types of each other; tight coupling indicates documents which define Internet
Frameworks, and how they fit into this architecture. It also provides
a high degree of
mutual dependence.

To make it possible minimal roadmap to evolve the architecture by replacing only part
of documents which have defined previous
SNMP frameworks.

Section 3 details the system, or by supplementing existing portions with alternate
mechanisms vocabulary of this architecture and its pieces.
This section is important for similar functionality, without obsoleting understanding the complete
system, it is necessary remaining sections,
and for understanding documents which are written to limit fit within this
architecture.

Section 4 describes the coupling elements of the parts.

Encapsulation and cohesion help to reduce coupling procedure followed by limiting an SNMP
engine in coordinating the
visibility processing of those parts that are only needed within portions of a
system. Another mechanism is to constrain the nature of interactions
between various parts messages by the subsystems
of the system.

This can be done engine and by defining fixed, generic, flexible interfaces
for transferring data between the parts of the system. The concept of
plug-and-play hardware components is based on that type applications.

Section 5 defines a collection of interface
between the hardware component managed objects used to instrument
SNMP engines within this architecture.

Sections 6, 7, 8, and system into which it will be
"plugged."

This approach has been chosen so individual portions 9 are administrative in nature.

Appendix A contains guidelines for developers of the system
can be upgraded over time, while keeping the overall system intact.

To avoid specifying fixed interfaces, Models which would constrain are
expected to fit within this architecture.

Appendix B contains a vendor's
choice discussion of implementation strategies, software design principles which
guided the development of this architecture. Many books provide a set
more in-depth discussion of abstract data elements
is used for (conceptually) transferring data between subsystems in
documents these topics.

1.2. Management Systems

  A management system contains:
    - several (potentially many) nodes, each with an SNMP entity
      containing command responder and notification originator
      applications, which describe subsystem or model interactions. Documents have access to management instrumentation;

Harrington/Wijnen         Expires  December 1977 1997              [Page  8]

describing the interaction of subsystems or models should use only  7]
\
    - at least one SNMP entity containing command generator and/or
      notification receiver applications; and,
    - a management protocol, used to convey management information
      between the abstract data SNMP entities.

  SNMP entities executing command generator and notification receiver
  applications monitor and control managed elements.  Managed elements provided for transferring data but vendors
  are not constrained devices such as hosts, routers, terminal servers, etc., which
  are monitored and controlled via access to using the described data elements for
transferring data between portions of their implementation.

Loose coupling works well with management
  information.

  Operations of the IETF standards process. If we
separate message-handling from protocol are carried out under an administrative
  framework which defines minimum requirements for standard services,
  such as sending and receiving messages, countering security threats
  to messages, controlling access to managed objects, and from local processing,
then the separate portions processing
  various types of requests.

  It is the system purpose of this document to define an architecture which
  can move through the standards
process with less dependence on the status evolve to realize effective network management in a variety
  of configurations and environments. The architecture has been
  designed to meet the needs of implementations of:
    - minimal SNMP entities with command responder and/or notification
      originator applications (traditionally called SNMP agents),
    - SNMP entities with proxy forwarder applications (traditionally
      called SNMP proxy 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 portions types of the
standard. Security models may be able to be re-opened applications for discussion
due to patents, new research, export laws, etc., as is clearly expected managing
      a potentially very large number of managed nodes (traditionally
      called network enterprise management stations).

1.3. Goals of this Architecture

This architecture was driven by the WG, without needing to reopen following goals:

   - Use existing materials as much as possible.
     It is heavily based on previous work, informally
     known as SNMPv2u and SNMPv2*.
   - Address the documents need for secure SET support, which detail the
message format or is considered
     the local processing most important deficiency in SNMPv1 and SNMPv2c.
   - Make it possible to move portions of PDUs. Thus, the architecture forward
     in the standards
track status of related, but independent, documents is track, even if consensus has not affected. been reached
     on all pieces.
   - Define an architecture that allows for longevity of the SNMP
     Frameworks that have been and will be defined.

Harrington/Wijnen         Expires  December 1977 1997              [Page  9]

4. Abstract Functionality

DBH: {ref: Get-Request, PDU, authentication, encryption, timeliness,
managed objects, proxy, }

The architecture described here contains four subsystems, each
capable of being defined  8]
\
   - Keep SNMP as one or more different models which may
be replaced or supplemented simple as the growing needs possible.
   - Make it relatively inexpensive to deploy a minimal conformant
     implementation
   - Make it possible to upgrade portions of network management
require. The subsystems are a Message Processing and Control
subsystem, framework as new
     approaches become available, without disrupting the entire
     framework.
   - Make it possible to support features required in large networks,
     but make the expense of supporting a feature directly related
     to the support of the feature.

1.4. Security subsystem, an Orangelet subsystem, and an
Access Control subsystem.

The subsystems Requirements of this Architecture

Several of the classical threats to network protocols are contained in two "engines".

A messageEngine deals with SNMP messages, and is responsible for
sending and receiving messages, including having authentication
and encryption services applied applicable
to the messages, network management problem and determining therefore would be applicable
to any Security Model used in an Internet Management Framework. Other
threats are not applicable to which Orangelet the message contents should be delivered.

A contextEngine deals with processing network management operations,
and contains subsystems for Access Control, MIB access, problem.  This
section discusses principal threats, secondary threats, and
Orangelets threats
which are of lesser importance.

The principal threats against which any Security Model used within
this architecture SHOULD provide specific functional processing.
Depending on protection are:

Modification of Information
    The modification threat is the network management service needed, an Orangelet danger that some unauthorized SNMP
    entity may use the access control and MIB access subsystems, and may use alter in-transit SNMP messages generated on behalf of
    an authorized principal in such a way as to communicate with remote nodes. effect unauthorized
    management operations, including falsifying the value of an object.

Masquerade
    The network masquerade threat is the danger that management service operations
    not authorized for some principal may be requested via attempted by assuming
    the payload identity of an another principal that has the appropriate
    authorizations.

Message Stream Modification
    The SNMP
message, or may be requested via protocol is typically based upon a local process.

4.1. The messageEngine connectionless
    transport service which may operate over any subnetwork service.
    The messageEngine interacts with the network using SNMP messages, re-ordering, delay or replay of messages can and with does occur
    through the natural operation of many such subnetwork services.
    The message processing subsystem and stream modification threat is the security subsystem
and with orangelets using service interfaces defined within this
architecture.

4.1.1. Transport Mappings

SNMP danger that messages are sent to,
    may be maliciously re-ordered, delayed or received from, the network using
transport addresses. It replayed to an extent
    which is greater than can occur through the responsibility natural operation of the messageEngine
    a subnetwork service, in order to listen at effect unauthorized management
    operations.

Disclosure
    The disclosure threat is the appropriate local addresses, and to send messages
through danger of eavesdropping on the appropriate addresses, consistent with mappings defined
by
    exchanges between SNMP Transport Mapping documents, such engines.  Protecting against this threat
    may be required as RFC1906.

4.1.2. SNMP-Based Message Formats

SNMP messages sent to, or received from, the network use a format
defined matter of local policy.

Harrington/Wijnen         Expires  December 1997              [Page  9]
\

There are at least two threats against which a Security Model used by
a version-specific Message Processing and Control model.
The messageEngine determines to which version-specific model the
message should be given.

The version-specific model interacts with the security subsystem,

using a service interface defined by framework within this architecture, to procure
security services architecture need not protect.

Denial of Service
    A Security Model need not attempt to meet address the requirements broad range of the version-specific
protocol.

4.1.3. The Interface to Orangelets

A messageEngine, as a result
    attacks by which service on behalf of authorized users is denied.
    Indeed, such denial-of-service attacks are in many cases
    indistinguishable from the receipt type of an SNMP message, may
initiate a transaction network failures with an Orangelet, such which any
    viable network management protocol must cope as for an incoming
request, or an Orangelet a matter of course.

Traffic Analysis
    A Security Model need not attempt to address traffic analysis
    attacks.  Many traffic patterns are predictable - entities may initiate
    be managed on a transaction with regular basis by a
messageEngine, such as for an outgoing request. The messageEngine
determines to relatively small number of
    management stations - and therefore there is no significant
    advantage afforded by protecting against traffic analysis.

1.5. Design Decisions

Various designs decision were made in support of these goals:

   - Architecture
     An architecture should be defined which orangelet identifies the
     conceptual boundaries between the documents of a message framework.
     Subsystems should be given.

4.1.4.  Protocol Instrumentation

To monitor and manage an SNMP engine, a Management Information Base
for SNMP defines defined which describe the collection abstract
     services provided by specific portions of managed objects which instrument the SNMP protocol itself. The messageEngine has framework.
     Abstract service interfaces, as described by service primitives,
     define the responsibility
for maintaining abstract boundaries between documents, and the instrumentation
     abstract services that is described are provided by the
SNMPv2 MIB module [RFC1907] plus conceptual
     subsystems of a framework.

   - Self-contained Documents
     Elements of procedure plus the instrumentation MIB objects which is
described by the IMFMIB module are needed for
     processing for a specific portion of a framework should be
     defined in this document.

A Message Processing the same document, and Control model may require support for
MIB modules related to instrumenting version-specific aspects as much as possible, should
     not be referenced in other documents. This allows various
     pieces of the SNMP protocol.

4.2. Security

Some environments require secure protocol interactions. Security Frameworks to be designed and documented as
     independent and self-contained parts, which is
normally applied at two different stages - in consistent with
     the transmission/receipt general SNMP MIB module approach. As portions of messages, and in SNMP change
     over time, the processing documents describing other portions of the contents
     framework are not directly impacted. This modularity allows,
     for example, Security Models, authentication and privacy
     mechanisms, and message formats to be upgraded and supplemented
     as the need arises. The self-contained documents can move
     along the standards track on different time-lines.

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

\
     environment, these SNMP parameters must be able to message-level security;
"access control" refers be remotely
     configured.

   - Controlled Complexity
     It is recognized that simple managed devices want to keep the security applied
     resources used by SNMP to protocol operations.

Authentication, encryption, a minimum.  At the same time, there
     is a need for more complex configurations which can spend more
     resources for SNMP and timeliness checking are common
functions of message level security.

4.3. Orangelets

Orangelets coordinate thus provide more functionality.
     The design tries to keep the processing of management information
operations.

This document describes three common types competing requirements of orangelets
and how they interact within the architecture - 1) an orangelet
may process requests to perform an operation on managed objects,
2) an orangelet may initiate a transaction as the result of a
local event, and 3) an orangelet may act as an intermediary,
forwarding an operation to another network management entity.

Orangelets provide access to MIB information, these
     two environments in balance and coordinate allows the application of access control more complex
     environments to management operations.

A discussion of logically extend the simple environment.

\

2.  Documentation Overview

The following figure shows the management information and processing is
provided here, but an Orangelet model defines which set of documents are used to specifically define that fit within the structure of management
information, textual conventions, conformance requirements,
SNMP Architecture.
                             Document Set
 +--------------------------------------------------------------------+
 |                                                                    |
 | +------------+             +-----------------+  +----------------+ |
 | |          * |             |               * |  |              * | |
 | | Document   |             | Applicability   |  | Coexistence    | |
 | | Roadmap    |             | Statement       |  | & Transition   | |
 | +------------+             +-----------------+  +----------------+ |
 |                                                                    |
 | +-------------------+  +-----------------------------------------+ |
 | | Operational Model |  | Security and
operations supported by the Orangelet.

4.4.1. Administration             | |
 | |                   |  |                                         | |
 | | +-------------+   |  | +------------+ +----------+ +---------+ | |
 | | |             |   |  | |            | |          | |         | | |
 | | | Protocol    |   |  | | Message    | | Security | | Access  | | |
 | | | Operations  |   |  | | Processing | |          | | Control | | |
 | | +-------------+   |  | +------------+ +----------+ +---------+ | |
 | | +-------------+   |  |                                         | |
 | | |             |   |  | +--------------+           +----------+ | |
 | | | Transport   |   |  | |              |           |          | | |
 | | | Mappings    |   |  | | Applications | ......... |          | | |
 | | +-------------+   |  | +--------------+           +----------+ | |
 | |                   |  |                                         | |
 | +-------------------+  +-----------------------------------------+ |
 |                                                                    |
 | +----------------------------------------------------------------+ |
 | | Information Model                                              | |
 | |                                                                | |
 | | +--------------+    +--------------+    +---------------+      | |
 | | | Structure of |    | Textual      |    | Conformance   |      | |
 | | | Management   |    | Conventions  |    | Statements    |      | |
 | | | Information

Management information is viewed as a collection of managed objects,
residing  |    |              |    |               |      | |
 | | +--------------+    +--------------+    +---------------+      | |
 | +----------------------------------------------------------------+ |
 |                                                                    |
 | +----------------------------------------------------------------+ |
 | | 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 a virtual information store, termed the Management
Information Base (MIB).  Collections
future.	Each of related objects are defined these documents may be replaced or supplemented.
This Architecture document specifically describes how new documents
fit into the set of documents in MIB modules.

It is the purpose Security and Administration area.

2.1. Document Roadmap

One or more documents may be written that will describe how sets
of documents taken together form a Structure specific SNMP framework.
The configuration of Management Information document to establish sets might change over time, so the syntax for defining objects, modules, and
other elements of managed information.

An Orangelet model defines which SMI
"roadmap" should be maintained in a document separate from the
standards documents are supported themselves.

2.2. Applicability Statement

SNMP is used in networks that vary widely in size and complexity,
by the model.

4.4.2.  Textual Conventions

When designing a MIB module, it is often useful to define new types
similar to those defined organizations that vary widely in the SMI, but with more precise semantics, their requirements of network
management.    Some models will be designed to address specific
problems of network management, such as message security.

One or which have special semantics associated with them. These newly
defined types are termed textual conventions.

An Orangelet model defines which Textual Conventions more documents
are supported by the model.

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

An Orangelet model defines written which Conformance Statement documents
are supported by the model.

4.4.4.  Protocol Operations

SNMP messages encapsulate a Protocol Data Unit (PDU). It is the
purpose of a Protocol Operations document to define the operations
of describe the protocol with respect environments
to the processing of the PDUs.

An Orangelet model defines which Protocol Operations documents
are supported by the model.

4.5. Access Control

During processing, it may be required to control access to certain
instrumentation for certain operations. The determination versions of
access rights requires the means SNMP or models within SNMP would be
appropriately applied, and those to identify the access allowed for
the security-identity on whose behalf which a request is generated.

An Access Control given model provides an advisory service for an
Orangelet. The determination of whether to check access control
policy is the responsibility of the Orangelet model. The mechanism
by which access control is checked is defined by the Access Control
model.

4.6. 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 a Coexistence document 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.

5. Abstract Data Elements of

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 Architecture

This section contains definitions purpose of abstract data elements used
Transport Mapping documents to
transfer data define how the mapping between subsystems.

5.1. engineID

Each SNMP engine, consisting of potentially many subsystems, must be
able to be uniquely identified. The mechanism by which this can be
done is defined in
and the IMFMIB module, described in this document,
since it transport is desirable that engine identification span all frameworks.

5.2. SecurityIdentity done. A generic term for specific implementation of an uniquely-identifiable entity on whose behalf SNMP engine
defines which transports it supports.

2.5. Message Processing

A Message Processing Model document defines a message can be generated. Each security subsystem may define a
model-specific mechanism for entity identification, such as a
community [RFC1157] or user [RFC1910] or party-pair [RFC1445].
This model-specific identifier format, which is not guaranteed to be represented
in a character set readable
typically identified by humans.

5.3. Model Independent Identifier (MIID)

Each security model must also provide a mapping from the model
specific identification to an SnmpAdminString representation,
called the MIID, which, version field in combination with the securityModel,
can be used by all other subsystems within an engine to identify
a security identity, regardless of the security mechanisms used to
provide security services. SNMP message header.
The combination of engineID and securityModel and MIID provides document may also define a
globally-unique identifier MIB module for an entity on whose behalf a use in message
can be generated.

5.4. Level
processing and for instrumentation of Security

Messages version-specific interactions.

An engine will include one or more Message Processing Models, and thus
may support sending and receiving multiple SNMP versions of
messages.

2.6. Security

Some environments require secure protocol interactions.  Security is
normally applied at two different levels of security. The acronym LoS is
used to refer to stages:

  - in the level of security.

This architecture recognizes three levels transmission/receipt of security:
    - without authentication messages, and without privacy (noAuth/noPriv)
    - with authentication but without privacy (auth/noPriv)
  - with authentication and with privacy (auth/Priv)

Every message has an associated LoS; all subsystems (security, access
control, orangelets, message 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 control) timeliness checking are required
to abide common
functions of message level security.

A security document will describe a Security Model, the specified LoS while processing threats
against which the message model protects, the goals of the Security Model,
the protocols which it uses to meet those goals, and its
contents.

5.5. Contexts

An SNMP context is it may define
a collection of management information
accessible by an SNMP engine. An item MIB module to describe the data used during processing, and to allow
the remote configuration of management information
may exist in more than one context. message-level security parameters,
such as passwords.

An SNMP engine potentially
has may support multiple Security Models concurrently.

2.7. Access Control

During processing, it may be required to control access to many contexts.

5.6. ContextName certain
instrumentation for certain operations. An octet string 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 name

\

determine whether access to a context. Each context must managed object should be uniquely
named within an engine.

5.7. ContextEngineID

A contextEngineID uniquely identifies an engine that allowed,
and may realize
an instance of define a named context.

5.8. Naming Scope

The combination of a contextEngineID and a contextName uniquely
identifies a context within an administrative domain, and is called
a naming scope.

5.9. Scoped-PDU

A scopedPDU contains a Naming-Scope MIB module used during processing, and a PDU.

The Naming Scope unambiguously identifies, within the administrative
domain, the context to which allow
the remote configuration of access control policies.

2.8. Applications

An SNMP management information in
the PDU refers.

The PDU format is defined by an Orangelet model, or entity normally includes a document
referenced by an Orangelet model, which processes the PDU contents.

5.10. PDU-MMS

the maximum size number of a scopedPDU to be included in a response message,
given applications.
Applications use the amount services of reserved space in the message for the anticipated
security parameters.

5.11. Local Configuration Datastore

The subsystems and models in an SNMP engine may need to retain their
own, possibly multiple, sets of information to perform their
processing. To allow these sets accomplish
specific tasks. They coordinate the processing of management
information to be remotely
configured, portions operations, and may need use SNMP messages to be accessible as managed objects.

The collection of these possibly multiple sets communicate
with other SNMP entities.

Applications documents describe the purpose of information is
referred to collectively as an engine's Local Configuration Datastore
(LCD).

5.11.1. Security Portion of application, the Local Configuration Datastore

Each Security model may need to retain its own set
services required of information about
security entities, mechanisms, the associated SNMP engine, and policies.

5.11.2. Orangelet Portion of the Local Configuration Datastore

Each Orangelet protocol
operations and informational model may need that the application uses to retain its own
perform network management operations.

An application document defines which set of information
about contexts, naming scopes, and other configuration data.

5.11.3. Access Control Portion documents are used to
specifically define the structure of management information, textual
conventions, conformance requirements, and operations supported by
the Local Configuration Datastore

Each Access Control model may need to retain its own set application.

2.9. Structure of Management Information

Management information about access control policies, and the MIIDs
to which the policies apply.

5.12. Groups

A Group identifies is viewed as a set collection of zero or more MIIDs on whose
behalf SNMP managed objects,
residing in a virtual information store, termed the Management
Information Base (MIB).  Collections of related objects are being processed, subject to access
control policies common to all members of defined
in MIB modules.

It is the group.

6. Definition purpose of a Structure of Managed Objects for Internet Management Frameworks

IMF-MIB DEFINITIONS ::= BEGIN

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

imfMIB MODULE-IDENTITY
    LAST-UPDATED "9706160000Z"     -- 16 June 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
                  email:      mundy@tis.com
                  phone:      301-854-6889

                  Co-editor   Dave Harrington
                              Cabletron Systems, Inc
                  postal:     Post Office Box 5005
                              MailStop: Durham
                              35 Industrial Way
                              Rochester NH 03867-5005
                  email:      dbh@cabletron.com
                  phone:      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-412-498

                 "
    DESCRIPTION  "The Internet Management Architecture MIB"
    ::= { snmpModules 99 }

-- document
to establish the syntax for defining objects, modules, and other
elements of managed information.

2.10. Textual Conventions used

When designing a MIB module, it is often useful to define new types
similar to those defined in the Internet Management Architecture ***

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

                 The value for this object may not be all zeros SMI, but with more precise semantics,
or
                 all 'ff'H.

                 The initial value for this object which have special semantics associated with them.  These newly
defined types are termed textual conventions, and may be configured
                 via an operator console entry defined in
separate documents, or via an algorithmic
                 function. In within a MIB module.

2.11. Conformance Statements

It may be useful to define the later case, acceptable lower-bounds of
implementation, along with the following
                 guidelines are recommended:

                  1) The first four octets are set to actual level of implementation
achieved.  It is the binary
                     equivalent purpose of Conformance Statements to define
the agent's notation used for these purposes.

\

2.12. Protocol Operations

SNMP network management
                     private enterprise number as assigned by messages encapsulate an SNMP Protocol Data Unit (PDU). It is the
                     Internet Assigned Numbers Authority (IANA).
                     For example, if Acme Networks has been assigned
                     { enterprises 696 },
purpose of a Protocol Operations document to define the first four octets would
                     be assigned '000002b8'H.

                  2) The remaining eight octets are operations
of the cookie whose
                     contents are determined via one or more
                     enterprise specific methods. Such methods must
                     be designed so as protocol with respect to maximize the possibility
                     that the value processing of this object will be unique in the agent's administrative domain. For example, 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 cookie SNMP protocol itself. In addition, MIB modules may be
defined within the IP address documents which describe portions of the agent,
                     or SNMP
architecture, such as the MAC address of one of documents for Message processing Models,
Security Models, etc. for the interfaces,
                     with each address suitably padded with random
                     octets. If multiple methods are defined, then
                     it purpose of instrumenting those
Models, and for the purpose of allowing remote configuration of
the Model.

2.14. SNMP Framework Documents

This architecture is recommended that designed to allow an orderly evolution of
portions of SNMP Frameworks.

Throughout the cookie be further
                     divided into one octet that indicates rest of this document, the
                     method being used term "subsystem" refers
to an abstract and seven octets which are incomplete specification of a function portion of the method.
                "
    SYNTAX       OCTET STRING (SIZE (12))

SnmpSecurityModel ::= TEXTUAL-CONVENTION
    STATUS       current
    DESCRIPTION "An identifier
a Framework, that uniquely identifies is further refined by a model specification.

A "model" describes a specific design of
                 security subsystem within the Internet
                 Management Architecture.
                "
    SYNTAX       INTEGER(0..2147483647)

-- BW a subsystem, defining
additional constraints and rules for conformance to DBH: why do we need the following TC? It is never used in a MIB
-- model.
A model is it?
-- DBH sufficiently detailed to BW: I defined this only because make it was used in an architectural
--		  interface, and felt that the architecture should define possible to implement
the
--		  limits specification.

An "implementation" is an instantiation of the syntax, and provide a common description.
--
-- SnmpSecurityStateReference ::= TEXTUAL-CONVENTION
--  STATUS       current
--  DESCRIPTION "An implementation-defined reference subsystem, conforming
to one or more specific models.

SNMP version 1 (SNMPv1), is the retained
--               security information required to send a response.

--               The security model defines what information must be
--               retained for use original Internet-standard Network
Management Framework, as described in sending the response.
--              "
--  SYNTAX      OCTET STRING

SnmpLoS ::= TEXTUAL-CONVENTION
    STATUS       current
    DESCRIPTION "A level of security at which SNMP messages can be
                 sent; in particular, one of:
                   noAuth - without authentication and without privacy,
                   auth   - with authentication but without privacy,
                   priv   - with authentication RFCs 1155, 1157, and with privacy.
                "
    SYNTAX       INTEGER { noAuth(1), auth(2), priv(3) }

SnmpAdminString ::= TEXTUAL-CONVENTION
    STATUS        current
    DESCRIPTION  "An octet string containing an 1212.

SNMP administrative
                  string.  Preferably this a a human readable string.
                  We're still thinking if this could use the UTF8
                  character set.
                 "
    SYNTAX        OCTET STRING (SIZE(1..255))

-- BW to DBH: I think these are no longer needed. They now use the
--            SnmpV3AdminString TC.
-- DBH to BW: so now all securityidentities, Gropups, and Contxets
--            can be up to 255 bytes long, and MUST always be at least
--            one byte version 2 (SNMPv2) is an updated design of portions of SNMPv1,
as described in length? What RFCs 1902-1908.  SNMPv2 has an incomplete message
definition.

Community-based SNMP version 2 (SNMPv2c) is our new default context?
--
-- SnmpSecurityIdentity ::= TEXTUAL-CONVENTION
--  STATUS        current
--  DESCRIPTION  "A octet string an experimental Framework
which contains data in a supplements the incomplete message format
--                defined by a security model which identifies a
--                unique identity for which messages may be generated.
--                The securityIdentity must be unique across all
--                securityModels supported by of SNMPv2 with
portions of the engine.
--               "
--  SYNTAX       DisplayString (SIZE (0..32))
--
-- SnmpGroupName ::= TEXTUAL-CONVENTION
--  STATUS        current
--  DESCRIPTION  "An octet string which identifies message format of SNMPv1, as described in RFC1901.

\

SNMP version 3 (SNMPv3) Framework is a set particular configuration of zero or
--                more security entities on whose behalf
implemented subsystems, consistent with the architecture described
in this document.

Other SNMP managed
--                objects Frameworks, i.e. other configurations of implemented
subsystems, are being processed, subject expected to access
--                control policies common to all members of the group.
--               "
--  SYNTAX        OCTET STRING (SIZE(1..16))
--
--SnmpContextName ::= TEXTUAL-CONVENTION
--  STATUS        current

--  DESCRIPTION  "A name also be consistent with this architecture.

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

\

3. Naming

This architecture deals with three kinds of
--                management information realized by an SNMP engine.
--               "
--  SYNTAX       OCTET STRING (SIZE (0..32))
--
--
-- The IMF Engine Group
--

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

imfAdmin           OBJECT IDENTIFIER ::= { imfMIB 1 }
imfMIBObjects      OBJECT IDENTIFIER ::= { imfMIB 2 }
imfMIBConformance  OBJECT IDENTIFIER ::= { imfMIB 3 }

-- naming:

  1) the imfEngine group ***********************************************

imfEngine OBJECT IDENTIFIER ::= { imfMIBObjects 1 }

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

snmpEngineBoots  OBJECT-TYPE
    SYNTAX       Unsigned32 -- (1..4294967295)
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION "The number naming of times that entities,
  2) the engine has re-initialized
                 itself since its initial configuration.
                "
    ::= { imfEngine 2 }

snmpEngineTime   OBJECT-TYPE
    SYNTAX       Integer32 (0..2147483647)
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION "The number naming of seconds since the engine last
                 incremented the snmpEngineBoots object.
                "
    ::= { imfEngine 3 }

snmpEngineMaxMessageSize OBJECT-TYPE
--  SYNTAX       Integer32 (484..2147483647)
-- From BW to DBH: why did you use that large range? The 65507 is identities, and
  3) the
--                 max naming of management information.

This architecture also defines some names for other constructs that fits
are used in a UDP datagram. I thought we
--                 reached consensus on that on the mailinglist.
-- DBH to BW:      did we? I thought there were arguments that we should

--                 not work with the limits documentation.

3.1. The Naming of UDP, since other transports
--                 are now officially supported. If I write Entities

The following picture shows detail about an SNMP entity and how
components within it are named.

 +--------------------------------------------------------------------+
 |                                                                    |
 |  SNMP entity                                                       |
 |                                                                    |
 |  +--------------------------------------------------------------+  |
 |  |                                                              |  |
 |  |  SNMP engine (identified by snmpEngineID)                    |  |
 |  |                                                              |  |
 |  |  +---------------+  +--------------+  +---------------+      |  |
 |  |  |               |  |              |  |               |      |  |
 |  |  | Message       |  | Security     |  | Access        |      |  |
 |  |  | Processing    |  | Subsystem    |  | Control       |      |  |
 |  |  | Subsystem     |  |              |  | Subsystem     |      |  |
 |  |  |               |  |              |  |               |      |  |
 |  |  +---------------+  +--------------+  +---------------+      |  |
 |  |                                                              |  |
 |  +--------------------------------------------------------------+  |
 |                                                                    |
 |  +--------------------------------------------------------------+  |
 |  |                                                              |  |
 |  |  Application(s)                                              |  |
 |  |                                                              |  |
 |  |  +-------------+  +--------------+  +--------------+         |  |
 |  |  | Command     |  | Notification |  | Proxy        |         |  |
 |  |  | Generator   |  | Receiver     |  | Forwarder    |         |  |
 |  |  +-------------+  +--------------+  +--------------+         |  |
 |  |                                                              |  |
 |  |  +-------------+  +--------------+  +--------------+         |  |
 |  |  | Command     |  | Notification |  | Other        |         |  |
 |  |  | Responder   |  | Originator   |  |              |         |  |
 |  |  +-------------+  +--------------+  +--------------+         |  |
 |  |                                                              |  |
 |  +--------------------------------------------------------------+  |
 |                                                                    |
 +--------------------------------------------------------------------+

\

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 that
-- has three subsystems:

   1) a larger buffer, Message Processing Subsystem,
   2) a Security Subsystem, and use
   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 transport that can handle
--
one-to-one association between SNMP engines and SNMP entities,
it also uniquely and unambiguously identifies the larger size, why artficially limit it? SNMP entity.

3.1.4. Message Processing Subsystem

The type can
--                 handle the larger number; why impose unnecessary limits?
    SYNTAX       Integer32 (484..65507)
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION "The maximum length 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 octets the next picture. Those
marked with an asterisk (*) may be absent.

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

3.1.5. Message Processing Model

Each Message Processing Model defines the format of a particular
version of an SNMP message
                 which this SNMP engine can send or receive and
                 process, determined as coordinates the minimum processing of each
version-specific message.

\

3.1.6. Security Subsystem

The Security Subsystem provides security services such as the maximum
                 message size values supported among all
authentication and privacy of the
                 transports available to messages and supported by potentially contains
multiple Security Models as shown in the engine.
                "
-- From BW to DBH: How do you like this (picked it from RFC1910):
--                 I think it is only meant to state what next picture. Those
marked with an asterisk (*) may be absent.

 +------------------------------------------------------------------+
 |                                                                  |
 |  Security Subsystem                                              |
 |                                                                  |
 |  +------------+  +-------------------+  +---------------------+  |
 |  |            |  |                 * |  |                   * |  |
 |  | User-Based |  | Community-based   |  | Other               |  |
 |  | Security   |  | Security          |  | Security            |  |
 |  | Model      |  | Model             |  | Model               |  |
 |  |            |  |                   |  |                     |  |
 |  +------------+  +-------------------+  +---------------------+  |
 |                                                                  |
 +------------------------------------------------------------------+

3.1.7. Security Model

A Security Model defines the threats against which it can
--                 receive!!!
-- DBH to BW:      I think protects,
the one above came from snmpv2*. I think goals of its services, and the send
--                 was included to indictae
-- security protocols used to an enquiring manager how large a getBulk might be
--                 supported, so a manager didn't send one obviously too large,
-- 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 reflect that provide a message might be receivable, but not
--                 be able to be processed due to resource limitations (such
-- security service such as an ASN.1-decoded message being larger than the encoded
--			 message, 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                                        |
 |                                                                  |
 |  +------------+  +-------------------+  +---------------------+  |
 |  |            |  |                 * |  |                   * |  |
 |  | View-Based |  | Community         |  | Other               |  |
 |  | Access     |  | Access            |  | Access              |  |
 |  | Control    |  | Control           |  | Control             |  |
 |  | Model      |  | Model             |  | Model               |  |
 |  |            |  |                   |  |                     |  |
 |  +------------+  +-------------------+  +---------------------+  |
 |                                                                  |
 +------------------------------------------------------------------+

3.1.10. Access Control Model

An Access Control Model defines a secured message with a non-sent key that led
--                 to resource allocation problems...)
--  DESCRIPTION "The maximum length particular access decision function
in octets order to support decisions regarding authorization.

3.1.11. Applications

There are several types of an SNMP message applications, which
--               this agent will accept using any transport mapping.
--              "
    ::= { imfEngine 4 }

-- From BW to DBH: Was the following decided at the interim?
--                 We had those defined in USEC doc.... so if we
--                 do define these protocols here, then I can
--                 remove them from USEC doc.
-- DBH to BW:      Not sure if decided; If we want protocols defined
--			in a common place, include:

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

These applications make use of the arch mib should provide services provided by the tree.
--                I don't object to MD5 Security
and DES being defined in USEC, but
-- 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                        |     |
       |                                     |     |
       |  +-----------------------+          |     |
       |  | Security Model        |          |     |
       |  |  +-------------+      |          |     |
  wire |  |  | Model       |    +------------+--+  |
<----------->| Dependent   |<-->| | securityName|  |
       |  |  | Security ID |    +---------------+  |
       |  |  +-------------+      |                |
       |  |                       |                |
       |  +-----------------------+                |
       |                                           |
       |                                           |
       +-------------------------------------------+

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)                | |
    | |                                                          | |
    | |  +---------------+  +--------------+  +---------------+  | |
    | |  |               |  |              |  |               |  | |
    | |  | Message       |  | Security     |  | Access        |  | |
    | |  | Processing    |  | Subsystem    |  | Control       |  | |
    | |  | Subsystem     |  |              |  | Subsystem     |  | |
    | |  |               |  |              |  |               |  | |
    | |  +---------------+  +--------------+  +---------------+  | |
    | |                                                          | |
    | +----------------------------------------------------------+ |
    |                                                              |
    | +----------------------------------------------------------+ |
    | | Command Responder Application                            | |
    | | (contextEngineID, example: abcd)                         | |
    | |                                                          | |
    | | example contextNames:                                    | |
    | |                                                          | |
    | | "repeater1"        "repeater2"          "" (default)     | |
    | | -----------        -----------          ------------     | |
    | |     |                   |                    |           | |
    | +-----|-------------------|--------------------|-----------+ |
    |       |                   |                    |             |
    | +-----|-------------------|--------------------|-----------+ |
    | | MIB |  instrumentation  |                    |           | |
    | |-----v------------+ +----v-------------+ +----v-----------| |
    | | context          | | context          | | context        | |
    | |                  | |                  | |                | |
    | | +--------------+ | | +--------------+ | | +------------+ | |
    | | | repeater MIB | | | | repeater MIB | | | | other MIB  | | |
    | | +--------------+ | | +--------------+ | | +------------+ | |
    | |                  | |                  | |                | |
    | |                  | |                  | | +------------+ | |
    | |                  | |                  | | | some  MIB  | | |
    | |                  | |                  | | +------------+ | |
    | |                  | |                  | |                | |
    +--------------------------------------------------------------+

\

3.3.1. An SNMP Context

An SNMP context, or just "context" for short,  is a collection of
management information accessible by an SNMP entity. An item of
management information may exist in more than one context. An SNMP
engine potentially has access to many contexts.

Typically, there are many instances of each managed object type within
a management domain.  For simplicity, the method for identifying
instances specified by the MIB module does not allow each instance to
be distinguished amongst the set of all instances within a management
domain; rather, it allows each instance to be identified only within
some scope or "context", where there are multiple such contexts within
the management domain.  Often, a context is a physical device, or
perhaps, a logical device, although a context can also encompass
multiple devices, or a subset of a single device, or even a subset of
multiple devices, but a context is always defined as a subset of a
single SNMP entity.  Thus, in order to identify an individual item of
management information within the management domain, its contextName
and contextEngineID must be identified in addition to its object type
and its instance.

For example, the managed object type ifDescr [RFC1573], is defined as
the description of a network interface.  To identify the description
of device-X's first network interface, four pieces of information are
needed: the snmpEngineID of the SNMP entity which provides access to
device-X, the contextName (device-X), the managed object type
(ifDescr), and the instance ("1").

Each context has (at least) one unique identification within the
management domain. The same item of management information can exist
in multiple contexts. So, an item of management information can have
multiple unique identifications, either because it exists in multiple
contexts, and/or because each such context has multiple unique
identifications.

The combination of a contextEngineID and a contextName unambiguously
identifies a context within an administrative domain.

3.3.2. contextEngineID

Within an administrative domain, a contextEngineID uniquely
identifies an SNMP entity that may realize an instance of a
context with a particular contextName.

3.3.3. contextName

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

3.3.4. scopedPDU

\

A scopedPDU is a block of data containing a contextEngineID,
a contextName, and a PDU.

The PDU is an SNMP Protocol Data Unit containing information
named in the context which is unambiguously identified within
an administrative domain by the combination of the contextEngineID
and the contextName. See, for example, RFC1905 for more information
about SNMP PDUs.

3.4. Other Constructs

3.4.1. maxSizeResponseScopedPDU

The maxSizeResponseScopedPDU is the maximum size 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 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 the message and its contents.

\

4. Architectural Elements 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. The architecture also includes applications which utilize the
services provided by 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, 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 the Access Control Subsystem, and may use SNMP messages to
communicate with remote nodes.  The network management service may
be requested via the payload of an SNMP message, or may be requested
via a local process.

\

4.1.  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)
 +--------------------------------------------------------------------+
 | SNMP entity                                                        |
 |                                                                    |
 | +--------------+         +--------------+         +--------------+ |
 | | NOTIFICATION |         | NOTIFICATION |         |   COMMAND    | |
 | |  ORIGINATOR  |         |   RECEIVER   |         |  GENERATOR   | |
 | | applications |         | applications |         | applications | |
 | +--------------+         +--------------+         +--------------+ |
 |         ^                       ^                        ^         |
 |         |                       |                        |         |
 |         v                       v                        v         |
 | +----------------------------------------------------------------+ |
 | |        Message Processing Application Multiplexor              | |
 | +----------------------------------------------------------------+ |
 |                     ^          ^            ^             ^        |
 | +-----------+       |          |            |             |        |
 | |           |       v          v            v             v        |
 | | Security  |    +------+  +---------+  +--------+   +-----------+ |
 | | Subsystem |<-->| v3MP |  | v2cMP * |  | v1MP * |...| otherMP * | |
 | |           |    +------+  +---------+  +--------+   +-----------+ |
 | +-----------+       ^          ^            ^             ^        |
 |                     |          |            |             |        |
 |                     v          v            v             v        |
 | +----------------------------------------------------------------+ |
 | |      Message Processing Model selection (incoming only)        | |
 | +----------------------------------------------------------------+ |
 |                           ^                                        |
 |                           |                                        |
 |                           v                                        |
 | +----------------------------------------------------------------+ |
 | |          TRANSPORT MAPPING (for example RFC1906)               | |
 | +----------------------------------------------------------------+ |
 +--------------------------------------------------------------------+
        +-----+ +-----+       +-------+
        | UDP | | IPX | . . . | other |
        +-----+ +-----+       +-------+
           ^       ^              ^
           |       |              |
           v       v              v
        +------------------------------+
        |           Network            |
        +------------------------------+

\
        +------------------------------+
        |           Network            |
        +------------------------------+
           ^       ^              ^
           |       |              |
           v       v              v
        +-----+ +-----+       +-------+
        | UDP | | IPX | . . . | other |
        +-----+ +-----+       +-------+       (traditional SNMP agent)
 +--------------------------------------------------------------------+
 | +----------------------------------------------------------------+ |
 | |          TRANSPORT MAPPING (for example RFC1906)               | |
 | +----------------------------------------------------------------+ |
 |                           ^                                        |
 |                           |                                        |
 |                           v                                        |
 | +----------------------------------------------------------------+ |
 | |      Message Processing Model selection (incoming only)        | |
 | +----------------------------------------------------------------+ |
 |                     ^          ^            ^             ^        |
 | +-----------+       |          |            |             |        |
 | |           |       v          v            v             v        |
 | | Security  |    +------+  +---------+  +--------+   +-----------+ |
 | | Subsystem |<-->| v3MP |  | v2cMP * |  | v1MP * |...| otherMP * | |
 | |           |    +------+  +---------+  +--------+   +-----------+ |
 | +-----------+       ^          ^            ^             ^        |
 |                     |          |            |             |        |
 |                     v          v            v             v        |
 | +----------------------------------------------------------------+ |
 | |        Message Processing Abstract Service Interface           | |
 | +----------------------------------------------------------------+ |
 |        ^                               ^                ^          |
 |        |                               |                |          |
 |        v                               v                v          |
 | +-------------+   +---------+   +--------------+   +-------------+ |
 | |   COMMAND   |   | ACCESS  |   | NOTIFICATION |   |    PROXY  * | |
 | |  RESPONDER  |<->| CONTROL |<->|  ORIGINATOR  |   |  FORWARDER  | |
 | | application |   |         |   | applications |   | application | |
 | +-------------+   +---------+   +--------------+   +-------------+ |
 |        ^                               ^                           |
 |        |                               |                           |
 |        v                               v                           |
 | +----------------------------------------------+                   |
 | |             MIB instrumentation              |       SNMP entity |
 +--------------------------------------------------------------------+

\

4.2. Sending and Receiving SNMP Messages

4.2.1. Send a Message to the Network

Applications may request that messages be generated and sent. The
application has the responsibility of providing the information
necessary to generate the message, as detailed below, and of
providing the transport address to which the message should be sent.

The engine passes a request for a message to be generated to the
specified Message Processing Model which, utilizing the services of
the selected Security Model, generates the message and prepares it
for sending.

The SNMP engine sends the message to the specified transport address.
It then advises the sending Message Processing Model about the success
or failure of the sending of the message.

4.2.2. Receive a Message from the Network

It is the responsibility of the SNMP engine to listen for incoming
messages at the appropriate local addresses. Some local addresses
for listening are recommended by SNMP Transport Mapping documents,
such as [RFC1906].

Upon receipt of an SNMP message, the SNMP engine increments the
snmpInPkts counter [RFC1907].

SNMP messages received from the network use a format defined by a
version-specific Message Processing Model, typically identified
by a version field in the message header.

The engine determines the SNMP version of an incoming message by
inspecting the serialized values for a recognizable pattern.
The mechanism by which it makes the determination 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 the snmpInBadVersions counter [RFC1907] is incremented,
and the message is discarded without further processing.

The SNMP engine caches the msgID, which is subsequently used for
coordinating all processing regarding this received message, and
caches the origin network address so a possible response can be
sent to the origin address.

Based on the SNMP version of the message, the engine passes the
message to the appropriate version-specific Message Processing Model.
The Message Processing Model extracts the information in the message,
utilizing services of the appropriate Security Model to authenticate

\

and decrypt the message as needed.

4.3. Send a Request or Notification Message for an Application

The Application Multiplexor receives a request for the generation
of an SNMP message from an application via the sendPdu primitive:

sendPdu(
    transportDomain             -- transport domain to be used
    transportAddress            -- destination network address
    messageProcessingModel      -- typically, SNMP version
    securityModel               -- Security Model to use
    securityName                -- on behalf of this principal
    LoS                         -- Level of Security requested
    contextEngineID             -- data from/at this entity
    contextName                 -- data from/in this context
    PDU                         -- SNMP Protocol Data Unit
    expectResponse)             -- TRUE or FALSE

The SNMP engine checks the "expectResponse" parameter to determine if
it is a message which is expected to receive a response, and if so,
caches the msgID of the generated message and which application
made the request.

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

4.4. Receive a Request or Notification Message from the Network

The engine receives the message according to the procedure detailed
in section 4.2.2. Receive a Message from the Network.

The Application Demultiplexor looks into the scopedPDU to determine
the contextEngineID and the PDU type, then determines which
application has registered (see section 4.7) to support that PDU type
for that contextEngineID.

The Application Demultiplexor passes the request or notification
to the registered application using the processPdu primitive:

processPdu(
    contextEngineID             -- data from/at this SNMP engine
    contextName                 -- data from/in this context
    PDU                         -- SNMP Protocol Data Unit
    maxSizeResponseScopedPDU    -- maximum size of the Response PDU
    securityModel               -- Security Model in use
    securityName                -- on behalf of this principal
    LoS                         -- Level of Security
    stateReference)             -- reference to state information
                                -- needed when sending a response

\

4.5. Generate a Response Message for an Application

The Application Multiplexor receives a request for the generation
of an SNMP response message from an application via the
returnResponsePdu primitive:

returnResponsePdu(
    contextEngineID             -- data from/at this SNMP engine
    contextName                 -- data from/in this context
    securityModel               -- Security Model in use
    securityName                -- on behalf of this principal
    LoS                         -- Level of Security
    stateReference              -- reference to state information
                                -- as presented with the request
    PDU                         -- SNMP Protocol Data Unit
    maxSizeResponseScopedPDU    -- maximum size of the Response PDU
    statusInformation           -- success or errorIndication
    )                           -- error counter OID/value if error

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

4.6. Receive a Response Message

The engine receives the message according to the procedure detailed
in section 4.2.2. Receive a Message from the Network.

The Application Demultiplexor looks into the scopedPDU to determine
the contextEngineID and the PDU type.

If the PDU type is a Response PDU, the Demultiplexor matches the
msgID of the incoming response to the cached msgIDs of messages
sent by this SNMP engine.

If a matching cached msgID is found, the cached msgID and the cached
origin network address are released, and the response is passed to the
associated application using the processResponsePdu primitive:

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

4.7. Registering to Receive Asynchronous Messages

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

\

the message should be given.

An Application that wishes to receive asynchronous messages registers
itself with the engine using the registration primitive. The
application registers to handle all incoming messages containing
a particular PDU type regarding a specific contextEngineID.

statusInformation =             -- success or errorIndication
    registerContextEngineID(
        contextEngineID         -- take responsibility for this one
        pduType                 -- the pduType(s) to be registered
        )

Only one registration per PDU type per contextEngineID is permitted
at the same time. Duplicate registrations are ignored. An
errorIndication will be returned to the application if it attempts
to duplicate an existing registration.

An Application that wishes to stop receiving asynchronous messages
should unregister itself with the SNMP engine.

unregisterContextEngineID(
        contextEngineID         -- give up responsibility for this one
        pduType                 -- the pduType(s) to be unregistered
        )

SNMP does not provide a mechanism for identifying an application,
so the mechanism used to identify which application is registering
is implementation-specific.

\

5. Definition of Managed Objects for Internet Management Frameworks

SNMP-FRAMEWORK-MIB DEFINITIONS ::= BEGIN

IMPORTS
    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"            -- 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 }  -- DBH: check if this number is indeed OK

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

SnmpEngineID ::= TEXTUAL-CONVENTION
    STATUS       current

\
    DESCRIPTION "An SNMP engine's administratively-unique identifier.

                 The value for this object may not be all zeros or
                 all 'ff'H.  It may also not be the empty 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 for a twelve-octet identifier
                 is recommended:

                 1) The first four octets are set to the binary
                    equivalent of the entity'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 assigned '000002b8'H.

                 2) 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 entity'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 that indicates the method being used and
                    the remaining octets are a function of the method.
                "
    SYNTAX       OCTET STRING

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

                 The values for securityModel are allocated as follows:

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

                   enterpriseID * 256 + security model within enterprise

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

                 The eight bits allow a maximum of 255 (256-1 reserved)
                 standards based Security Models.  Similarly, they
                 allow a maximum of 255 Security Models per enterprise.

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

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

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

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

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

SnmpLoS ::= TEXTUAL-CONVENTION
    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 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 the arch doc does specify they 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 expected, so I think
--                it treasonable added by amendments
                 to define here, especially if we want the 10646 standard from time to
--                make it mandatory for basic compliance.
--
-- time,
                 implementations must be prepared to encounter any code
                 point from 0x00000000 to 0x7fffffff.

                 The IMF IETF-Standard Authentication Protocols Group use of control codes should be avoided.

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

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

--

imfAuthProtocols Administrative assignments ****************************************

snmpFrameworkAdmin          OBJECT IDENTIFIER ::= { imfAdmin snmpFrameworkMIB 1 }

imfNoAuthProtocol
snmpFrameworkMIBObjects     OBJECT IDENTIFIER ::= { imfAuthProtocols 1 snmpFrameworkMIB 2 }

imfAuthMD5Protocol
snmpFrameworkMIBConformance OBJECT IDENTIFIER ::= { imfAuthProtocols 2 snmpFrameworkMIB 3 }

DBH to BW: should we have a description of this object to make it
meaningful? ditto for DES below.

--

\

-- The IMF IETF-Standard Privacy Protocols the snmpEngine Group
--

imfPrivProtocols **********************************************

snmpEngine OBJECT IDENTIFIER ::= { imfAdmin 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 SNMP engine has
                 (re-)initialized itself since its initial
                 configuration.
                "
    ::= { snmpEngine 2 }

imfNoPrivProtocol     OBJECT IDENTIFIER

snmpEngineTime   OBJECT-TYPE
    SYNTAX       Integer32 (0..2147483647)
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION "The number of seconds since the 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 for standards-track authentication
                  protocols used in the Internet Management Framework.
                 "
    ::= { imfPrivProtocols snmpFrameworkAdmin 1 }

imfDESPrivProtocol    OBJECT IDENTIFIER

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

-- conformance Conformance information

imfMIBCompliances *******************************************

snmpFrameworkMIBCompliances

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

-- compliance statements

imfMIBCompliance

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

    ::= { imfMIBCompliances snmpFrameworkMIBCompliances 1 }

-- units of conformance

imfEngineBasicGroup

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

-- DBH to BW: should the tree for registering protocols be in basicGroup?
--            I thouhgt we had consensus that user-based security was required

--            as a minimum. No?

END

7. Model Design Requirements

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

\

6. Security Considerations

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 describes how a fixed
set of abstract data elements and primitive functions which framework can be overloaded
to satisfy the needs of multiple model definitions.

Documents which define models to be used within this architecture are constrained
to using the abstract data elements for transferring data between subsystems,
possibly defining specific mechanisms for converting the abstract data into
model-usable formats. This constraint exists to allow subsystem use a Security Model and model
documents
an Access Control Model to be written recognizing common borders achieve a level of the subsystem security for network
management messages and model.
Vendors are not constrained controlled access to recognize these borders in their implementations. management information.

The architecture defines certain standard services to be level of security provided
between subsystems, is determined by the specific Security
Model implementation(s) and the architecture defines abstract specific Access Control Model
implementation(s) incorporated into this framework.

Applications have access to data
elements which is not secured.  Applications
should take reasonable steps to transfer protect the data necessary to perform from disclosure.

It is the services.

Each model definition for a subsystem must support responsibility of the standard service
interfaces, but whether, or how, or how well, it performs purchaser of a management framework
implementation to ensure that:
  1) an implementation of this framework complies with the service
is rules
      defined by this architecture,
  2) the model definition.

7.1. Security Model Design Requirements

7.1.1. Threats

Several and Access Control Models utilized satisfy the
      security and access control needs of the classical threats to network protocols are applicable
to organization,
  3) the network management problem 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 therefore would be applicable
to any security model used in an Internet Management Framework. Other
threats are not applicable S., Waldbusser, "Introduction to the network management problem.  This
section discusses principal threats, secondary threats, and threats
which are of lesser importance.
    Community-based SNMPv2", RFC 1901, January 1996.

[RFC1902] The principal threats against which any security model used within
this architecture should provide protection are:

Modification SNMPv2 Working Group, Case, J., McCloghrie, K.,
    Rose, M., and S., Waldbusser, "Structure of Management
    Information
     The modification threat is the danger that some unauthorized
     entity may alter in-transit SNMP messages generated on behalf for Version  2 of an authorized security-identity in such a way as to effect
     unauthorized management operations, including falsifying the
     value of an object.

Masquerade Simple Network Management
    Protocol (SNMPv2)", RFC 1905, January 1996.

[RFC1903] The masquerade threat is the danger that management operations
     not authorized SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M.,
    and S. Waldbusser, "Textual Conventions for some security-identity may be attempted by
     assuming Version 2 of the identity 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 another security-identity that has the
     appropriate authorizations.

Message Stream Modification
    Simple Network Management Protocol (SNMPv2)", RFC 1904,
    January 1996.

[RFC1905] The SNMPv3 protocol is typically based upon a connectionless
     transport service which may operate over any subnetwork service. 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 re-ordering, delay or replay of messages can SNMPv2 Working Group, Case, J., McCloghrie, K.,
    Rose, M., and does occur
     through the natural operation S. Waldbusser, "Transport Mappings for
    Version 2 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 Simple Network Management Protocol (SNMPv2)",
    RFC 1906, January 1996.

[RFC1907] The disclosure threat is the danger SNMPv2 Working Group, Case, J., McCloghrie, K.,
    Rose, M., and S. Waldbusser, "Management Information Base for
    Version 2 of eavesdropping on the
     exchanges 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 SNMP engines. Protecting against this threat
     may be required as a matter Version 1
    and Version 2 of local policy.

There are at least two threats against which a security model used
by a framework within this architecture need not protect.

Denial the Internet-standard Network Management

\
    Framework", RFC 1908, January 1996.

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

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

\

9. Editor's Addresses

                   Co-editor:  Bert Wijnen
                               IBM T.J. Watson Research
                   postal:     Schagen 33
                               3461 GL Linschoten
                               Netherlands
                   email:      wijnen@vnet.ibm.com
                   phone:      +31-348-432-794

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

\

10. Acknowledgements

This document builds on the work of Service
     A security model need not attempt to address the broad range SNMP Security and
Administrative Framework Evolution team, composed of
     attacks by which service on behalf

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

\

APPENDIX A

A. Guidelines for Model Designers

This appendix describes guidelines for designers of authorized users is denied.
     Indeed, such denial-of-service attacks models which
are expected to fit into the architecture defined in many cases
     indistinguishable this document.

The basic design elements come from the type of network failures with which any
     viable network management protocol must cope SNMPv2u and SNMPv2*, as
described in RFCs 1909-1910, and from a matter set of
     course.

Traffic Analysis
     A internet drafts.
these are the two most popular de facto "administrative framework"
standards that include security model need not attempt to address traffic analysis
     attacks.  Many traffic patterns and access control for SNMPv2.

SNMPv1 and SNMPv2c [RFC1901] are predictable - agents may be
     managed two administrative frameworks based
on a regular basis by a relatively small number 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
     management stations - SNMPv1 and therefore
SNMPv2c Frameworks could be fit into this architecture, but this
document does not provide guidelines for that coexistence.

Within any subsystem model, there is no significant
     advantage afforded by protecting against traffic analysis.

7.1.2. Security Processing

Received messages must should be validated no reference to any
specific model of another subsystem, or to data defined by a specific
model of the security another subsystem. Validation includes authentication and privacy processing

if needed, but it

Transfer of data between the subsystems is explicitly allowed to send messages which do
not require authentication or privacy.

A received message will contain deliberately described

as a specified Level fixed set of Security to be
used during processing. All messages requiring privacy must also
require authentication.

A security model specifies rules by which authentication abstract data elements and privacy
are to primitive functions
which can be done. A model may define mechanisms overloaded to provide additional
security features, but satisfy the needs of multiple model definition is constrained
definitions.

Documents which define models to using
(possibly a subset of) be used within this architecture
SHOULD use the standard primitives between subsystems, possibly
defining specific mechanisms for converting the abstract data elements defined in this
document for transferring data between subsystems.

Each Security model may
into model-usable formats. This constraint exists to allow multiple security mechanisms subsystem
and model documents to be used
concurrently within an implementation written recognizing common borders 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
subsystem and Privacy protocols supported by security models model. Vendors are uniquely identified using Object Identifiers. IETF standard
protocol for authentication or privacy should have an identifier
defined within the ImfAuthenticationProtocols or ImfPrivacyProtocols
subtrees. Enterprise-specific protocol identifiers should be defined
within the enterprise subtree.

For privacy, not constrained to recognize these
borders in their implementations.

The architecture defines certain standard services to be provided
between subsystems, and the Security model architecture defines what portion of abstract service
interfaces to request the message
is encrypted.

The persistent data used services.

Each model definition for security should be SNMP-manageable, but a subsystem SHOULD support the Security model defines whether an instantiation of standard
service interfaces, but whether, or how, or how well, it performs
the MIB service is defined by the model definition.

A.1. Security Model Design Requirements

A.1.1. Threats

A document describing a
conformance requirement. Security models are replaceable within Model MUST describe how the security subsystem. Multiple
Security model Implementations may exist concurrently within an engine.
The number of Security models defined by
protects against the SNMP community should
remain small to promote interoperability. It is required that an
implementation threats described under "Security Requirements
of the User-Based this Architecture", section 1.4.

\

A.1.2. Security model Processing

Received messages MUST be used in all
engines to ensure at least validated by a minimal level Model of interoperability.

7.1.3. validate the security-stamp in a 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

given contains a message, the MMS, LoS, and the security parameters from that
message, verify the message has not been altered, and authenticate
the identification specified Level of the security-identity for whom the message was
generated.

If encrypted, decrypt the message

Additional requirements may Security to be defined
used during processing.  All messages requiring privacy MUST also
require authentication.

A Security Model specifies rules by the model, which authentication and privacy
are to be done.  A model may define mechanisms to provide additional

services provided by the model,
security features, but the model definition is constrained to use
only using
(possibly a subset of) the defined abstract data elements defined in this
document for transferring data between subsystems. Implementations are no so constrained.

return a MIID identifying the security-identity for whom
the message was generated and return the portions of the message
needed for further processing:
         a PDU - a PDU containing varbinds and a verb according

Each Security Model may allow multiple security mechanisms to
            the rules be used
concurrently within an implementation of the Local Processing model model. Each Security Model
defines how to be used. determine which protocol to use, given the LoS - and the level of security required. The same level of
security must also be used during application of access
            control.
         MMS - the maximum size of a message able parameters relevant to be generated 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 this engine Security Models are
uniquely identified using Object Identifiers. IETF standard protocol
for authentication or privacy should have an identifier defined within
the destination agent.
         PDU-MMS - snmpAuthProtocols or the maximum size of a PDU to snmpPrivProtocols subtrees. Enterprise
specific protocol identifiers should be included in a
            response message, given defined within the amount enterprise
subtree.

For privacy, the Security Model defines what portion of
            reserved space in the message for the anticipated
            security parameters.

7.1.4. Security Identity

Different security models define identifiers which represent some
<thing> which somehow exists, and
is capable of using SNMP. encrypted.

The <thing> may be person, or a network-management platform, or
an aggregate of persons, or an aggregation of persons and devices,
or some other abstraction of entities that are recognized as
being able to use SNMP-defined services.

This document will refer to that abstraction as a security-identity.

7.1.5. Model Dependent Identifier

Each persistent data used for security should be SNMP-manageable, but
the Security model Model defines how security-identities are identified
within whether an instantiation of the model, i.e. how they MIB is a
conformance requirement.

Security Models are named. Model-dependent identifiers
must be unique replaceable within the model. Security Subsystem.
Multiple Security Model implementations may exist concurrently within
an SNMP engine.  The combination number of engineID,
securityModel, and Security Models defined by the correct model-dependent identifier can be
used SNMP
community should remain small to uniquely identify a security-identity.

For example, David Harrington may be represented on promote interoperability.

A.1.3. validate the security-stamp in a particular
engine by multiple security models - as received message

The Message Processing Model requests that the user "davidh", Security Model verify
that the
community "david", message has not been altered, and authenticate the foobar "david". It is legal to use
"david" in more than one model, since uniqueness is only guaranteed
within the model, but there cannot be two "david" communities.
The combination
identification of the engineID, principal for whom the message was generated.
If encrypted, decrypt the message.

\

Additional requirements may be defined by the <user> model, and additional
services provided by the user
"davidh" uniquely identifies model, but the security-entity David Harrington.

7.1.6. Model Independent Identifier

It is desirable to be able to refer to a security-entity using a human
readable identifier, such as for audit trail entries.
Therefore, each Security model is required constrained to define a mapping use
the following primitives for transferring data between

a model-dependent identifier and an identifier restricted to a human
readable character set. This identifier is called a MIID. subsystems.
Implementations are not so constrained.

The type of a MIID is a human-readable OCTET STRING Message Processing Model uses the following 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
conventions received message
    LoS                         -- Level of Security
    wholeMsg                    -- as received on the SnmpAdminString TEXTUAL-CONVENTION, defined below.

The combination of engineID and securityModel and MIID can be used wire
    wholeMsgLength              -- length as a
globally-unique identifier for a security-identity.

It is important to note that since received on the MIID may be accessible outside wire
    )

The Security Model uses the engine, care must be taken following primitive to not disclose sensitive data, such
as by including passwords in open text in respond:

returnProcessedMsg(
    securityName                -- identification of the principal
    scopedPDU,                  -- message (plaintext) payload
    maxSizeResponseScopedPDU    -- maximum size of the MIID.

7.1.5. Response PDU
    securityStateReference      -- reference to security state
                                -- information, needed for response
    statusInformation           -- errorIndication or success
    )                           -- error counter OID/value if error

A.1.5. Security MIBs

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

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

7.1.6. allows access.

A.1.6. Security State Cacheing Cache

For each message received, the security subsystem Security Subsystem caches the state
information such that a response Response message can be generated using the
same security state information, even if the security portion of the Local Configuration
Datastore is altered between the time of the incoming request and
the outgoing response.

The Orangelet subsystem has

\

Applications have the responsibility for explicitly releasing the
cached data. To enable this, an abstract state_reference stateReference data element
is passed from the security subsystem Security Subsystem to the message processing and control
subsystem, Message Processing
Subsystem, which passes it to the orangelet subsystem. application.

The cached security data must may be implicitly released via the
generation of a response, or explicitly released by using the state_release()
stateRelease primitive:

state_release( state_reference

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

7.2. MessageEngine

\

A.2. SNMP engine and Message Processing and Control Model Requirements

A messageEngine

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

Within any version-specific Message Processing and Control model, Model, there may be
an explicit binding to a particular security model Security Model but there should
be no reference to any data defined by a specific security model. there Security Model.
There should be no reference to any specific Orangelet model, application, or to any
data defined by a specific Orangelet model; application; there should be no reference
to any specific Access Control model, Model, or to any data defined by a
specific Access Control model. Model.

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

7.2.1.
varBinds.

A.2.1. Receiving an SNMP Message from the Network

Upon receipt of a message from the network, the messageEngine will,
in an implementation-defined manner, establish a mechanism SNMP engine notes the
msgID, which is subsequently  used for coordinating all processing
regarding this received message, e.g. it may assign a "handle"
to the message.
DBH: It is no longer valid that the MPC coordinates all processing. But it
still needs to match requests and responses. how does an incoming request get
matched to the outgoing response?

A Message Processing and Control model will specify Model specifies how to determine the values of
the global data (MMS, (mms, the securityModel, the LoS), and the security
parameters block. The Message Processing and Control will call 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 security
model to provide security processing sending SNMP entity
    msgFlags                    -- for the received message using
    securityParameters          -- for the primitive:

processMsg( globalData, securityParameters, wholeMsg, wholeMsgLen received message
    securityModel               -- for the received message
    LoS                         -- Level of Security
    wholeMsg                    -- as received on the wire
    wholeMsgLength              -- length as received on the wire
    )

The Security model, after completion of its processing, will return Model uses the following primitive to respond:

returnProcessedMsg(
    securityName                -- identification of the Message Processing and Control model principal
    scopedPDU,                  -- message (plaintext) payload
    maxSizeResponseScopedPDU    -- maximum size of the extracted Response PDU
    securityStateReference      -- reference to security state
                                -- information, using
the returnProcess() primitive:

returnProcess( scopedPDUmms, MIID, cachedSecurityData, scopedPDU, statusCode needed for response
    statusInformation           -- errorIndication or success
    )

7.2.2.                           -- error counter OID/value if error

\

A.2.2. Send SNMP messages to the network

The Message Processing and Control model will pass Model passes a PDU, the
MIID,
securityName, and all global data to be included in the message to
the Security model using the following primitives:

For requests and notifications:

generateRequestMessage( globalData, scopedPDU, MIID, engineID

generateRequestMsg(
    messageProcessingModel      -- typically, SNMP version
    msgID                       -- for the outgoing message
    mms                         -- of the sending SNMP entity
    msgFlags                    -- for the outgoing message
    securityParameters          -- filled in by Security Module
    securityModel               -- for the outgoing message
    securityName                -- on behalf of this principal
    LoS                         -- Level of Security requested
    snmpEngineID                -- authoritative SNMP engine
    scopedPDU                   -- message (plaintext) payload
    )

DBH: why do we need engineID? isn't that implicit?

For response messages:

generateResponseMessage( globalData, scopedPDU, MIID, cachedSecurityData

generateResponseMsg(
    messageProcessingModel      -- typically, SNMP version
    msgID                       -- for the outgoing message
    mms                         -- of the sending SNMP entity
    msgFlags                    -- for the outgoing message
    securityParameters          -- filled in by Security Module
    securityModel               -- for the outgoing message
    scopedPDU                   -- message (plaintext) payload
    securityStateReference      -- reference to security state
                                -- information, as received in
    )                           -- processPdu primitive

The Security model will construct constructs the message, and return returns the completed
message to the messageEngine Message Processing Model using the returngenerate() returnGeneratedMsg
primitive:

returnGenerate( wholeMsg, wholeMsglen, statusCode

returnGeneratedMsg(
    wholeMsg                    -- complete generated message
    wholeMsgLength              -- length of the generated message
    statusInformation           -- errorIndication or success
    )

The messageEngine will send SNMP engine sends the message to the desired address using the
appropriate transport.

7.2.3.

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

\

The messageEngine will receive SNMP engine receives a request for the generation of an an SNMP
message from an application via the sendPdu primitive:

sendPdu(
    transportDomain             -- transport domain to be used
    transportAddress            -- destination network address
    messageProcessingModel      -- typically, SNMP version
    securityModel               -- Security Model to use
    securityName                -- on behalf of this principal
    LoS                         -- Level of Security requested
    contextEngineID             -- data from/at this entity
    contextName                 -- data from/in this context
    PDU                         -- SNMP message
from an orangelet via the send_pdu primitive:

send_pdu( transportDomain, transportAddress, snmpVersion,
    LoS, securityModel, MIID, contextEngineID,
    contextName, PDU, Protocol Data Unit
    expectResponse              -- TRUE or FALSE
    )

The messageEngine SNMP engine checks the verb in the PDU "expectResponse" parameter to determine if
it is a message which may is expected to receive a response, and if so,
caches the msgID of the generated message and the associated orangelet.
application.

The messageEngine will generate Message Processing Model generates the message according to the
process described in 7.2.2.

7.2.4. Forward A.2.2.

A.2.4. Pass Received Response Message to an Orangelet Application

The Message Processing and Control will receive Model receives the SNMP message according to
the process described in 7.2.1. A.2.1.

The Message Processing and Control will determine Model determines which orangelet application is awaiting a
this response, using the msgID and the cached information from
step 7.2.3 A.2.3

The messageEngine Message Processing Model matches the msgID of an incoming response
to the cached msgIDs of messages sent by this messageEngine, SNMP engine, and
forwards the response to the associated Orangelet application using the process_pdu()
processResponsePdu primitive:

process_pdu( contextEngineID, contextName, pdu, LoS, scopedPdu-MMS,
	securityModel, MIID, state-reference

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

7.2.5. Forward

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

The messageEngine will receive Message Processing Model receives the SNMP message according to
the process described in 7.2.1. A.2.1.

\

The messageEngine will look SNMP engine looks into the scopedPDU to determine the
contextEngineID, then determine which orangelet application has registered to
support that contextEngineID, and forwards the request or notification
to the registered Orangelet application using the
process_pdu() processPdu primitive:

process_pdu( contextEngineID, contextName, pdu, LoS, scopedPdu-MMS,
	securityModel, MIID, state-reference

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 the Response PDU
    securityModel               -- Security Model in use
    securityName                -- on behalf of this principal
    LoS                         -- Level of Security
    stateReference              -- reference to state information
    )

7.2.6.                           -- needed when sending a response

A.2.6. Generate a Response Message for an Orangelet Application

The messageEngine will receive SNMP engine receives a request for the generation of an SNMP
response message from an orangelet application via the return_pdu returnResponsePdu
primitive:

return_pdu( contextEngineID, contextName, LoS, MIID, state_reference,
	PDU, PDU-MMS, status_code

returnResponsePdu(
    contextEngineID             -- data from/at this SNMP engine
    contextName                 -- data from/in this context
    PDU                         -- SNMP Protocol Data Unit
    maxSizeResponseScopedPDU    -- maximum size of the Response PDU
    securityModel               -- Security Model in use
    securityName                -- on behalf of this principal
    LoS                         -- Level of Security
    stateReference              -- reference to state information
                                -- as presented with the request
    statusInformation           -- success or errorIndication
    )                           -- error counter OID/value if error

The messageEngine will generate SNMP engine generates the message according to the process
described in 7.2.2.

7.3. Orangelet Model A.2.2.

A.3. Application Design Requirements

Within an Orangelet model, application, there may be an explicit binding to a specific
SNMP message version, i.e. a specific Message Processing and Control model, Model, and to
a specific Access Control model, Model, but there should be no reference to
any data defined by a specific Message Processing and Control model Model or Access
Control model. Model.

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

\

An Orangelet application determines whether explicit or implicit access control
should be applied to the operation, and, if access control is needed,
which Access Control model Model should be used.

An orangelet application has the responsibility to define any MIB modules used
to provide orangelet-specific application-specific services.

Orangelets

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

7.3.1. Orangelets

A.3.1. Applications that Initiate Messages

Orangelets

Applications may request that the messageEngine SNMP engine send messages containing
SNMP
polling requests commands or notifications using the send_pdu() sendPdu primitive:

send_pdu( transportDomain, transportAddress, snmpVersion,
    LoS, securityModel, MIID, contextEngineID,
    contextName, PDU,

[DBH: I rearranged these parameters into groups

sendPdu(
    transportDomain             -- transport domain to be used
    transportAddress            -- destination network address
    messageProcessingModel      -- typically, SNMP version
    securityModel               -- Security Model to use
    securityName                -- on behalf of related data organized
roughly by order this principal
    LoS                         -- Level of locality - transport/engine/contextEngine/PDU.] Security requested
    contextEngineID             -- data from/at this entity
    contextName                 -- data from/in this context
    PDU                         -- SNMP Protocol Data Unit
    expectResponse              -- TRUE or FALSE
    )

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

The messageEngine SNMP engine assumes necessary access control has been applied
to the PDU, and provides no access control services.
The messageEngine SNMP engine looks at the verb, "expectResponse" parameter, and for
operations which will elicit a response, the msgID and the associated orangelet
application are cached.

7.3.2. Orangelets

A.3.2. Applications that Receive Responses

The messageEngine SNMP engine matches the msgID of an incoming response to the
cached msgIDs of messages sent by this messageEngine, SNMP engine, and forwards the
response to the associated Orangelet application using the process_pdu() processResponsePdu
primitive:

process_pdu( contextEngineID, contextName, pdu, LoS, scopedPdu-MMS,
	securityModel, MIID, state-reference )

DBH: should the MPC release the state_reference when it receives a response?
There isn't much reason to force the orangelet to handle

processResponsePdu(             -- process Response PDU
    contextEngineID             -- data from/at this if the MPC
already knows it is a response message, i.e. the end SNMP entity
    contextName                 -- data from/in this context
    PDU                         -- SNMP Protocol Data Unit
    LoS                         -- Level of a transaction.

7.3.3. Orangelets 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 a messageEngine an SNMP engine receives a message that is not the response to a
request from this messageEngine, SNMP engine, it must determine to which Orangelet application
the message should be given.

An Orangelet Application that wishes to receive asynchronous messages registers
itself with the messageEngine engine using the registration primitive.
An Orangelet Application that wishes to stop receiving asynchronous messages
should un-register unregister itself with the messageEngine.

register_contextEngineID ( SNMP engine.

statusInformation =             -- success or errorIndication
    registerContextEngineID(
        contextEngineID         -- take responsibility for this one
        pduType                 -- the pduType(s) to be registered
        )
unregister_contextEngineID (

unregisterContextEngineID(
        contextEngineID         -- give up responsibility for this one
        pduType                 -- the pduType(s) to be unregistered
        )

Only one registration per PDU type per contextEngineID is permitted
at the same time. Duplicate registrations are ignored.

[DBH: there is no provision for an error for this. Is An
errorIndication will be returned to the second
just ignored?] application that attempts
to duplicate a registration.

All asynchronously received messages referencing containing a registered
PDU type and contextEngineID
will be are sent to the orangelet application which
registered to support that contextEngineID.
This includes incoming requests, incoming notifications, and proxies.

It combination.

The engine forwards the PDU to the registered Orangelet, application, using the process_pdu()
processPdu primitive:

process_pdu( contextEngineID, contextName, PDU, PDU-MMS,
    LoS, securityModel, MIID, state_reference

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 the Response PDU
    securityModel               -- Security Model in use
    securityName                -- on behalf of this principal
    LoS                         -- Level of Security
    stateReference              -- reference to state information
    )

7.3.4. Orangelets                           -- needed when sending a response

A.3.4. Applications that Send Responses

\

Request operations require responses. These operations include Get
requests,
set Set requests, and inform Inform requests.  An Orangelet application sends a
response via the
return_pdu primitive:

return_pdu( contextEngineID, contextName, LoS, MIID, state_reference,
	PDU, PDU-MMS, status_code 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 the Response PDU
    securityModel               -- on behalf of this principal
    securityName                -- on behalf of this principal
    LoS                         -- Level of Security
    stateReference              -- reference to state information
                                -- as presented with the request
    statusInformation           -- success or errorIndication
    )                           -- error counter OID/value if error

The contextEngineID, contextName, securityModel, securityName, LoS, 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.

The following primitive is used to invoke the access control service:

statusInformation =             -- success or errorIndication
    isAccessAllowed(
        securityModel           -- Security Model in use
        securityName            -- principal who wants to access
        LoS                     -- Level of Security
        viewType                -- read, write, or notify view
        contextName             -- context containing variableName
        variableName            -- OID for the managed object
        )

\

APPENDIX B

B. An Evolutionary Architecture - Design Goals

The contextEngineID, contextName, LoS, MIID, and state_reference parameters
are from goals of the initial process_pdu() primitive. The PDU and status_code architectural design are to use encapsulation,
cohesion, hierarchical rules, and loose coupling to reduce complexity
of design and make the results evolution of portions of processing.

DBH: in the v2adv approach, a handle was passed so architecture
possible.

B.1. Encapsulation

Encapsulation describes the messageEngine
could match practice of hiding the response details that are
used internal to the incoming request. How a process. Some data is it done now?

7.4. Access Control Model Design Requirements

An Access Control model must determine whether required for a given
procedure, but isn't needed by any other part of the specified
MIID is allowed to perform process.

In networking, the requested operation on concept of a specified managed object. layered stack reflects this approach.
The Access Control model specifies transport layer contains data specific to its processing; the
rules by which access control data
is determined.

A model may define mechanisms not visible to provide additional the other layers. In programming this is reflected
in language elements such as "file static" variables in C, and
"private" in C++, etc.

In this architecture, all data used for processing
features, but only within
a functional portion of the architecture should have its visibility
restricted to that portion if possible. The data should be accessed
only by that functionality defined with the data. No reference to the
data should be made from outside the functional portion of the
architecture, except through predefined public interfaces.

B.2. Cohesion

Similar functions can be grouped together and their differences
ignored, so they can be dealt with as a single entity. It is constrained to using important
that the functions which are grouped together are actually similar.
Similarity of the abstract data elements
defined in this document for transferring data between subsystems.

The persistent data used for access control should to perform functions can be manageable
using SNMP, but a good
indicator of the Access Control model defines whether an
instantiation similarity of the MIB is a conformance requirement.

8. Security Consideration

This document describes how a framework can use a Security model functions.

For example, authentication and encryption are both security functions
which are applied to a Local Processing model message. Access control, while similar in some
ways, is dissimilar in that it is not applied to achieve a level of security message, it is
applied to a (proposed) request for
network a management messages operation.
The data required to perform authentication and controlled access encryption are
different than the data needed to data.

The level perform access control, and the
two sets of services can be described independently.

Similar functions, especially those that use the same data elements,
should be defined together. The security provided is determined by functions which operate at
the specific Security
model implementation(s) and message level should be defined in a document together with the specific Local Processing model
implementation(s) incorporated into this framework.

Orangelets have access to
definitions for those data which elements that are used only by those
security functions. For example, a MIB with authentication keys is not secured. Orangelets
used only by authentication functions; they should take reasonable steps to protect be defined together.

\

B.3. Hierarchical Rules

Functionality can be grouped into hierarchies where each element in the data
hierarchy receives general characteristics from disclosure.

It is the responsibility of the purchaser of a management framework
implementation its direct superior,
and passes on those characteristics to ensure that:
  1) an implementation each of this framework is fully compliant with its direct subordinates.

This architecture uses the rules defined hierarchical approach by this architecture,
  2) the implementation of the Security model complies with defining
subsystems, which specify the general rules of the Security model,
  3) the implementation a portion of the Local Processing model complies
      with system,
models which define the specific rules of the Local Processing model,
  4) the to be followed by an
implementation of associated orangelets comply
      with the rules of this framework relative to orangelets,
  5) the Security model portion of the implementation(s) incorporated system, and implementations which
encode those rules into
      the framework satisfy the security needs of the organization,
  6) the Local Processing model reality for a portion of the implementation(s) incorporated
      into the framework satisfy the access control policies system.

Within portions of the
      organization,
  7) system, hierarchical relationships are used to
compartmentalize, or modularize, the implementation of specific
functionality. For example, within the Security model protects against
      inadvertently revealing security secrets in its design of
      implementation-specific data structures,
  8) the implementation of the Local Processing model protects against
      inadvertently revealing configuration secrets in its design of
      implementation-specific data structures,
  9) and implementation portion of the orangelets protect security and
      access control configuration secrets from disclosure.

9. Glossary

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, system,
authentication and J. Davin, The Simple
    Network Management Protocol", RFC 1157, University of Tennessee
    at Knoxville, Performance Systems International, Performance
    International, privacy may be contained in separate modules, and the MIT Laboratory for Computer
    Science, May 1990.

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

[RFC1445] Galvin, J., privacy mechanisms may be supported by
allowing supplemental modules that provide protocol-specific
authentication and McCloghrie, K., "Administrative Model for
    version 2 of privacy services.

B.4. Coupling

Coupling describes the Simple Network Management Protocol (SNMPv2)",
    RFC 1445, Trusted Information Systems, Hughes LAN Systems,
    April 1993.

[RFC1901] The SNMPv2 Working Group, Case, J., McCloghrie, K.,
    Rose, M., and S., Waldbusser, "Introduction amount of interdependence between parts of
a system. Loose coupling indicates that two sub-systems are relatively
independent of each other; tight coupling indicates a high degree of
mutual dependence.

To make it possible to
    Community-based SNMPv2", RFC 1901, January 1996.

[RFC1902] The SNMPv2 Working Group, Case, J., McCloghrie, K.,
    Rose, M., and S., Waldbusser, "Structure evolve the architecture by replacing only part
of Management
    Information the system, or by supplementing existing portions with alternate
mechanisms for Version  2 similar functionality, without obsoleting the complete
system, it is necessary to limit the coupling of the Simple Network Management
    Protocol (SNMPv2)", RFC 1905, January 1996.

[RFC1903] The SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., parts.

Encapsulation and S. Waldbusser, "Textual Conventions for Version 2 cohesion help to reduce coupling by limiting the
visibility of those parts that are only needed within portions of a
system. Another mechanism is to constrain 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 nature of interactions
between various parts 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 system.

This can be done by defining fixed, generic, flexible interfaces
for
    Version 2 transferring data between the parts of the Simple Network Management Protocol (SNMPv2)",
    RFC 1905, January 1996.

[RFC1906] system. The SNMPv2 Working Group, Case, J., McCloghrie, K.,
    Rose, M., and S. Waldbusser, "Transport Mappings for
    Version 2 concept of
plug-and-play hardware components is based on that type of interface
between the Simple Network Management Protocol (SNMPv2)",
    RFC 1906, January 1996.

[RFC1907] The SNMPv2 Working Group, Case, J., McCloghrie, K.,
    Rose, M., hardware component and S. Waldbusser, "Management Information Base system into which it is "plugged."

This approach has been chosen so individual portions of the system
can be upgraded over time, while keeping the overall system intact.

To avoid specifying fixed interfaces, which would constrain a vendor's
choice of implementation strategies, a set of abstract data elements
is used for
    Version 2 (conceptually) transferring data between subsystems in
documents which describe subsystem or model interactions. Documents
describing the interaction of subsystems or models should use only
the Simple Network Management Protocol (SNMPv2)",
    RFC 1907 January 1996.

[RFC1908] The SNMPv2 Working Group, Case, J., McCloghrie, K.,
    Rose, M., and S. Waldbusser, "Coexistence abstract data elements provided for transferring data but vendors

\

are not constrained to using the described data elements for
transferring data between Version 1 portions of their implementation.

Loose coupling works well with the IETF standards process. If we
separate message-handling from security and Version 2 from local processing,
then the separate portions 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

11. 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-412-498

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

12. Acknowledgements

This document builds system can move through the standards
process with less dependence on the work status of the SNMP other portions of the
standard. Security and
Administrative Framework Evolution team, comprised models may be able to be re-opened for discussion
due to patents, new research, export laws, etc., as is clearly expected
by the WG, without needing to reopen the documents which detail the
message format or the local processing of

     David Harrington (Cabletron Systems Inc.)
     Jeff Johnson (Cisco)
     David Levi (SNMP Research Inc.)
     John Linn (Openvision)
     Russ Mundy (Trusted Information Systems) chair
     Shawn Routhier (Epilogue)
     Glenn Waters (Nortel)
     Bert Wijnen (IBM T.J. Watson Research) PDUs. Thus, the standards
track status of related, but independent, documents is not affected.

\

Table of Contents

0. Issues                                                              3                                                             2
0.1. Issues to be resolved                                            3                                            2
0.1.1. Issues discussed at second Interim Meeting:                    2
0.2.  Change Log                                                      3
1. Introduction                                                        5
1.1. A Note on Terminology                                             5
2. Overview                                                            6
3. An Evolutionary Architecture - Design Goals                                                       7
3.1. Encapsulation
1.1. Target Audience                                                  7
3.2. Cohesion
1.2. Management Systems                                               7
3.3. Hierarchical Rules                                                8
3.4. Coupling
1.3. Goals of this Architecture                                       8
4. Abstract Functionality                                             10
4.1. The messageEngine
1.4. Security Requirements of this Architecture                       9
1.5. Design Decisions                                                10
4.1.1.
2.  Documentation Overview                                           12
2.1. Document Roadmap                                                13
2.2. Applicability Statement                                         13
2.3. Coexistence and Transition                                      13
2.4. Transport Mappings                                             10
4.1.2. SNMP-Based                                              14
2.5. Message Formats                                     10
4.1.3. The Interface to Orangelets                                    11
4.1.4.  Protocol Instrumentation                                      11
4.2. Processing                                              14
2.6. Security                                                         11
4.3. Orangelets                                                       11
4.4.1.                                                        14
2.7. Access Control                                                  14
2.8. Applications                                                    15
2.9. Structure of Management Information                           12
4.4.2.                             15
2.10. Textual Conventions                                           12
4.4.3.                                            15
2.11. Conformance Statements                                        12
4.4.4.                                         15
2.12. Protocol Operations                                           12
4.5.                                            16
2.13. Management Information Base Modules                            16
2.13.1. SNMP Instrumentation MIBs                                    16
2.14. SNMP Framework Documents                                       16
3. Naming                                                            18
3.1. The Naming of Entities                                          18
3.1.1. SNMP entity                                                   19
3.1.2. SNMP engine                                                   19
3.1.3. snmpEngineID                                                  19
3.1.4. Message Processing Subsystem                                  19
3.1.5. Message Processing Model                                      19
3.1.6. Security Subsystem                                            20
3.1.7. Security Model                                                20
3.1.8. Security Protocol                                             20
3.1.9. Access Control Subsystem                                      21
3.1.10. Access Control                                                   13
4.6. Coexistence                                                      13
5. Abstract Data Elements of the Architecture                         14
5.1. engineID                                                         14
5.2. SecurityIdentity                                                 14
5.3. Model Independent Identifier (MIID)                              14
5.4. Level                                         21
3.1.11. Applications                                                 21
3.1.12. SNMP Agent                                                   21
3.1.13. SNMP Manager                                                 21
3.2. The Naming of Security                                                14
5.5. Contexts                                                         15
5.6. ContextName                                                      15
5.7. ContextEngineID                                                  15
5.8. Identities                                        22
3.2.1. Principal                                                     22
3.2.2. securityName                                                  22
3.2.3. Model dependent security ID                                   22
3.3. The Naming Scope                                                     15
5.9. Scoped-PDU                                                       15
5.10. PDU-MMS                                                         15
5.11. Local Configuration Datastore                                   15
5.11.1. Security Portion of the Management Information                            23
3.3.1. An SNMP Context                                               24
3.3.2. contextEngineID                                               24
3.3.3. contextName                                                   24
3.3.4. scopedPDU                                                     24
3.4. Other Constructs                                                25

\^L

3.4.1. maxSizeResponseScopedPDU                                      25
3.4.2. Local Configuration Datastore         16
5.11.2. Orangelet Portion                                 25
3.4.3. LoS                                                           25
4. Architectural Elements of Procedure                               26
4.1.  Operational Overview                                           27
4.2. Sending and Receiving SNMP Messages                             29
4.2.1. Send a Message to the Local Configuration Datastore        16
5.11.3. Access Control Portion of Network                                 29
4.2.2. Receive a Message from the Local Configuration Datastore   16
5.12. Groups                                                          16
6. Network                            29
4.3. Send a Request or Notification Message for an Application       30
4.4. Receive a Request or Notification Message from the Network      30
4.5. Generate a Response Message for an Application                  31
4.6. Receive a Response Message                                      31
4.7. Registering to Receive Asynchronous Messages                    31
5. Definition of Managed Objects for Internet Management Frameworks   17  33
6. Security Considerations                                           39
7. Glossary                                                          40
8. References                                                        40
9. Editor's Addresses                                                42
10. Acknowledgements                                                 43
A. Guidelines for Model Design Requirements                                          24
7.1. Designers                                    44
A.1. Security Model Design Requirements                               24
7.1.1.                              44
A.1.1. Threats                                                        24
7.1.2.                                                       44
A.1.2. Security Processing                                            25
7.1.3.                                           45
A.1.3. validate the security-stamp in a received message              26
7.1.4. Security Identity                                              27
7.1.5. Model Dependent Identifier                                     27
7.1.6. Model Independent Identifier                                   27
7.1.5.             45
A.1.5. Security MIBs                                                  28
7.1.6.                                                 46
A.1.6. Security State Cacheing                                        28
7.2. MessageEngine Cache                                          46
A.2. SNMP engine and Message Processing and Control Model Requirements 28
7.2.1.           48
A.2.1. Receiving an SNMP Message from the Network                     29
7.2.2.                    48
A.2.2. Send SNMP messages to the network                              29
7.2.3.                             49
A.2.3. Generate a Request or Notification Message for an Orangelet    30
7.2.4. Forward Application   49
A.2.4. Pass Received Response Message to an Orangelet              30
7.2.5. Forward Application              50
A.2.5. Pass Received Request or Notification Message to an Orangelet 30
7.2.6. Application  50
A.2.6. Generate a Response Message for an Orangelet                   31
7.3. Orangelet Model Application                51
A.3. Application Design Requirements                              31
7.3.1. Orangelets                                 51
A.3.1. Applications that Initiate Messages                              31
7.3.2. Orangelets                           52
A.3.2. Applications that Receive Responses                              32
7.3.3. Orangelets                           52
A.3.3. Applications that Receive Asynchronous Messages                  32
7.3.4. Orangelets               53
A.3.4. Applications that Send Responses                                 32
7.4.                              53
A.4. Access Control Model Design Requirements                         33
8. Security Consideration                                             34
9. Glossary                                                           35
10. References                                                        36
11. Editor's Addresses                                                38
12. Acknowledgements                                                  39                        54