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 an SNMP engine containing a Message Processing subsystem, a Security Subsystem and an Access Control Subsystem, and possibly multiple SNMP applications which provide specific functional processing of network management data. These SNMP applications are of various types, including Command Generator and Command Responder applications, Notification Originator and Notification Receiver applications, and Proxy Forwarding applications. Harrington/Wijnen Expires December 1997 [Page 1] \ Draft Architecture for Internet Management Frameworks July 1997 0. Issues 0.1. Issues to be resolved . OID or Integer for auth/priv protocol identifiers second interim meeting reached consensus on OIDs some mailing list members still say Integers preferred . forward references need to be handled . Is Glossary needed to describe primitive parameters, or is the expanded template adequate for this purpose? . state_reference releases - are these consistently defined? check documents. . discuss utf8. - probably open WG discussion in Munich per NMAD discuss tomorrow; remains open issue. . need mechanism to discover securityModels supported . new SnmpEngineID format rules to be discussed yet. . 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 value!! 0.1.1. Issues discussed at second Interim Meeting: . A "readable" introduction supplement may be done after Munich. . Applications are responsible for retries, but implementations may differ. . TCs should not be defined just to describe primitive parameters. If they cannot be described adequately in text, they can be defined in a Glossary. Avoid describing implementation details. . Is SnmpAdminString appropriate for all strings, such as securityIdentifier and context and group? These had different sizes and semantics. size and semantics may be defined in syntax and description of OBJECT . AdminString has size (0..255); revisit for utf8 discussions . securityModel #s - 00 for IETF standards; from v2* documents . protocol IDs - integer or OID? voted 13-0 for OID. . uniqueness of securityName . mapping between principal and securityName is outside scope of WG. . principals may have more than one securityName in an entity . mappings may exist between many types of MDID and a single securityName . mappings may exist between different (model, Name) and the same securityName by varying the model or the Name. . the securityName and a MDID may be identical. This can be defined by the Security Model. (user,"public") may map to securityName "public" . [securityName, securityModel] yields zero or one MDName, with exceptions for backwards compatibility. The exception is defined by the model, and the problems are the province of the model to resolve. Harrington/Wijnen Expires December 1997 [Page 2] \ Draft Architecture for Internet Management Frameworks July 1997 0.2. Change Log [version 4.4] . Fixed one error in the MIB (found with SMICng) . Reformatted text for SnmpAdminString, no change in text. . Changed text for SnmpEngineID.. this is still under discussion. But this new text seems to be getting close to what we want. . Added an issue w.r.t. snmpEngineMaxMessageSize . adapt Primitive names and parameters to very latest (july 11) names . removed blank lines before the .p page controls. [version 4.3] . some minor editing adjustments [version 4.2] . modify abstract so there is no requirement for one entity to contain both a command generator and a notification receiver. . modify Introduction list of entities which are meant to be supported . reorganized sections 1 through 4 for more consistency in contents. . described section contents in Introduction:Target Audience . move documentation descriptions to section 2 . rewrite section 4 to be more like a real elements of procedure. . modified SnmpSecurityModel and SnmpEngineID definitions . replaced MIB with Bert's replacement . added Randy's TC for SnmpAdminString . modified the example algorithm text for SnmpEngineID . rewrote security considerations for brevity. . modified "context" description . moved "Threats" to Goals/Requirements . eliminated snmpEngineMaxMessageSize object . posted to snmpv3 (by DBH) [version 4.1] . Adopt "abstract" to new terminology . Addressed all comments I (BW) made to DBH in an earlier email . Changed Introduction section to new terminology . changed wording for "implementation" to indicate it may contain multiple models. . Section 2. Started some wording on Goals and Design decisions . Added the overview picture of a traditional agent and a traditional manager. This is in section 2. . Changed overview figure in section 3. to address the comments by Dave Levi. It now lists the type of applications . At various places ensure that text (easily) fits within 72 columns as required by RFC-editors Guidelines document. . Section 2.3 (new section) has the documents set overview. I verified the claims about standards. Not sure I worded the SNMPv2 std correctly,. We'll hear it if we did it wrong. . Section 2.4 (new section) gives overview of SNMP entities based on modified Dave Levi figure. I (Bert) wonder however if it would Harrington/Wijnen Expires December 1997 [Page 3] \ Draft Architecture for Internet Management Frameworks July 1997 not be better to move it to after section 3.1.13 . Section 3. Added more figures... please let us know if you find then useful and/or helpful. We could also move these back to section 2 if such makes more sense. . Added a picture in section 3.2. It also shows some of access control, so not sure it really fits here, although it does map principal to model dependent security ID to securityName . Replace "<" with "is lower than" in section 3.4.3 which seems better in a text document. . Renamed section 4.1 to "SNMP engine processing" instead of "The Message Processing Subsystem" because the transport mappings, mpc multiplexor and such is done in ARCH document so it is done "in general in the engine" and it passes a specific message to a Message Processing Subsystem. . "bulletized" some stuff in section 4.2 and 4.3. Dave, this is just how I (Bert) like it better. Feel free to undo it if you strongly disagree . Section 4.3 changed "initiate a transaction" to "originate a notification". . Inserted title line for section 4.4 (I think it was missing) I have named it "Information Model" in accordance with the change I made (after Russ's comments) in the document figure to lump SMI, TC and Conformance together. . Inserted a title for section 4.5 named "Operational Model" to get in sync with the the lumping together of ProtoOps and Transport Mappings in document overview . Renumber section 4.4.4 to 4,5,1 and added 4.5.2 to follow the document overview figure. If we really want to follow it, then maybe we should also reorder some of these sections. Like Access Control seems specifically misplaced. So I decided to move it before applications as section 4.3, so the 4.x above should all be read as 4.x+1 . Removed size from SnmpEngineID TC... why did you limit it to (0..2048). Did we not decide to leave it open? . Should we not remove snmpEngineMaxMessageSize from the MIB. That was agreed at 2nd interim. It travels in every message and so seems to be useless. However, I think it could indeed still help SNMPv1 or SNMPv2c managers. . I kept your definitions of registration-points for auth and priv protocols, but my recollection is that they would be completely removed from ARCH and that it would all be done in SEC document. . Modified Security Considerations. Was still talking about LPM. . Appendix. I am still wondering if we need to use capitals for things like "Security Model" "Subsystem" and such. This is only an appendix... but we better be consistent, no? Anyway I changed it so it is consistent (at least I tried). . Appendix, renamed imf to snmpFramework . Appendix, changed state_reference and state_release to stateReference and stateRelease to be consistent with other names for abstract data and primitives. Harrington/Wijnen Expires December 1997 [Page 4] \ Draft Architecture for Internet Management Frameworks July 1997 . A.2 changed MessageEngine to SNMP engine . Fixed ASI primitives to be in sync with SEC document. I also thought that our ARCH document-outline wanted to at least have the primitives listed within the main body of the text, no? . Adapted send_pdu to sendPdu primitive as reconciled by Randy In fact I made sure all primitives are in-line with current agreement on names and parameters. . Rename title of A.2.4 and A.2.5 so it fits on 1 line in contents . I did not look at appendix B. That is your (DBH) specialty is it not ? ;-). . Quick simple spell check done with "spell" on AIX [version 4.0] . move section 7 - Model Requirements to an appendix . move Section 3 - Design Goals to an appendix . modified Section 5 - Naming . remove "possibly multiple" . moved Section 5 to Section 3 . change orangelets to applications . modify description of applications . change scopedPDU-MMS and PDU-MMS to maxSizeResponseScopedPDU . change Scoped-PDU and ScopedPDU to scopedPDU (no dash, lower case S) . change imfxxx to snmpFrameworkxxx . change security-entity to principal . change securityIdentity to securityName . change MIID to securityName . eliminate all reference to groupName or group . LoS ordering noAuthNoPriv < authNoPriv < authPriv . Los TC naming - noAuthNoPriv(1), authNoPriv(2), authPriv(3) . remove TCs not used in MIBs - securityIdentity TC etc . changed Message Processing and Control to Message Processing . changed future tense to present tense . eliminate messageEngine . added/updated primitives . addressed issues raised on the mailing list [version 3.1] . change securityIdentity to MIID . write text to explain the differences between security-identities, model-dependent identifiers, and model-independent identifiers. . write text to explain distinction within the LCD of the security data, the access control data, and the orangelet data. . identify issues . publish as [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 1997 [Page 5] \ Draft Architecture for Internet Management Frameworks July 1997 . change securityCookie to securityIdentity . the format of securityIdentity is defined by the model . add securityModel to passed parameters as needed . eliminate group from passed parameters . remove unused IMPORTS . add glossary section with initial set of words to define . differentiate the 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 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] \ Draft Architecture for Internet Management Frameworks July 1997 1. Introduction 1.1. Target Audience This document will have as its audience persons with varying levels of technical understanding of SNMP. This document does not provide a general introduction to SNMP. Other documents and books can provide a much better introduction to SNMP. Nor does this document provide a history of SNMP. That also can be found in books and other documents. This document does define a vocabulary for describing Internet Management Frameworks, and an architecture for describing the major portions of Internet Management Frameworks. Section 1 describes the purpose, goals, and design decisions of the architecture. Section 2 describes various types of documents which define Internet Frameworks, and how they fit into this architecture. It also provides a minimal roadmap to the documents which have defined previous SNMP frameworks. Section 3 details the vocabulary of this architecture and its pieces. This section is important for understanding the remaining sections, and for understanding documents which are written to fit within this architecture. Section 4 describes the elements of procedure followed by an SNMP engine in coordinating the processing of messages by the subsystems of the engine and by applications. Section 5 defines a collection of managed objects used to instrument SNMP engines within this architecture. Sections 6, 7, 8, and 9 are administrative in nature. Appendix A contains guidelines for developers of Models which are expected to fit within this architecture. Appendix B contains a discussion of software design principles which guided the development of this architecture. Many books provide a more in-depth discussion of these topics. 1.2. Management Systems A management system contains: - several (potentially many) nodes, each with an SNMP entity containing command responder and notification originator applications, which have access to management instrumentation; Harrington/Wijnen Expires December 1997 [Page 7] \ Draft Architecture for Internet Management Frameworks July 1997 - at least one SNMP entity containing command generator and/or notification receiver applications; and, - a management protocol, used to convey management information between the SNMP entities. SNMP entities executing command generator and notification receiver applications monitor and control managed elements. Managed elements are devices such as hosts, routers, terminal servers, etc., which are monitored and controlled via access to their management information. Operations of the protocol are carried out under an administrative 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 processing various types of requests. It is 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 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 types of applications for 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 following goals: - Use existing materials as much as possible. It is heavily based on previous work, informally known as SNMPv2u and SNMPv2*. - Address the need for secure SET support, which is considered the most important deficiency in SNMPv1 and SNMPv2c. - Make it possible to move portions of the architecture forward in the standards track, even if consensus has not been reached on all pieces. - Define an architecture that allows for longevity of the SNMP Frameworks that have been and will be defined. Harrington/Wijnen Expires December 1997 [Page 8] \ Draft Architecture for Internet Management Frameworks July 1997 - Keep SNMP as simple as possible. - Make it relatively inexpensive to deploy a minimal conformant implementation - Make it possible to upgrade portions of a framework as new approaches become available, without disrupting the entire framework. - Make it possible to support features required in large networks, but make the expense of supporting a feature directly related to the support of the feature. 1.4. Security Requirements of this Architecture Several of the classical threats to network protocols are applicable to the network management problem and therefore would be applicable to any Security Model used in an Internet Management Framework. Other threats are not applicable to the network management problem. This section discusses principal threats, secondary threats, and threats which are of lesser importance. The principal threats against which any Security Model used within this architecture SHOULD provide protection are: Modification of Information The modification threat is the danger that some unauthorized SNMP entity may alter in-transit SNMP messages generated on behalf of an authorized principal in such a way as to effect unauthorized management operations, including falsifying the value of an object. Masquerade The masquerade threat is the danger that management operations not authorized for some principal may be attempted by assuming the identity of another principal that has the appropriate authorizations. Message Stream Modification The SNMP protocol is typically based upon a connectionless transport service which may operate over any subnetwork service. The re-ordering, delay or replay of messages can and does occur through the natural operation of many such subnetwork services. The message stream modification threat is the danger that messages may be maliciously re-ordered, delayed or replayed to an extent which is greater than can occur through the natural operation of a subnetwork service, in order to effect unauthorized management operations. Disclosure The disclosure threat is the danger of eavesdropping on the exchanges between SNMP engines. Protecting against this threat may be required as a matter of local policy. Harrington/Wijnen Expires December 1997 [Page 9] \ Draft Architecture for Internet Management Frameworks July 1997 There are at least two threats against which a Security Model used by a framework within this architecture need not protect. Denial of Service A Security Model need not attempt to address the broad range of attacks by which service on behalf of authorized users is denied. Indeed, such denial-of-service attacks are in many cases indistinguishable from the type of network failures with which any viable network management protocol must cope as a matter of course. Traffic Analysis A Security Model need not attempt to address traffic analysis attacks. Many traffic patterns are predictable - entities may be managed on a regular basis by a relatively small number of management stations - and therefore there is no significant advantage afforded by protecting against traffic analysis. 1.5. Design Decisions Various designs decision were made in support of these goals: - Architecture An architecture should be defined which identifies the conceptual boundaries between the documents of a framework. Subsystems should be defined which describe the abstract services provided by specific portions of the framework. Abstract service interfaces, as described by service primitives, define the abstract boundaries between documents, and the abstract services that are provided by the conceptual subsystems of a framework. - Self-contained Documents Elements of procedure plus the MIB objects which are needed for processing for a specific portion of a framework should be defined in the same document, and as much as possible, should not be referenced in other documents. This allows various pieces of SNMP Frameworks to be designed and documented as independent and self-contained parts, which is consistent with the general SNMP MIB module approach. As portions of SNMP change over time, the documents describing other portions of the framework are not directly impacted. This modularity allows, for example, Security Models, authentication and privacy mechanisms, and message formats to be upgraded and supplemented as the need arises. The self-contained documents can move along the standards track on different time-lines. - Remote Configuration The Security and Access Control Subsystems add a whole new set of SNMP configuration parameters. The Security Subsystem also requires frequent changes of secrets at the various SNMP entities. To make this deployable in a large operational Harrington/Wijnen Expires December 1997 [Page 10] \ Draft Architecture for Internet Management Frameworks July 1997 environment, these SNMP parameters must be able to be remotely configured. - Controlled Complexity It is recognized that simple managed devices want to keep the resources used by SNMP to a minimum. At the same time, there is a need for more complex configurations which can spend more resources for SNMP and thus provide more functionality. The design tries to keep the competing requirements of these two environments in balance and allows the more complex environments to logically extend the simple environment. Harrington/Wijnen Expires December 1997 [Page 11] \ Draft Architecture for Internet Management Frameworks July 1997 2. Documentation Overview The following figure shows the set of documents that fit within the SNMP Architecture. Document Set +--------------------------------------------------------------------+ | | | +------------+ +-----------------+ +----------------+ | | | * | | * | | * | | | | Document | | Applicability | | Coexistence | | | | Roadmap | | Statement | | & Transition | | | +------------+ +-----------------+ +----------------+ | | | | +-------------------+ +-----------------------------------------+ | | | Operational Model | | Security and Administration | | | | | | | | | | +-------------+ | | +------------+ +----------+ +---------+ | | | | | | | | | | | | | | | | | | | Protocol | | | | Message | | Security | | Access | | | | | | Operations | | | | Processing | | | | Control | | | | | +-------------+ | | +------------+ +----------+ +---------+ | | | | +-------------+ | | | | | | | | | | +--------------+ +----------+ | | | | | Transport | | | | | | | | | | | | Mappings | | | | Applications | ......... | | | | | | +-------------+ | | +--------------+ +----------+ | | | | | | | | | +-------------------+ +-----------------------------------------+ | | | | +----------------------------------------------------------------+ | | | Information Model | | | | | | | | +--------------+ +--------------+ +---------------+ | | | | | Structure of | | Textual | | Conformance | | | | | | Management | | Conventions | | Statements | | | | | | Information | | | | | | | | | +--------------+ +--------------+ +---------------+ | | | +----------------------------------------------------------------+ | | | | +----------------------------------------------------------------+ | | | MIBs | | | | | | | | +-------------+ +-------------+ +----------+ +----------+ | | | | | Standard v1 | | Standard v1 | | Historic | | Draft v2 | | | | | | RFC1157 | | RFC1212 | | RFC14xx | | RFC19xx | | | | | | format | | format | | format | | format | | | | | +-------------+ +-------------+ +----------+ +----------+ | | | +----------------------------------------------------------------+ | | | +--------------------------------------------------------------------+ Harrington/Wijnen Expires December 1997 [Page 12] \ Draft Architecture for Internet Management Frameworks July 1997 Those marked with an asterisk (*) are expected to be written in the future. Each of these documents may be replaced or supplemented. This Architecture document specifically describes how new documents fit into the set of documents in the Security and Administration area. 2.1. Document Roadmap One or more documents may be written that will describe how sets of documents taken together form a specific SNMP framework. The configuration of document sets might change over time, so the "roadmap" should be maintained in a document separate from the standards documents themselves. 2.2. Applicability Statement SNMP is used in networks that vary widely in size and complexity, by organizations that vary widely in their requirements of network management. Some models will be designed to address specific problems of network management, such as message security. One or more documents may be written which describe the environments to which certain versions of SNMP or models within SNMP would be appropriately applied, and those to which a given model might be inappropriately applied. 2.3. Coexistence and Transition The purpose of an evolutionary architecture is to permit new models to replace or supplement existing models. The interactions between models could result in incompatibilities, security "holes", and other undesirable effects. The purpose of Coexistence documents is to detail recognized anomalies and to describe required and recommended behaviors for resolving the interactions between models within the architecture. It would be very difficult to document all the possible interactions between a model and all other previously existing models while in the process of developing a new model. Coexistence documents are therefore expected to be prepared separately from model definition documents, to describe and resolve interaction anomalies between a model definition and one or more other model definitions. Additionally, recommendations for transitions between models may also be described, either in a coexistence document or in a separate document. Harrington/Wijnen Expires December 1997 [Page 13] \ Draft Architecture for Internet Management Frameworks July 1997 2.4. Transport Mappings SNMP messages are sent over various transports. It is the purpose of Transport Mapping documents to define how the mapping between SNMP and the transport is done. A specific implementation of an SNMP engine defines which transports it supports. 2.5. Message Processing A Message Processing Model document defines a message format, which is typically identified by a version field in an SNMP message header. The document may also define a MIB module for use in message processing and for instrumentation of version-specific interactions. An engine will include one or more Message Processing Models, and thus may support sending and receiving multiple SNMP versions of messages. 2.6. Security Some environments require secure protocol interactions. Security is normally applied at two different stages: - in the transmission/receipt of messages, and - in the processing of the contents of messages. For purposes of this document, "security" refers to message-level security; "access control" refers to the security applied to protocol operations. Authentication, encryption, and timeliness checking are common functions of message level security. A security document will describe a Security Model, the threats against which the model protects, the goals of the Security Model, the protocols which it uses to meet those goals, and it may define a MIB module to describe the data used during processing, and to allow the remote configuration of message-level security parameters, such as passwords. An SNMP engine may support multiple Security Models concurrently. 2.7. Access Control During processing, it may be required to control access to certain instrumentation for certain operations. An Access Control Model determines whether access to an object should be allowed. The mechanism by which access control is checked is defined by the Access Control Model. An Access Control Model document defines the mechanisms used to Harrington/Wijnen Expires December 1997 [Page 14] \ Draft Architecture for Internet Management Frameworks July 1997 determine whether access to a managed object should be allowed, and may define a MIB module used during processing, and to allow the remote configuration of access control policies. 2.8. Applications An SNMP entity normally includes a number of applications. Applications use the services of an SNMP engine to accomplish specific tasks. They coordinate the processing of management information operations, and may use SNMP messages to communicate with other SNMP entities. Applications documents describe the purpose of an application, the services required of the associated SNMP engine, and the protocol operations and informational model that the application uses to perform network management operations. An application document defines which set of documents are used to specifically define the structure of management information, textual conventions, conformance requirements, and operations supported by the application. 2.9. Structure of Management Information Management information is viewed as a collection of managed objects, residing in a virtual information store, termed the Management Information Base (MIB). Collections of related objects are defined in MIB modules. It is the purpose of a Structure of Management Information document to establish the syntax for defining objects, modules, and other elements of managed information. 2.10. Textual Conventions When designing a MIB module, it is often useful to define new types similar to those defined in the SMI, but with more precise semantics, or which have special semantics associated with them. These newly defined types are termed textual conventions, and may defined in separate documents, or within a MIB module. 2.11. Conformance Statements It may be useful to define the acceptable lower-bounds of implementation, along with the actual level of implementation achieved. It is the purpose of Conformance Statements to define the notation used for these purposes. Harrington/Wijnen Expires December 1997 [Page 15] \ Draft Architecture for Internet Management Frameworks July 1997 2.12. Protocol Operations SNMP messages encapsulate an SNMP Protocol Data Unit (PDU). It is the purpose of a Protocol Operations document to define the operations of the protocol with respect to the processing of the PDUs. An application document defines which Protocol Operations documents are supported by the application. 2.13. Management Information Base Modules MIB documents describe collections of managed objects which instrument some aspect of a managed node. 2.13.1. SNMP Instrumentation MIBs An SNMP MIB document may define a collection of managed objects which instrument the SNMP protocol itself. In addition, MIB modules may be defined within the documents which describe portions of the SNMP architecture, such as the documents for Message processing Models, Security Models, etc. for the purpose of instrumenting those Models, and for the purpose of allowing remote configuration of the Model. 2.14. SNMP Framework Documents This architecture is designed to allow an orderly evolution of portions of SNMP Frameworks. Throughout the rest of this document, the term "subsystem" refers to an abstract and incomplete specification of a portion of a Framework, that is further refined by a model specification. A "model" describes a specific design of a subsystem, defining additional constraints and rules for conformance to the model. A model is sufficiently detailed to make it possible to implement the specification. An "implementation" is an instantiation of a subsystem, conforming to one or more specific models. SNMP version 1 (SNMPv1), is the original Internet-standard Network Management Framework, as described in RFCs 1155, 1157, and 1212. SNMP version 2 (SNMPv2) is an updated design of portions of SNMPv1, as described in RFCs 1902-1908. SNMPv2 has an incomplete message definition. Community-based SNMP version 2 (SNMPv2c) is an experimental Framework which supplements the incomplete message format of SNMPv2 with portions of the message format of SNMPv1, as described in RFC1901. Harrington/Wijnen Expires December 1997 [Page 16] \ Draft Architecture for Internet Management Frameworks July 1997 SNMP version 3 (SNMPv3) Framework is a particular configuration of implemented subsystems, consistent with the architecture described in this document. Other SNMP Frameworks, i.e. other configurations of implemented subsystems, are expected to also be consistent with this architecture. This document does not describe any framework, but describes an architecture into which multiple frameworks may be fitted. Harrington/Wijnen Expires December 1997 [Page 17] \ Draft Architecture for Internet Management Frameworks July 1997 3. Naming This architecture deals with three kinds of naming: 1) the naming of entities, 2) the naming of identities, and 3) the naming of management information. This architecture also defines some names for other constructs that are used in the documentation. 3.1. The Naming of Entities 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 | | | | | | | +-------------+ +--------------+ +--------------+ | | | | | | | +--------------------------------------------------------------+ | | | +--------------------------------------------------------------------+ Harrington/Wijnen Expires December 1997 [Page 18] \ Draft Architecture for Internet Management Frameworks July 1997 3.1.1. SNMP entity An SNMP entity is an implementation of this architecture. Each such SNMP entity consists of an SNMP engine and one or more associated applications. 3.1.2. SNMP engine An SNMP engine has three subsystems: 1) a Message Processing Subsystem, 2) a Security Subsystem, and 3) an Access Control Subsystem. 3.1.3. snmpEngineID Within an administrative domain, an snmpEngineID is the unique and unambiguous identifier of an SNMP engine. Since there is a one-to-one association between SNMP engines and SNMP entities, it also uniquely and unambiguously identifies the SNMP entity. 3.1.4. Message Processing Subsystem The Message Processing Subsystem is responsible for preparing and sending messages, and receiving and distributing messages. The Message Processing Subsystem potentially contains multiple Message Processing Models as shown in the next picture. Those marked with an asterisk (*) may be absent. +------------------------------------------------------------------+ | | | Message Processing Subsystem | | | | +------------+ +------------+ +------------+ +------------+ | | | | | * | | * | | * | | | | 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 and coordinates the processing of each version-specific message. Harrington/Wijnen Expires December 1997 [Page 19] \ Draft Architecture for Internet Management Frameworks July 1997 3.1.6. Security Subsystem The Security Subsystem provides security services such as the authentication and privacy of messages and potentially contains multiple Security Models as shown in the next picture. Those marked with an asterisk (*) may be absent. +------------------------------------------------------------------+ | | | 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 protects, the goals of its services, and the security protocols used to provide security services such as authentication and privacy. 3.1.8. Security Protocol A Security Protocol defines the mechanisms, procedures, and MIB data used to provide a security service such as authentication or privacy. Harrington/Wijnen Expires December 1997 [Page 20] \ Draft Architecture for Internet Management Frameworks July 1997 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 particular access decision function in order to support decisions regarding authorization. 3.1.11. Applications There are several types of applications, which include: - command generator, - command responder, - notification originator, - notification receiver, and - proxy forwarder. These applications make use of the services provided by the Security and Administration Framework. 3.1.12. SNMP Agent An SNMP entity containing one or more command responder and/or notification originator applications (along with their associated SNMP engine) has traditionally been called an SNMP agent. 3.1.13. SNMP Manager An SNMP entity containing one or more command generator and/or notification receiver applications (along with their associated SNMP engine) has traditionally been called an SNMP manager. Harrington/Wijnen Expires December 1997 [Page 21] \ Draft Architecture for Internet Management Frameworks July 1997 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. Harrington/Wijnen Expires December 1997 [Page 22] \ Draft Architecture for Internet Management Frameworks July 1997 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 | | | | | | | | | +------------+ | | | | | | | | | | +--------------------------------------------------------------+ Harrington/Wijnen Expires December 1997 [Page 23] \ Draft Architecture for Internet Management Frameworks July 1997 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 Harrington/Wijnen Expires December 1997 [Page 24] \ Draft Architecture for Internet Management Frameworks July 1997 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. Harrington/Wijnen Expires December 1997 [Page 25] \ Draft Architecture for Internet Management Frameworks July 1997 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. Harrington/Wijnen Expires December 1997 [Page 26] \ Draft Architecture for Internet Management Frameworks July 1997 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 | +------------------------------+ Harrington/Wijnen Expires December 1997 [Page 27] \ Draft Architecture for Internet Management Frameworks July 1997 +------------------------------+ | 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 | +--------------------------------------------------------------------+ Harrington/Wijnen Expires December 1997 [Page 28] \ Draft Architecture for Internet Management Frameworks July 1997 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 Harrington/Wijnen Expires December 1997 [Page 29] \ Draft Architecture for Internet Management Frameworks July 1997 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 Harrington/Wijnen Expires December 1997 [Page 30] \ Draft Architecture for Internet Management Frameworks July 1997 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 Harrington/Wijnen Expires December 1997 [Page 31] \ Draft Architecture for Internet Management Frameworks July 1997 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. Harrington/Wijnen Expires December 1997 [Page 32] \ Draft Architecture for Internet Management Frameworks July 1997 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 Harrington/Wijnen Expires December 1997 [Page 33] \ Draft Architecture for Internet Management Frameworks July 1997 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 Harrington/Wijnen Expires December 1997 [Page 34] \ Draft Architecture for Internet Management Frameworks July 1997 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: Harrington/Wijnen Expires December 1997 [Page 35] \ Draft Architecture for Internet Management Frameworks July 1997 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 ISO/IEC IS 10646-1 character set, encoded as an octet string using the UTF-8 character encoding scheme described in RFC 2044. Since additional code points are added by amendments to the 10646 standard from time to time, implementations must be prepared to encounter any code point from 0x00000000 to 0x7fffffff. The use of control codes should be avoided. For code points not directly supported by user interface hardware or software, an alternative means of entry and display, such as hexadecimal, may be provided. For information encoded in 7-bit US-ASCII, the UTF-8 representation is identical to the US-ASCII encoding. " SYNTAX OCTET STRING (SIZE (0..255)) -- Administrative assignments **************************************** snmpFrameworkAdmin OBJECT IDENTIFIER ::= { snmpFrameworkMIB 1 } snmpFrameworkMIBObjects OBJECT IDENTIFIER ::= { snmpFrameworkMIB 2 } snmpFrameworkMIBConformance OBJECT IDENTIFIER ::= { snmpFrameworkMIB 3 } Harrington/Wijnen Expires December 1997 [Page 36] \ Draft Architecture for Internet Management Frameworks July 1997 -- the snmpEngine Group ********************************************** snmpEngine OBJECT IDENTIFIER ::= { snmpFrameworkMIBObjects 1 } snmpEngineID OBJECT-TYPE SYNTAX SnmpEngineID MAX-ACCESS read-only STATUS current DESCRIPTION "An SNMP engine's administratively-unique identifier. " ::= { snmpEngine 1 } snmpEngineBoots OBJECT-TYPE SYNTAX Unsigned32 -- (1..4294967295) MAX-ACCESS read-only STATUS current DESCRIPTION "The number of times that the SNMP engine has (re-)initialized itself since its initial configuration. " ::= { snmpEngine 2 } snmpEngineTime OBJECT-TYPE SYNTAX Integer32 (0..2147483647) MAX-ACCESS read-only STATUS current DESCRIPTION "The number of seconds since the 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. " ::= { snmpFrameworkAdmin 1 } snmpPrivProtocols OBJECT-IDENTITY STATUS current DESCRIPTION "Registration point for standards-track privacy protocols used in the Internet Management Framework. " ::= { snmpFrameworkAdmin 2 } -- Conformance information ******************************************* snmpFrameworkMIBCompliances Harrington/Wijnen Expires December 1997 [Page 37] \ Draft Architecture for Internet Management Frameworks July 1997 OBJECT IDENTIFIER ::= { snmpFrameworkMIBConformance 1 } snmpFrameworkMIBGroups OBJECT IDENTIFIER ::= { snmpFrameworkMIBConformance 2 } -- compliance statements snmpFrameworkMIBCompliance MODULE-COMPLIANCE STATUS current DESCRIPTION "The compliance statement for SNMP engines which implement the Internet Management Framework MIB. " MODULE -- this module MANDATORY-GROUPS { snmpEngineGroup } ::= { snmpFrameworkMIBCompliances 1 } -- units of conformance snmpEngineGroup OBJECT-GROUP OBJECTS { snmpEngineID, snmpEngineBoots, snmpEngineTime } STATUS current DESCRIPTION "A collection of objects for identifying and determining the configuration and current timeliness values of an SNMP engine. " ::= { snmpFrameworkMIBGroups 1 } END Harrington/Wijnen Expires December 1997 [Page 38] \ Draft Architecture for Internet Management Frameworks July 1997 6. Security Considerations This document describes how a framework can use a Security Model and an Access Control Model to achieve a level of security for network management messages and controlled access to management information. The level of security provided is determined by the specific Security Model implementation(s) and the specific Access Control Model implementation(s) incorporated into this framework. Applications have access to data which is not secured. Applications should take reasonable steps to protect the data from disclosure. It is the responsibility of the purchaser of a management framework implementation to ensure that: 1) an implementation of this framework complies with the rules defined by this architecture, 2) the Security and Access Control Models utilized satisfy the security and access control needs of the organization, 3) the implementations of the Models and Applications comply with the model and application specifications, 4) and the implementation protects configuration secrets from inadvertent disclosure. Harrington/Wijnen Expires December 1997 [Page 39] \ Draft Architecture for Internet Management Frameworks July 1997 7. Glossary 8. References [RFC1155] Rose, M., and K. McCloghrie, "Structure and Identification of Management Information for TCP/IP-based internets", STD 16, RFC 1155, May 1990. [RFC1157] Case, J., M. Fedor, M. Schoffstall, and J. Davin, "The Simple Network Management Protocol", STD 15, RFC 1157, University of Tennessee at Knoxville, Performance Systems s International, Performance International, and the MIT Laboratory for Computer Science, May 1990. [RFC1212] Rose, M., and K. McCloghrie, "Concise MIB Definitions", STD 16, RFC 1212, March 1991. [RFC1901] The SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and S., Waldbusser, "Introduction to Community-based SNMPv2", RFC 1901, January 1996. [RFC1902] The SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and S., Waldbusser, "Structure of Management Information for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1905, January 1996. [RFC1903] The SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and S. Waldbusser, "Textual Conventions for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1903, January 1996. [RFC1904] The SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and S., Waldbusser, "Conformance Statements for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1904, January 1996. [RFC1905] The SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and S., Waldbusser, "Protocol Operations for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1905, January 1996. [RFC1906] The SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and S. Waldbusser, "Transport Mappings for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1906, January 1996. [RFC1907] The SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and S. Waldbusser, "Management Information Base for Version 2 of the Simple Network Management Protocol (SNMPv2)", RFC 1907 January 1996. [RFC1908] The SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M., and S. Waldbusser, "Coexistence between Version 1 and Version 2 of the Internet-standard Network Management Harrington/Wijnen Expires December 1997 [Page 40] \ Draft Architecture for Internet Management Frameworks July 1997 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 Harrington/Wijnen Expires December 1997 [Page 41] \ Draft Architecture for Internet Management Frameworks July 1997 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 Harrington/Wijnen Expires December 1997 [Page 42] \ Draft Architecture for Internet Management Frameworks July 1997 10. Acknowledgements This document builds on the work of the SNMP Security and Administrative Framework Evolution team, composed of David Harrington (Cabletron Systems Inc.) Jeff Johnson (Cisco) David Levi (SNMP Research Inc.) John Linn (Openvision) Russ Mundy (Trusted Information Systems) chair Shawn Routhier (Epilogue) Glenn Waters (Nortel) Bert Wijnen (IBM T.J. Watson Research) Harrington/Wijnen Expires December 1997 [Page 43] \ Draft Architecture for Internet Management Frameworks July 1997 APPENDIX A A. Guidelines for Model Designers This appendix describes guidelines for designers of models which are expected to fit into the architecture defined in this document. The basic design elements come from SNMPv2u and SNMPv2*, as described in RFCs 1909-1910, and from a set of internet drafts. these are the two most popular de facto "administrative framework" standards that include security and access control for SNMPv2. SNMPv1 and SNMPv2c [RFC1901] are two administrative frameworks based on communities to provide trivial authentication and access control. SNMPv1 and SNMPv2c Frameworks can coexist with Frameworks designed to fit into this architecture, and modified versions of SNMPv1 and SNMPv2c Frameworks could be fit into this architecture, but this document does not provide guidelines for that coexistence. Within any subsystem model, there should be no reference to any specific model of another subsystem, or to data defined by a specific model of another subsystem. Transfer of data between the subsystems is deliberately described as a fixed set of abstract data elements and primitive functions which can be overloaded to satisfy the needs of multiple model definitions. Documents which define models to be used within this architecture SHOULD use the standard primitives between subsystems, possibly defining specific mechanisms for converting the abstract data elements into model-usable formats. This constraint exists to allow subsystem and model documents to be written recognizing common borders of the subsystem and model. Vendors are not constrained to recognize these borders in their implementations. The architecture defines certain standard services to be provided between subsystems, and the architecture defines abstract service interfaces to request the services. Each model definition for a subsystem SHOULD support the standard service interfaces, but whether, or how, or how well, it performs the service is defined by the model definition. A.1. Security Model Design Requirements A.1.1. Threats A document describing a Security Model MUST describe how the model protects against the threats described under "Security Requirements of this Architecture", section 1.4. Harrington/Wijnen Expires December 1997 [Page 44] \ Draft Architecture for Internet Management Frameworks July 1997 A.1.2. Security Processing Received messages MUST be validated by a Model of the Security Subsystem. Validation includes authentication and privacy processing if needed, but it is explicitly allowed to send messages which do not require authentication or privacy. A received message contains a specified Level of Security to be used during processing. All messages requiring privacy MUST also require authentication. A Security Model specifies rules by which authentication and privacy are to be done. A model may define mechanisms to provide additional security features, but the model definition is constrained to using (possibly a subset of) the abstract data elements defined in this document for transferring data between subsystems. Each Security Model may allow multiple security mechanisms to be used concurrently within an implementation of the model. Each Security Model defines how to determine which protocol to use, given the LoS and the security parameters relevant to the message. Each Security Model, with its associated protocol(s) defines how the sending/receiving entities are identified, and how secrets are configured. Authentication and Privacy protocols supported by Security Models are uniquely identified using Object Identifiers. IETF standard protocol for authentication or privacy should have an identifier defined within the snmpAuthProtocols or the snmpPrivProtocols subtrees. Enterprise specific protocol identifiers should be defined within the enterprise subtree. For privacy, the Security Model defines what portion of the message is encrypted. The persistent data used for security should be SNMP-manageable, but the Security Model defines whether an instantiation of the MIB is a conformance requirement. Security Models are replaceable within the Security Subsystem. Multiple Security Model implementations may exist concurrently within an SNMP engine. The number of Security Models defined by the SNMP community should remain small to promote interoperability. A.1.3. validate the security-stamp in a received message The Message Processing Model requests that the Security Model verify that the message has not been altered, and authenticate the identification of the principal for whom the message was generated. If encrypted, decrypt the message. Harrington/Wijnen Expires December 1997 [Page 45] \ Draft Architecture for Internet Management Frameworks July 1997 Additional requirements may be defined by the model, and additional services provided by the model, but the model is constrained to use the following primitives for transferring data between subsystems. Implementations are not so constrained. The Message Processing Model 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 received message LoS -- Level of Security wholeMsg -- as received on the wire wholeMsgLength -- length as received on the wire ) The Security Model uses the following primitive to respond: returnProcessedMsg( securityName -- identification of the principal scopedPDU, -- message (plaintext) payload maxSizeResponseScopedPDU -- maximum size of the Response PDU securityStateReference -- reference to security state -- information, needed for response statusInformation -- errorIndication or success ) -- error counter OID/value if error A.1.5. Security MIBs Each Security Model defines the MIB modules required for security processing, including any MIB modules required for the security mechanism(s) supported. The MIB modules 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 securityName MUST be able to be determined using SNMP, if the model-dependent MIB is instantiated and access control policy allows access. A.1.6. Security State Cache For each message received, the Security Subsystem caches the state information such that a Response message can be generated using the same security state information, even if the Local Configuration Datastore is altered between the time of the incoming request and the outgoing response. Harrington/Wijnen Expires December 1997 [Page 46] \ Draft Architecture for Internet Management Frameworks July 1997 Applications have the responsibility for explicitly releasing the cached data. To enable this, an abstract stateReference data element is passed from the Security Subsystem to the Message Processing Subsystem, which passes it to the application. The cached security data may be implicitly released via the generation of a response, or explicitly released by using the stateRelease primitive: stateRelease( stateReference -- handle of reference to be released ) Harrington/Wijnen Expires December 1997 [Page 47] \ Draft Architecture for Internet Management Frameworks July 1997 A.2. SNMP engine and Message Processing Model Requirements An SNMP engine contains a Message Processing Subsystem which may contain multiple version-specific Message Processing Models. Within any version-specific Message Processing Model, there may be an explicit binding to a particular Security Model but there should be no reference to any data defined by a specific Security Model. There should be no reference to any specific application, or to any data defined by a specific application; there should be no reference to any specific Access Control Model, or to any data defined by a specific Access Control Model. The Message Processing Model MUST always (conceptually) pass the complete PDU, i.e. it never forwards less than the complete list of varBinds. A.2.1. Receiving an SNMP Message from the Network Upon receipt of a message from the network, the SNMP engine notes the msgID, which is subsequently used for coordinating all processing regarding this received message. A Message Processing Model specifies how to determine the values of the global data (mms, the securityModel, the LoS), and the security parameters block. The Message Processing Model calls the Security Model to provide security processing for the message using the primitive: processMsg( messageProcessingModel -- typically, SNMP version msgID -- of the received message mms -- of the sending SNMP entity msgFlags -- for the received message securityParameters -- for the received message securityModel -- for the received message LoS -- Level of Security wholeMsg -- as received on the wire wholeMsgLength -- length as received on the wire ) The Security Model uses the following primitive to respond: returnProcessedMsg( securityName -- identification of the principal scopedPDU, -- message (plaintext) payload maxSizeResponseScopedPDU -- maximum size of the Response PDU securityStateReference -- reference to security state -- information, needed for response statusInformation -- errorIndication or success ) -- error counter OID/value if error Harrington/Wijnen Expires December 1997 [Page 48] \ Draft Architecture for Internet Management Frameworks July 1997 A.2.2. Send SNMP messages to the network The Message Processing Model passes a PDU, the securityName, and all global data to be included in the message to the Security model using the following primitives: For requests and notifications: 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 ) For response messages: 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 constructs the message, and returns the completed message to the Message Processing Model using the returnGeneratedMsg primitive: returnGeneratedMsg( wholeMsg -- complete generated message wholeMsgLength -- length of the generated message statusInformation -- errorIndication or success ) The SNMP engine sends the message to the desired address using the appropriate transport. A.2.3. Generate Request or Notification Message for an Application Harrington/Wijnen Expires December 1997 [Page 49] \ Draft Architecture for Internet Management Frameworks July 1997 The SNMP engine 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 the associated application. The Message Processing Model generates the message according to the process described in A.2.2. A.2.4. Pass Received Response Message to an Application The Message Processing Model receives the SNMP message according to the process described in A.2.1. The Message Processing Model determines which application is awaiting this response, using the msgID and the cached information from step A.2.3 The Message Processing Model matches the msgID of an incoming response to the cached msgIDs of messages sent by this SNMP engine, and forwards the response to the associated application using the processResponsePdu primitive: 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 ) A.2.5. Pass Received Request or Notification Message to Application The Message Processing Model receives the SNMP message according to the process described in A.2.1. Harrington/Wijnen Expires December 1997 [Page 50] \ Draft Architecture for Internet Management Frameworks July 1997 The SNMP engine looks into the scopedPDU to determine the contextEngineID, then determine which application has registered to support that contextEngineID, and forwards the request or notification to the registered application using the processPdu primitive: 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 ) -- needed when sending a response A.2.6. Generate a Response Message for an Application The SNMP engine 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 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 SNMP engine generates the message according to the process described in A.2.2. A.3. Application Design Requirements Within an application, there may be an explicit binding to a specific SNMP message version, i.e. a specific Message Processing Model, and to a specific Access Control Model, but there should be no reference to any data defined by a specific Message Processing Model or Access Control Model. Within an application, there should be no reference to any specific Security Model, or any data defined by a specific Security Model. Harrington/Wijnen Expires December 1997 [Page 51] \ Draft Architecture for Internet Management Frameworks July 1997 An application determines whether explicit or implicit access control should be applied to the operation, and, if access control is needed, which Access Control Model should be used. An application has the responsibility to define any MIB modules used to provide application-specific services. Applications interact with the SNMP engine to initiate messages, receive responses, receive asynchronous messages, and send responses. A.3.1. Applications that Initiate Messages Applications may request that the SNMP engine send messages containing SNMP commands or notifications using the sendPdu primitive: sendPdu( transportDomain -- transport domain to be used transportAddress -- destination network address messageProcessingModel -- typically, SNMP version securityModel -- Security Model to use securityName -- on behalf of this principal LoS -- Level of Security requested contextEngineID -- data from/at this entity contextName -- data from/in this context PDU -- SNMP Protocol Data Unit expectResponse -- TRUE or FALSE ) If it is desired that a message be sent to multiple targets, it is the responsibility of the application to provide the iteration. The SNMP engine assumes necessary access control has been applied to the PDU, and provides no access control services. The SNMP engine looks at the "expectResponse" parameter, and for operations which elicit a response, the msgID and the associated application are cached. A.3.2. Applications that Receive Responses The SNMP engine matches the msgID of an incoming response to the cached msgIDs of messages sent by this SNMP engine, and forwards the response to the associated application using the processResponsePdu primitive: 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 Harrington/Wijnen Expires December 1997 [Page 52] \ Draft Architecture for Internet Management Frameworks July 1997 ) The SNMP engine then releases its own state information about this message. A.3.3. Applications that Receive Asynchronous Messages When an SNMP engine receives a message that is 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. An Application that wishes to stop receiving asynchronous messages should unregister itself with the SNMP engine. statusInformation = -- success or errorIndication registerContextEngineID( contextEngineID -- take responsibility for this one pduType -- the pduType(s) to be registered ) 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. An errorIndication will be returned to the application that attempts to duplicate a registration. All asynchronously received messages containing a registered PDU type and contextEngineID are sent to the application which registered to support that combination. The engine forwards the PDU to the registered application, using the processPdu primitive: 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 ) -- needed when sending a response A.3.4. Applications that Send Responses Harrington/Wijnen Expires December 1997 [Page 53] \ Draft Architecture for Internet Management Frameworks July 1997 Request operations require responses. These operations include Get requests, Set requests, and Inform requests. An application sends a response via the returnResponsePdu primitive: returnResponsePdu( contextEngineID -- data from/at this SNMP engine contextName -- data from/in this context PDU -- SNMP Protocol Data Unit maxSizeResponseScopedPDU -- maximum size of 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 ) Harrington/Wijnen Expires December 1997 [Page 54] \ Draft Architecture for Internet Management Frameworks July 1997 APPENDIX B B. An Evolutionary Architecture - Design Goals The goals of the architectural design are to use encapsulation, cohesion, hierarchical rules, and loose coupling to reduce complexity of design and make the evolution of portions of the architecture possible. B.1. Encapsulation Encapsulation describes the practice of hiding the details that are used internal to a process. Some data is required for a given procedure, but isn't needed by any other part of the process. In networking, the concept of a layered stack reflects this approach. The transport layer contains data specific to its processing; the data is not visible to the other layers. In programming this is reflected in language elements such as "file static" variables in C, and "private" in C++, etc. In this architecture, all data used for processing only within 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 important that the functions which are grouped together are actually similar. Similarity of the data used to perform functions can be a good indicator of the similarity of the functions. For example, authentication and encryption are both security functions which are applied to a message. Access control, while similar in some ways, is dissimilar in that it is not applied to a message, it is applied to a (proposed) request for a management operation. The data required to perform authentication and encryption are different than the data needed to perform access control, and the two sets of services can be described independently. Similar functions, especially those that use the same data elements, should be defined together. The security functions which operate at the message level should be defined in a document together with the definitions for those data elements that are used only by those security functions. For example, a MIB with authentication keys is used only by authentication functions; they should be defined together. Harrington/Wijnen Expires December 1997 [Page 55] \ Draft Architecture for Internet Management Frameworks July 1997 B.3. Hierarchical Rules Functionality can be grouped into hierarchies where each element in the hierarchy receives general characteristics from its direct superior, and passes on those characteristics to each of its direct subordinates. This architecture uses the hierarchical approach by defining subsystems, which specify the general rules of a portion of the system, models which define the specific rules to be followed by an implementation of the portion of the system, and implementations which encode those rules into reality for a portion of the system. Within portions of the system, hierarchical relationships are used to compartmentalize, or modularize, the implementation of specific functionality. For example, within the security portion of the system, authentication and privacy may be contained in separate modules, and multiple authentication and privacy mechanisms may be supported by allowing supplemental modules that provide protocol-specific authentication and privacy services. B.4. Coupling Coupling describes the 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 evolve the architecture by replacing only part of the system, or by supplementing existing portions with alternate mechanisms for similar functionality, without obsoleting the complete system, it is necessary to limit the coupling of the parts. Encapsulation and cohesion help to reduce coupling by limiting the visibility of those parts that are only needed within portions of a system. Another mechanism is to constrain the nature of interactions between various parts of the system. This can be done by defining fixed, generic, flexible interfaces for transferring data between the parts of the system. The concept of plug-and-play hardware components is based on that type of interface between the hardware component and 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 (conceptually) transferring data between subsystems in documents which describe subsystem or model interactions. Documents describing the interaction of subsystems or models should use only the abstract data elements provided for transferring data but vendors Harrington/Wijnen Expires December 1997 [Page 56] \ Draft Architecture for Internet Management Frameworks July 1997 are not constrained to using the described data elements for transferring data between portions of their implementation. Loose coupling works well with the IETF standards process. If we separate message-handling from security and from local processing, then the separate portions of the system can move through the standards process with less dependence on the status of the other portions of the standard. Security models may be able to be re-opened for discussion due to patents, new research, export laws, etc., as is clearly expected by the WG, without needing to reopen the documents which detail the message format or the local processing of PDUs. Thus, the standards track status of related, but independent, documents is not affected. Harrington/Wijnen Expires December 1997 [Page 57] \ Draft Architecture for Internet Management Frameworks July 1997 Table of Contents 0. Issues 2 0.1. Issues to be resolved 2 0.1.1. Issues discussed at second Interim Meeting: 2 0.2. Change Log 3 1. Introduction 7 1.1. Target Audience 7 1.2. Management Systems 7 1.3. Goals of this Architecture 8 1.4. Security Requirements of this Architecture 9 1.5. Design Decisions 10 2. Documentation Overview 12 2.1. Document Roadmap 13 2.2. Applicability Statement 13 2.3. Coexistence and Transition 13 2.4. Transport Mappings 14 2.5. Message Processing 14 2.6. Security 14 2.7. Access Control 14 2.8. Applications 15 2.9. Structure of Management Information 15 2.10. Textual Conventions 15 2.11. Conformance Statements 15 2.12. Protocol Operations 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 Model 21 3.1.11. Applications 21 3.1.12. SNMP Agent 21 3.1.13. SNMP Manager 21 3.2. The Naming of Identities 22 3.2.1. Principal 22 3.2.2. securityName 22 3.2.3. Model dependent security ID 22 3.3. The Naming of 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 Harrington/Wijnen Expires December 1997 [Page 58] \^L Draft Architecture for Internet Management Frameworks July 1997 3.4.1. maxSizeResponseScopedPDU 25 3.4.2. Local Configuration Datastore 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 Network 29 4.2.2. Receive a Message from the 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 33 6. Security Considerations 39 7. Glossary 40 8. References 40 9. Editor's Addresses 42 10. Acknowledgements 43 A. Guidelines for Model Designers 44 A.1. Security Model Design Requirements 44 A.1.1. Threats 44 A.1.2. Security Processing 45 A.1.3. validate the security-stamp in a received message 45 A.1.5. Security MIBs 46 A.1.6. Security State Cache 46 A.2. SNMP engine and Message Processing Model Requirements 48 A.2.1. Receiving an SNMP Message from the Network 48 A.2.2. Send SNMP messages to the network 49 A.2.3. Generate Request or Notification Message for an Application 49 A.2.4. Pass Received Response Message to an Application 50 A.2.5. Pass Received Request or Notification Message to Application 50 A.2.6. Generate a Response Message for an Application 51 A.3. Application Design Requirements 51 A.3.1. Applications that Initiate Messages 52 A.3.2. Applications that Receive Responses 52 A.3.3. Applications that Receive Asynchronous Messages 53 A.3.4. Applications that Send Responses 53 A.4. Access Control Model Design Requirements 54 Harrington/Wijnen Expires December 1997 [Page 59]