idnits 2.17.1 draft-ietf-policy-core-schema-04.txt: -(1471): Line appears to be too long, but this could be caused by non-ascii characters in UTF-8 encoding Checking boilerplate required by RFC 5378 and the IETF Trust (see https://trustee.ietf.org/license-info): ---------------------------------------------------------------------------- ** Looks like you're using RFC 2026 boilerplate. This must be updated to follow RFC 3978/3979, as updated by RFC 4748. Checking nits according to https://www.ietf.org/id-info/1id-guidelines.txt: ---------------------------------------------------------------------------- ** Missing expiration date. The document expiration date should appear on the first and last page. == There are 2 instances of lines with non-ascii characters in the document. Checking nits according to https://www.ietf.org/id-info/checklist : ---------------------------------------------------------------------------- ** The document seems to lack an IANA Considerations section. (See Section 2.2 of https://www.ietf.org/id-info/checklist for how to handle the case when there are no actions for IANA.) ** The document seems to lack separate sections for Informative/Normative References. All references will be assumed normative when checking for downward references. ** There are 156 instances of too long lines in the document, the longest one being 1 character in excess of 72. ** The abstract seems to contain references ([Policy], [10]), which it shouldn't. Please replace those with straight textual mentions of the documents in question. == There are 1 instance of lines with non-RFC6890-compliant IPv4 addresses in the document. If these are example addresses, they should be changed. Miscellaneous warnings: ---------------------------------------------------------------------------- == The copyright year in the RFC 3978 Section 5.4 Copyright Line does not match the current year == Line 240 has weird spacing: '...case is not s...' == Line 726 has weird spacing: '...-valued prope...' == Line 1412 has weird spacing: '...ository direc...' == Line 1465 has weird spacing: '... server will ...' -- The document seems to lack a disclaimer for pre-RFC5378 work, but may have content which was first submitted before 10 November 2008. If you have contacted all the original authors and they are all willing to grant the BCP78 rights to the IETF Trust, then this is fine, and you can ignore this comment. If not, you may need to add the pre-RFC5378 disclaimer. (See the Legal Provisions document at https://trustee.ietf.org/license-info for more information.) -- The document date (June 1999) is 9053 days in the past. Is this intentional? Checking references for intended status: Proposed Standard ---------------------------------------------------------------------------- (See RFCs 3967 and 4897 for information about using normative references to lower-maturity documents in RFCs) -- Looks like a reference, but probably isn't: 'Policy' on line 81 -- Looks like a reference, but probably isn't: 'RAPFRAME' on line 1460 == Unused Reference: '6' is defined on line 1540, but no explicit reference was found in the text == Unused Reference: '7' is defined on line 1543, but no explicit reference was found in the text == Unused Reference: '8' is defined on line 1547, but no explicit reference was found in the text == Unused Reference: '9' is defined on line 1550, but no explicit reference was found in the text -- Unexpected draft version: The latest known version of draft-strassner-policy-terms is -01, but you're referring to -02. -- Possible downref: Normative reference to a draft: ref. '1' -- Possible downref: Non-RFC (?) normative reference: ref. '2' -- Possible downref: Non-RFC (?) normative reference: ref. '3' -- Possible downref: Non-RFC (?) normative reference: ref. '4' ** Obsolete normative reference: RFC 2028 (ref. '6') (Obsoleted by RFC 9281) ** Obsolete normative reference: RFC 2253 (ref. '7') (Obsoleted by RFC 4510, RFC 4514) -- Possible downref: Non-RFC (?) normative reference: ref. '8' -- Possible downref: Non-RFC (?) normative reference: ref. '9' == Outdated reference: A later version (-08) exists of draft-ietf-policy-core-info-model-00 Summary: 8 errors (**), 0 flaws (~~), 12 warnings (==), 11 comments (--). Run idnits with the --verbose option for more detailed information about the items above. -------------------------------------------------------------------------------- 1 Policy Framework Working Group J. Strassner 2 Internet-draft Cisco Systems 3 Category: Standards Track E. Ellesson 4 B. Moore 5 IBM Corporation 6 June 1999 8 Policy Framework LDAP Core Schema 9 draft-ietf-policy-core-schema-04.txt 10 June 25, 1999 13:39 12 Status of this Memo 14 This document is an Internet-Draft and is in full conformance with all 15 provisions of Section 10 of RFC2026. 17 Internet-Drafts are working documents of the Internet Engineering Task 18 Force (IETF), its areas, and its working groups. Note that other 19 groups may also distribute working documents as Internet-Drafts. 21 Internet-Drafts are draft documents valid for a maximum of six months 22 and may be updated, replaced, or obsoleted by other documents at any 23 time. It is inappropriate to use Internet-Drafts as reference 24 material or to cite them other than as "work in progress." 26 The list of current Internet-Drafts can be accessed at 27 http://www.ietf.org/ietf/1id-abstracts.txt 29 The list of Internet-Draft Shadow Directories can be accessed at 30 http://www.ietf.org/shadow.html 32 Copyright Notice 34 Copyright (C) The Internet Society (1999). All Rights Reserved. 36 Abstract 38 This document takes as its starting point the object-oriented 39 information model for representing policy information currently under 40 joint development in the Service Level Agreements (SLA) Policy working 41 group of the Distributed Management Task Force (DMTF) and in the 42 IETF's Policy Framework working group. The IETF document defining 43 this information model is the "Policy Framework Core Information 44 Model" [10]. This model defines two hierarchies of object classes: 45 structural classes representing policy information and control of 46 policies, and relationship classes that indicate how instances of the 47 structural classes are related to each other. In general, both of 48 these class hierarchies will need to be mapped to a particular data 49 store. 51 This draft defines the mapping of these information model classes to a 52 directory that uses LDAPv3 as its access protocol. When mapping to an 53 LDAP schema, the structural classes can be mapped more or less 54 directly. The relationship hierarchy, however, must be mapped to a 55 form suitable for directory implementation. Since this mapping of the 56 relationship classes could be done in a number of different ways, 57 there is the risk of non-interoperable implementations. To avoid this 58 possibility, this document provides a single mapping that all 59 implementations using an LDAP directory as their policy repository 60 SHALL use. 62 Classes are also added to the LDAP schema to improve the performance 63 of a client's interactions with an LDAP server when the client is 64 retrieving large amounts of policy-related information. These classes 65 exist only to optimize LDAP retrievals: there are no classes in the 66 information model that correspond to them. 68 The LDAP schema described in this document consists of six very 69 general classes: policy (an abstract class), policyGroup, policyRule, 70 policyCondition, policyTimePeriodCondition, and policyAction. The 71 schema also contains two less general classes: vendorPolicyCondition 72 and vendorPolicyAction. To achieve the mapping of the information 73 model's relationships, the schema contains two auxiliary classes: 74 policyGroupContainmentAuxClass and policyRuleContainmentAuxClass. 75 Finally, the schema includes two classes policySubtreesPtrAuxClass and 76 policyElement for optimizing LDAP retrievals, and a structural class 77 policyInstance for attaching auxiliary classes representing policy 78 conditions and policy actions. In all, therefore, the schema contains 79 13 classes. 81 Within the context of this document, the term "Core [Policy] Schema" 82 is used to refer to the LDAP class definitions it contains. 84 Table of Contents 85 1. Introduction......................................................3 86 2. The Policy Core Information Model.................................4 87 3. Inheritance Hierarchy for the LDAP Core Policy Schema.............5 88 4. General Discussion of Mapping the Information Model to LDAP.......5 89 4.1. Summary of Class and Relationship Mappings...................6 90 4.2. Naming Attributes in the Core Schema.........................7 91 4.3. Flexibility Gained through Auxiliary Classes.................8 92 4.4. Location and Retrieval of Policy Objects in the Directory....9 93 4.4.1. Aliases...................................................12 94 5. Class Definitions................................................13 95 5.1. The Abstract Class "policy".................................13 96 5.2. The Class policyGroup.......................................14 97 5.3. The Class policyRule........................................14 98 5.4. The Class policyCondition...................................19 99 5.5. The Class policyTimePeriodCondition.........................19 100 5.6. The Class vendorPolicyCondition.............................21 101 5.7. The Class policyAction......................................22 102 5.8. The Class vendorPolicyAction................................22 103 5.9. The Class policyInstance....................................23 104 5.10. The Auxiliary Class policyElement..........................23 105 5.11. The Auxiliary Class policySubtreesPtrAuxClass..............24 106 5.11.1. The Attribute policySubtreesAuxContainedSet..............25 107 5.12. The Auxiliary Class policyGroupContainmentAuxClass.........25 108 5.12.1. The Attribute policyGroupsAuxContainedSet................26 109 5.13. The Auxiliary Class policyRuleContainmentAuxClass..........26 110 5.13.1. The Attribute policyRulesAuxContainedSet.................27 111 6. Extending the Core Schema........................................27 112 6.1. Subclassing policyCondition and policyAction................27 113 6.2. Using the Vendor Policy Encoding Attributes.................28 114 6.3. Using Time Validity Periods.................................28 115 7. Security Considerations..........................................29 116 8. Intellectual Property............................................31 117 9. Acknowledgments..................................................31 118 10. References......................................................31 119 11. Authors' Addresses..............................................32 120 12. Full Copyright Statement........................................32 122 1. Introduction 124 This document takes as its starting point the object-oriented 125 information model for representing policy information currently under 126 joint development in the Service Level Agreements working group of the 127 Distributed Management Task Force (DMTF) and in the IETF's Policy 128 Framework working group. The IETF document defining this information 129 model is the "Policy Framework Core Information Model" [10]. This 130 model defines two hierarchies of object classes: structural classes 131 representing policy information and control of policies, and 132 relationship classes that indicate how instances of the structural 133 classes are related to each other. In general, both of these class 134 hierarchies will need to be mapped to a particular data store. 136 This draft defines the mapping of these information model classes to a 137 directory that uses LDAPv3 as its access protocol. Two types of 138 mappings are involved: 140 o For the structural classes in the information model, the mapping is 141 basically one-for-one: information model classes map to LDAP 142 classes, information model properties map to LDAP attributes. 144 o For the relationship classes in the information model, different 145 mappings are possible. In this document the information model's 146 relationship classes and their properties are mapped in three ways: 147 to LDAP auxiliary classes, to attributes representing DN pointers, 148 and to "composite" attributes representing DN pointers with 149 additional data elements. 151 Implementations that use an LDAP directory as their policy repository 152 SHALL use the LDAP policy schema defined in this document. The use of 153 the information model defined in reference [10] as the starting point 154 enables the schema and the relationship class hierarchy to be 155 extensible, such that other types of policy repositories, such as 156 relational databases, can also use this information. 158 This document fits into the overall framework for representing, 159 deploying, and managing policies being developed by the Policy 160 Framework Working Group. The initial work to define this framework is 161 in reference [1]. More specifically, this document builds on the core 162 policy classes first introduced in references [2] and [3]. It also 163 draws on the work done for the Directory-enabled Networks (DEN) 164 specification, reference [4]. Work on the DEN specification by the 165 DEN Ad-Hoc Working Group itself has been completed. Further work to 166 standardize the models contained in it will be the responsibility of 167 selected working groups of the Common Information Model (CIM) effort 168 in the Distributed Management Task Force (DMTF). Standardization of 169 the core policy model is the responsibility of the SLA Policy working 170 group. 172 The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", 173 "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this 174 document are to be interpreted as described in RFC 2119, reference 175 [5]. 177 2. The Policy Core Information Model 179 This document contains an LDAP schema representing the Policy Core 180 Information Model, which is defined in the companion document "Policy 181 Framework Core Information Model" [10]. Other documents may 182 subsequently be produced, with mappings of this same Core Information 183 Model to other storage technologies. Since the detailed semantics of 184 the Core Policy classes appear only in reference [10], that document 185 is a prerequisite for reading and understanding this document. 187 3. Inheritance Hierarchy for the LDAP Core Policy Schema 189 The following diagram illustrates the class hierarchy for the LDAP 190 Core Policy Schema classes: 192 top 193 | 194 +--policy (abstract) 195 | | 196 | +---policyGroup (structural) 197 | | 198 | +---policyRule (structural) 199 | | 200 | +---policyCondition (auxiliary) 201 | | | 202 | | +---policyTimePeriodCondition (auxiliary) 203 | | | 204 | | +---vendorPolicyCondition (auxiliary) 205 | | 206 | +---policyAction (auxiliary) 207 | | | 208 | | +---vendorPolicyAction (auxiliary) 209 | | 210 | +--policyInstance (structural) 211 | | 212 | +--policyElement (auxiliary) 213 | 214 +--policySubtreesPtrAuxClass (auxiliary) 215 | 216 +--policyGroupContainmentAuxClass (auxiliary) 217 | 218 +--policyRuleContainmentAuxClass (auxiliary) 220 Figure 1. LDAP Class Inheritance Hierarchy for the Core Policy 221 Schema 223 4. General Discussion of Mapping the Information Model to LDAP 225 The classes described in Section 5 below contain certain optimizations 226 for a directory that uses LDAP as its access protocol. One example of 227 this is the use of auxiliary classes to represent some of the 228 relationships defined in the information model. Other data stores 229 might need to implement these relationships differently. A second 230 example is the introduction of classes specifically designed to 231 optimize retrieval of large amounts of policy-related data from a 232 directory. This section discusses some general topics related to the 233 mapping from the information model to LDAP. 235 4.1. Summary of Class and Relationship Mappings 237 Eight of the classes in the LDAP Core Policy Schema come directly from 238 corresponding classes in the information model. Note that names of 239 classes begin with an upper case character in the information model 240 (although for CIM in particular, case is not significant in class and 241 property names), but with a lower case character in LDAP. 243 +---------------------------+---------------------------+ 244 | Information Model | LDAP Class | 245 +---------------------------+---------------------------+ 246 +---------------------------+---------------------------+ 247 | Policy | policy | 248 +---------------------------+---------------------------+ 249 | PolicyGroup | policyGroup | 250 +---------------------------+---------------------------+ 251 | PolicyRule | policyRule | 252 +---------------------------+---------------------------+ 253 | PolicyCondition | policyCondition | 254 +---------------------------+---------------------------+ 255 | PolicyAction | policyAction | 256 +---------------------------+---------------------------+ 257 | VendorPolicyCondition | vendorPolicyCondition | 258 +---------------------------+---------------------------+ 259 | VendorPolicyAction | vendorPolicyAction | 260 +---------------------------+---------------------------+ 261 | PolicyTimePeriodCondition | policyTimePeriodCondition | 262 +---------------------------+---------------------------+ 263 Figure 2. Mapping of Information Model Classes to LDAP 265 The relationships in the information model map to pointer attributes 266 in LDAP. Two of these attributes appear in auxiliary classes, which 267 allows each of them to represent several associations from the 268 information model. 270 +--------------------------------+---------------------------------+ 271 | Information Model Relationship | LDAP Attribute / Class | 272 +--------------------------------+---------------------------------+ 273 +--------------------------------+---------------------------------+ 274 | GroupJurisdiction | policyGroupsAuxContainedSet in | 275 | | policyGroupContainmentAuxClass | 276 +--------------------------------+---------------------------------+ 277 | ContainedPolicyGroup | policyGroupsAuxContainedSet in | 278 | | policyGroupContainmentAuxClass | 279 +--------------------------------+---------------------------------+ 280 | RuleJurisdiction | policyRulesAuxContainedSet in | 281 | | policyRuleContainmentAuxClass | 282 +--------------------------------+---------------------------------+ 283 | ContainedPolicyRule | policyRulesAuxContainedSet in | 284 | | policyRuleContainmentAuxClass | 285 +--------------------------------+---------------------------------+ 286 | ContainedPolicyCondition | policyRuleConditionList in | 287 | | policyRule | 288 +--------------------------------+---------------------------------+ 289 | ContainedPolicyAction | policyRuleActionList in | 290 | | policyRule | 291 +--------------------------------+---------------------------------+ 292 | PolicyRuleValidityPeriod | policyRuleValidityPeriodList in | 293 | | policyRule | 294 +--------------------------------+---------------------------------+ 295 Figure 3. Mapping of Information Model Relationships to LDAP 297 Of the remaining classes in the LDAP Core Schema, two (policyElement, 298 and policySubtreesPtrAuxClass) are included to make navigation through 299 the Directory Information Tree (DIT) and retrieval of the entries 300 found there more efficient. This topic is discussed in Section 4.4 301 below. 303 The final class in the LDAP Core Schema, policyInstance, plays the 304 role of a structural class to which the auxiliary classes 305 policyCondition and policyAction (and their subclasses) may be 306 attached. This topic is discussed in Section 4.3 below. 308 4.2. Naming Attributes in the Core Schema 310 Instances in a directory are identified by distinguished names (DNs), 311 which provide the same type of hierarchical organization that a file 312 system provides in a computer system. A distinguished name is a 313 sequence of relative distinguished names (RDNs), where an RDN provides 314 a unique identifier for an instance within the context of its 315 immediate superior, in the same way that a filename provides a unique 316 identifier for a file within the context of the folder in which it 317 resides. 319 To preserve maximum naming flexibility for policy administrators, each 320 of the structural classes defined in this schema has its own naming 321 attribute. (The structural class policyInstance gets its naming 322 attribute from one of two auxiliary classes defined in the schema: 323 either policyConditionName from the auxiliary class policyCondition, 324 or policyActionName from the auxiliary class policyAction.) Since the 325 naming attributes are different, a policy administrator can, by using 326 these attributes, guarantee that there will be no name collisions 327 between instances of different classes, even if the same VALUE is 328 assigned to the instances' respective naming attributes. 330 The X.500 attribute commonName (cn) is included as a MAY attribute in 331 the abstract class policy, and thus by inheritance in policyGroup, 332 policyRule, policyCondition, policyAction, policyInstance, 333 policyElement, and all of their subclasses. In X.500 commonName 334 typically functions as an RDN attribute, for naming instances of such 335 classes as X.500's person. 337 Each of the Core Schema classes thus has two attributes suitable for 338 naming: cn and its own class-specific attribute. Either of these 339 attributes MAY be used for naming an instance of a Core Schema class. 340 Consequently, implementations MUST be able to accommodate instances 341 named in either of these ways. 343 4.3. Flexibility Gained through Auxiliary Classes 345 A key feature of the Core Schema is the use of auxiliary classes for 346 modeling policy conditions and policy actions. These auxiliary 347 classes make it possible to model a policy rule in two different ways: 349 o Simple Policy Rule: The conditions and/or the actions for the rule 350 are attached to the rule object itself. 352 o Complex Policy Rule: The conditions and/or the actions for the 353 rule are attached to instances of the structural class 354 policyInstance, and these instances are pointed to by one of three 355 attributes in the policy rule object - policyRuleConditionList, 356 policyRuleActionList, or policyRuleValidityPeriodList (for the 357 special case of a policyTimePeriodCondition object). 359 The simple/complex distinction for a policy rule is not all or 360 nothing. A policy rule may have its conditions attached to itself and 361 its actions attached to instances of policyInstance, or it may have 362 its actions attached to itself and its conditions attached to 363 instances of policyInstance. However, it SHALL NOT have either its 364 conditions or its actions attached both to itself and to instances of 365 policyInstance, with one exception: a policy rule may point to its 366 validity periods with the policyRuleValidityPeriodList attribute, but 367 have its other conditions attached to itself. 369 The tradeoffs between simple and complex policy rules are between the 370 efficiency of simple rules and the flexibility and greater potential 371 for reuse of complex rules. With a simple policy rule, the semantic 372 options are limited: 374 o All conditions are ANDed together. This combination can be 375 represented in two ways in the DNF / CNF expressions characteristic 376 of policy conditions: as a DNF expression with a single AND group, 377 or as a CNF expression with multiple single-condition OR groups. 378 The first of these is arbitrarily chosen as the representation for 379 the ANDed conditions in a simple policy rule. 381 o If multiple actions are included, no order can be specified for 382 them. 384 Thus if a policy administrator needs to combine conditions in some 385 other way, or if there is a set of actions that must be ordered, then 386 the only option is to use a complex policy rule. The cost of a 387 complex rule lies in the overhead of following DN pointers from the 388 rule object to condition and/or action objects. Section 4.4 below 389 describes a technique for minimizing this overhead, by making the 390 following of these pointers a local operation for a PDP. 392 The classes policyCondition and policyAction do not themselves 393 represent actual conditions and actions: these are introduced in 394 subclasses of policyCondition and policyAction. What policyCondition 395 and policyAction do introduce, in addition to the naming attributes 396 policyConditionName and policyActionName, are the semantics of being a 397 policy condition or a policy action. These are the semantics that all 398 the subclasses of policyCondition and policyAction inherit. Among 399 these semantics are those of being an object to which, respectively, 400 the policyRuleConditionList and policyRuleActionList attributes may 401 point. 403 In order to preserve the flexibility of attaching either to policyRule 404 or to policyInstance, all the subclasses of policyCondition and 405 policyAction MUST also be auxiliary classes. 407 4.4. Location and Retrieval of Policy Objects in the Directory 409 When a PDP goes to an LDAP directory to retrieve the policy object 410 instances relevant to the PEPs it serves, it is faced with two related 411 problems: 413 o How does it locate and retrieve the directory entries that apply to 414 its PEPs? These entries may include instances of the Core Schema 415 classes, instances of domain-specific subclasses of these classes, 416 and instances of other classes modeling such resources as user 417 groups, interfaces, and address ranges. 419 o How does it retrieve the directory entries it needs in an efficient 420 manner, so that retrieval of policy information from the directory 421 does not become a roadblock to scaleability? There are two facets 422 to this efficiency: retrieving only the relevant directory 423 entries, and retrieving these entries using as few LDAP calls as 424 possible. 426 The placement of objects in the Directory Information Tree (DIT) 427 involves considerations other than how the policy-related objects will 428 be retrieved by a PDP. Consequently, all that the Core Schema can do 429 is to provide a "toolkit" of classes to assist the policy 430 administrator as the DIT is being designed and built. A PDP SHOULD be 431 able to take advantage of any tools that the policy administrator is 432 able to build into the DIT, but it MUST be able to use a less 433 efficient means of retrieval if that is all it has available to it. 435 The basic idea behind the LDAP optimization classes is a simple one: 436 make it possible for a PDP to retrieve all the policy-related objects 437 it needs, and only those objects, using as few LDAP calls as possible. 438 Figure 4 illustrates how these goals can be accomplished. 440 +-----+ 441 ---------------->| A | 442 DN pointer to | | DN pointers to subtrees +---+ 443 starting object +-----+ +------------------------->| C | 444 | o--+----+ +---+ +---+ 445 | o--+------------->| B | / \ 446 +-----+ +---+ / \ 447 / \ / \ / ... \ 448 / \ / \ 449 / \ / ... \ 451 Figure 4. Using a policyContainer Object to Scope Policies 453 The PDP is configured initially with a DN pointer to some entry in the 454 DIT. The structural class of this entry is not important; the PDP is 455 interested only in the policySubtreesPtrAuxClass attached to it. This 456 auxiliary class contains a multi-valued attribute with DN pointers to 457 objects that anchor subtrees containing policy-related objects of 458 interest to the PDP. Since policySubtreesPtrAuxClass is an auxiliary 459 class, it can be attached to an entry that the PDP would need to 460 access anyway - perhaps an entry containing initial configuration 461 settings for the PDP, or for a PEP that uses the PDP. 463 Once it has retrieved the DN pointers, the PDP will direct to each of 464 the objects identified by them an LDAP request that all entries in its 465 subtree be evaluated against the selection criteria specified in the 466 request. The LDAP-enabled directory then returns all entries in that 467 subtree that satisfy the specified criteria. 469 The selection criteria always specify that object class = "policy". 470 Since all classes representing policy rules, policy conditions, and 471 policy actions, both in the Core Schema and in any domain-specific 472 schema derived from it, are subclasses of the abstract class policy, 473 this criterion evaluates to TRUE for all instances of these classes. 474 To accommodate special cases where a PDP needs to retrieve objects 475 that are not inherently policy-related (for example, an IP address 476 range object pointed to by a subclass of policyAction representing the 477 DHCP action "assign from this address range), the auxiliary class 478 policyElement can be used to "tag" an entry, so that it will be found 479 by the selection criterion "object class = policy". 481 The approach described in the preceding paragraph will not work for 482 certain directory implementations, because these implementations do 483 not support matching of auxiliary classes in the objectClass 484 attribute. For environments where these implementations are expected 485 to be present, the "tagging" of entries as relevant to policy can be 486 accomplished by inserting the special value "POLICY" into the list of 487 values contained in the policyKeywords attribute. 489 If a PDP needs only a subset of the policy-related objects in the 490 indicated subtrees, then it can be configured with additional 491 selection criteria based on the policyKeywords attribute defined in 492 the policy class. This attribute supports both standardized and 493 administrator-defined values. Thus a PDP could be configured to 494 request only those policy-related objects containing the keywords 495 "DHCP" and "Eastern US". 497 To optimize what is expected to be a typical case, the initial request 498 from the client includes not only the object to which its "seed" DN 499 pointer points, but also the subtree contained under this object. The 500 filter for searching this subtree is whatever the client is going to 501 use later to search the other subtrees: "object class = policy", 502 presence of the keyword "POLICY", or presence of a more specific 503 policyKeyword. 505 Returning to the example in Figure 4, we see that in the best case, a 506 PDP can get all the policy-related objects it needs, and only these 507 objects, with exactly three LDAP requests: one to its starting object 508 A to get the pointers to B and C, as well as the policy-related 509 objects it needs from the subtree under A, and then one each to B and 510 C to get all the policy-related objects that pass the selection 511 criteria with which it was configured. Once it has retrieved all of 512 these objects, the PDP can then traverse their various DN pointers 513 locally to understand the semantic relationships among them. The PDP 514 should also be prepared to find a pointer to another subtree attached 515 to any of the objects it retrieves, and to follow this pointer first, 516 before it follows any of the semantically significant pointers it has 517 received. This recursion permits a structured approach to identifying 518 related policies. In Figure 4, for example, if the subtree under B 519 includes departmental policies and the one under C includes divisional 520 policies, then there might be a pointer from the subtree under C to an 521 object D that roots the subtree of corporate-level policies. 523 Since a PDP has no guarantee that the entity that populates the 524 directory won't use the policySubtreesPtrAuxClass, a PDP SHOULD 525 understand this class, SHOULD be capable of retrieving and processing 526 the entries in the subtrees it points to, and SHOULD be capable of 527 doing all of this recursively. The same requirements apply to any 528 other entity needing to retrieve policy information from the 529 directory. Thus a Policy Management Tool that retrieves policy 530 entries from the directory in order to perform validation and conflict 531 detection SHOULD also understand and be capable of using the 532 policySubtreesPtrAuxClass. All of these requirements are "SHOULD"s 533 rather than "MUST"s because an LDAP client that doesn't implement them 534 can still access and retrieve the directory entries it needs . The 535 process of doing so will just be less efficient than it would have 536 been if the client had implemented these optimizations. 538 When it is serving as a tool for creating policy entries in the 539 directory, a Policy Management Tool SHOULD support creation of 540 policySubtreePrtAuxClass entries and their DN pointers. 542 4.4.1. Aliases 544 Additional flexibility in DIT structure is available to the policy 545 administrator via LDAP aliasing. Figure 5 illustrates this 546 flexibility. 548 +-----+ 549 ---------------->| A | 550 DN pointer to | | DN pointers to subtrees +---+ 551 starting object +-----+ +------------------------->| C | 552 | o--+----+ +---+ +---+ 553 | o--+------------->| B | / \ 554 +-----+ +---+ / \ 555 / \ / \ / ... \ 556 / \ / \ 557 / \ / \ 558 +---+ / +------+ \ 559 | X |<***************************|aliasX| 560 +---+ +------+ 562 Figure 5. Addition of an Alias Object 564 Even if it is necessary to store a policy entry X in a directory 565 location separate from the other policy entries, batch retrieval using 566 policy subtrees can still be done. The administrator simply inserts 567 into one of the subtrees of policy entries an alias entry aliasX 568 pointing to the outlying entry X. When the PDP requests all entries 569 in the subtree under B, a response will be returned for entry X, just 570 as responses are returned for all the (non-alias) entries that 571 actually are in the subtree. 573 Since resolution of an alias to its true entry is handled entirely by 574 the LDAP directory, and is invisible to directory clients, PDPs need 575 not do anything extra to support aliases. A Policy Management Tool 576 MAY make available to a policy administrator the ability to create 577 alias entries like the one in Figure 5. 579 5. Class Definitions 581 The semantics for the LDAP classes mapped directly from the 582 information model are detailed in reference [10]. Consequently, all 583 that this document presents for these classes is a bare specification 584 of the LDAP classes and attributes. More details are provided for the 585 attributes listed above in Figure 3, which realize in LDAP the 586 relationships defined in the information model. Finally, the classes 587 that exist only in the LDAP Core Schema are documented fully in this 588 document. 590 5.1. The Abstract Class "policy" 592 The abstract class policy is a direct mapping of the abstract class 593 Policy from the Core Information Model. The property 594 CreationClassName maps to the LDAP attribute objectClass, which is 595 inherited from "top". The remaining properties in Policy map directly 596 to attributes in the class policy. 598 The class value "policy" is also used as the mechanism for identifying 599 policy-related instances in the Directory Information Tree. An 600 instance of any class may be "tagged" with this class value by 601 attaching to it the auxiliary class policyElement. 603 The class definition is as follows: 605 NAME policy 606 DESCRIPTION An abstract class with four attributes for 607 describing a policy-related instance. 608 DERIVED FROM top 609 TYPE abstract 610 AUXILIARY CLASSES none 611 OID 612 MAY cn caption description policyKeywords 614 The attributes are defined as: 616 NAME commonName (cn) 617 DESCRIPTION A user-friendly name of a policy-related object. 618 SYNTAX DirectoryString 619 OID 2.4.5.3 620 EQUALITY caseIgnoreMatch 621 MULTI-VALUED 623 NAME caption 624 DESCRIPTION A one-line description of this policy-related 625 object. 626 SYNTAX IA5String 627 OID 628 EQUALITY caseExactIA5Match 629 SINGLE-VALUED 630 NAME description 631 DESCRIPTION A long description of this policy-related object. 632 SYNTAX IA5String 633 OID 634 EQUALITY caseExactIA5Match 635 SINGLE-VALUED 637 NAME policyKeywords 638 DESCRIPTION A set of keywords to assist directory clients in 639 locating the policy objects applicable to them. 640 Standard keyword values are listed in the Policy 641 Core Information Model document. 642 SYNTAX IA5String 643 OID 644 EQUALITY caseExactIA5Match 645 MULTI-VALUED 647 5.2. The Class policyGroup 649 The class definition for policyGroup is as follows. Note that this 650 class definition does not include attributes to realize the 651 ContainedPolicyRule and ContainedPolicyGroup associations from the 652 object model, since a policyGroup object points to instances of 653 policyGroup and policyRule via, respectively, the pointer in 654 policyGroupContainmentAuxClass and the pointer in 655 policyRuleContainmentAuxClass. 657 NAME policyGroup 658 DESCRIPTION A container for either a set of related policyRules 659 or a set of related policyGroups. 660 DERIVED FROM top 661 TYPE structural 662 AUXILIARY CLASSES policyGroupContainmentAuxClass, 663 policyRuleContainmentAuxClass 664 POSSIBLE SUPERIORS container, organization, organizationalUnit, 665 policyGroup 666 OID 667 MUST policyGroupName 669 The one attribute of PolicyGroup is defined as: 671 NAME policyGroupName 672 DESCRIPTION The user-friendly name of this policy group. 673 SYNTAX IA5String 674 OID 675 EQUALITY caseExactIA5Match 676 SINGLE-VALUED 678 5.3. The Class policyRule 680 This class represents the "If Condition then Action" semantics 681 associated with a policy. The conditions and actions associated with 682 a policy rule are modeled, respectively, with auxiliary subclasses of 683 the classes policyCondition and policyAction. These auxiliary classes 684 are attached either to an instance of policyRule itself, or to an 685 instance of the structural class policyInstance identified by a DN 686 pointer in an instance of policyRule. 688 Of the ten attributes in the policyRule class, seven are mapped 689 directly from corresponding properties in the information model. The 690 remaining three attributes realize three of the aggregations in the 691 information model. Since the PolicyRuleValidityPeriod aggregation has 692 no "extra" properties (besides those that tie the aggregation to the 693 aggregating and aggregated objects), the attribute 694 policyRuleValidityPeriodList is simply a multi-valued DN pointer. 695 This attribute provides an unordered set of DN pointers to one or more 696 policyTimePeriodConditions, indicating when the policy rule is 697 scheduled to be active and when it is scheduled to be inactive. The 698 rule is scheduled to be active if it is active according to AT LEAST 699 ONE of the policyTimePeriodConditions pointed to by this attribute. 701 The ContainedPolicyCondition and ContainedPolicyAction aggregations, 702 however, have additional properties: ContainedPolicyAction has an 703 integer to sequence the actions, and ContainedPolicyCondition has an 704 integer to group the conditions, and a boolean to specify whether a 705 condition is to be negated. To represent these additional properties, 706 the attributes policyRuleConditionList and policyRuleActionList are 707 defined as "structured DN pointers." A structured DN pointer is, from 708 the point of view of an LDAP directory implementation, a 709 DirectoryString. These DirectoryStrings, however, have embedded in 710 them both a DN pointer and elements to represent the additional 711 properties from the aggregations being mapped. Figures 6 and 7 712 illustrate the mappings: 714 Contained Condition ------------------+ 715 Condition Negated --------------+ | 716 Group Number ---------+ | | 717 | | | 718 V V V 719 :<+|->: policyRuleConditionList 721 Figure 6. Mapping of ContainedPolicyCondition Properties 723 There is one subtlety here. In the element "<+|->", the '+' indicates 724 that the condition is not negated, and the '-' indicates that it is 725 negated. In the information model, however, this information is 726 represented by the boolean-valued property ConditionNegated in the 727 ContainedPolicyCondition aggregation. The mapping between the 728 information model and the LDAP Core Schema is thus: 730 o If ConditionNegated = TRUE (i.e., it's true that the condition is 731 negated), use '-'. 733 o If ConditionNegated = FALSE (i.e., it's false that the condition is 734 negated), use '+'. 736 For example, the Directory String "1:+:DN-C" points to the condition 737 named by DN-C, places it in Group 1, and indicates that it is not 738 negated. 740 Contained Action ---------------+ 741 Action Order ---------+ | 742 | | 743 V V 744 : policyRuleActionList 746 Figure 7. Mapping of ContainedPolicyAction Properties 748 For example, the DirectoryString "2:DN-A" points to the action named 749 by DN-A, and indicates that it is to be performed second. 751 Since these structured DN pointers appear as DirectoryStrings to a 752 directory implementation, the implementation does not apply DN- 753 oriented operations to them. In particular, if a condition or action 754 pointed to by a DN pointer embedded in one of these strings has its 755 name changed, the ModifyDN operation will NOT update the embedded DN 756 pointer. 758 The class definition of policyRule is as follows: 760 NAME policyRule 761 DESCRIPTION The central class for representing the "If 762 Condition then Action" semantics associated with a 763 policy rule. 764 DERIVED FROM top 765 TYPE structural 766 AUXILIARY CLASSES none 767 POSSIBLE SUPERIORS policyGroup 768 OID 769 MUST policyRuleName 770 MAY policyRuleEnabled policyRuleConditionListType 771 policyRuleConditionList policyRuleActionList 772 policyRuleValidityPeriodList policyRuleUsage 773 policyRulePriority policyRuleMandatory 774 policyRuleSequencedActions 776 The attributes of policyRule are as follows: 778 NAME policyRuleName 779 DESCRIPTION The user-friendly name of this policy rule. 780 SYNTAX IA5String 781 OID 782 EQUALITY caseExactIA5Match 783 SINGLE-VALUED 784 NAME policyRuleEnabled 785 DESCRIPTION An enumeration indicating whether a policy rule is 786 administratively enabled, administratively 787 disabled, or enabled for debug mode. The defined 788 values for this attribute are enabled(1), 789 disabled(2), and enabledForDebug(3). 790 SYNTAX INTEGER 791 OID 792 EQUALITY integerMatch 793 SINGLE-VALUED 794 DEFAULT VALUE enabled(1) 796 NAME policyRuleConditionListType 797 DESCRIPTION Indicates whether the list of policy conditions 798 associated with this policy rule is in disjunctive 799 normal form (DNF) or conjunctive normal form (CNF). 800 Defined values are DNF(1) and CNF(2). 801 SYNTAX INTEGER 802 OID 803 EQUALITY integerMatch 804 SINGLE-VALUED 805 DEFAULT VALUE DNF(1) 807 NAME policyRuleConditionList 808 DESCRIPTION An unordered list of strings of the form 809 ':<+|->:', indicating a set of 810 policy conditions that determine when the 811 policyRule is applicable. 812 SYNTAX DirectoryString 813 OID 814 EQUALITY caseIgnoreSubstringsMatch 815 MULTI-VALUED 816 FORMAT :<+|->: 818 NAME policyRuleActionList 819 DESCRIPTION An unordered list of strings of the form 'n:DN', 820 indicating an ordered set of policy actions to be 821 performed if the associated condition(s) of the 822 policyRule evaluates to true. 823 SYNTAX DirectoryString 824 OID 825 EQUALITY caseIgnoreSubstringsMatch 826 MULTI-VALUED 827 FORMAT n:DN 829 NAME policyRuleValidityPeriodList 830 DESCRIPTION Distinguished names of policyTimePeriodConditions 831 that determine when the policyRule is scheduled to 832 be active / inactive. No order is implied. 833 SYNTAX DN 834 OID 835 EQUALITY distinguishedNameMatch 836 MULTI-VALUED 838 NAME policyRuleUsage 839 DESCRIPTION This attribute is used to provide guidelines on how 840 this policy should be used. 841 SYNTAX DirectoryString 842 OID 843 EQUALITY caseIgnoreMatch 844 SINGLE-VALUED 846 NAME policyRulePriority 847 DESCRIPTION A non-negative integer for prioritizing this 848 policyRule relative to other policyRules. A larger 849 value indicates a higher priority. 850 SYNTAX INTEGER 851 OID 852 EQUALITY integerMatch 853 SINGLE-VALUED 854 DEFAULT VALUE 0 856 NAME policyRuleMandatory 857 DESCRIPTION A flag indicating that the evaluation of the 858 policyConditions and execution of policyActions (if 859 the condition list evaluates to True) is required. 860 SYNTAX Boolean 861 OID 862 EQUALITY booleanMatch 863 SINGLE-VALUED 864 DEFAULT VALUE TRUE 866 NAME policyRuleSequencedActions 867 DESCRIPTION An enumeration indicating how to interpret the 868 action ordering indicated via the 869 policyRuleActionList attribute. The defined values 870 for this attribute are mandatory(1), 871 recommended(2), and dontCare(3). 873 SYNTAX INTEGER 874 OID 875 EQUALITY integerMatch 876 SINGLE-VALUED 877 DEFAULT VALUE dontCare(3) 879 5.4. The Class policyCondition 881 The purpose of a policy condition is to determine whether or not the 882 set of actions (contained in the policyRule that the condition applies 883 to) should be executed or not. 885 The class definition is as follows: 887 NAME policyCondition 888 DESCRIPTION A class representing a condition to be evaluated in 889 conjunction with a policy rule. 890 DERIVED FROM top 891 TYPE auxiliary 892 AUXILIARY CLASSES none 893 POSSIBLE SUPERIORS policyRule 894 OID 895 MUST policyConditionName 896 MAY 898 The one attribute definition is as follows: 900 NAME policyConditionName 901 DESCRIPTION The user-friendly name of this policy condition. 902 SYNTAX IA5String 903 OID 904 EQUALITY caseExactIA5Match 905 SINGLE-VALUED 907 5.5. The Class policyTimePeriodCondition 909 This class provides a means of representing the time periods during 910 which a policy rule is valid, i.e., active. The class definition is 911 as follows. Note that instances of this class are named with the 912 attributes cn and policyConditionName that they inherit, respectively, 913 from policy and from policyCondition. 915 NAME policyTimePeriodCondition 916 DESCRIPTION A class that provides the capability of enabling / 917 disabling a policy rule according to a pre- 918 determined schedule. 919 DERIVED FROM policyCondition 920 TYPE auxiliary 921 AUXILIARY CLASSES none 922 POSSIBLE SUPERIORS policyRule 923 OID 924 MUST 925 MAY ptpConditionTime ptpConditionMonthOfYearMask 926 ptpConditionDayOfMonthMask 927 ptpConditionDayOfWeekMask ptpConditionTimeOfDayMask 928 ptpConditionTimeZone 930 The attributes of policyTimePeriodCondition are defined as follows: 932 NAME ptpConditionTime 933 DESCRIPTION The range of calendar dates on which a policy rule 934 is valid. 935 SYNTAX PrintableString 936 OID 937 EQUALITY caseIgnoreMatch 938 SINGLE-VALUED 939 FORMAT [yyyymmddhhmmss]:[yyyymmddhhmmss] 941 NAME ptpConditionMonthOfYearMask 942 DESCRIPTION A mask identifying the months of the year in which 943 a policy rule is valid. 944 SYNTAX Printable String 945 OID 946 EQUALITY caseIgnoreMatch 947 SINGLE-VALUED 948 FORMAT A string of 12 ASCII '0's and '1's. 950 NAME ptpConditionDayOfMonthMask 951 DESCRIPTION A mask identifying the days of the month on which a 952 policy rule is valid. 953 SYNTAX PrintableString 954 OID 955 EQUALITY caseIgnoreMatch 956 SINGLE-VALUED 957 FORMAT A string of 31 ASCII '0's and '1's. 959 NAME ptpConditionDayOfWeekMask 960 DESCRIPTION A mask identifying the days of the week on which a 961 policy rule is valid. 962 SYNTAX PrintableString 963 OID 964 EQUALITY caseIgnoreMatch 965 SINGLE-VALUED 966 FORMAT A string of 7 ASCII '0's and '1's. 968 NAME ptpConditionTimeOfDayMask 969 DESCRIPTION The range of times at which a policy rule is valid. 970 If the second time is earlier than the first, then 971 the interval spans midnight. 972 SYNTAX Printable String 973 OID 974 EQUALITY caseIgnoreMatch 975 SINGLE-VALUED 976 FORMAT hhmmss:hhmmss 978 NAME ptpConditionTimeZone 979 DESCRIPTION The definition of the time zone for the 980 policyTimePeriodCondition. 981 SYNTAX PrintableString 982 OID 983 EQUALITY caseIgnoreMatch 984 SINGLE-VALUED 985 FORMAT either 'Z' (UTC) or <'+'|'-'> 987 5.6. The Class vendorPolicyCondition 989 The class definition is as follows: 991 NAME vendorPolicyCondition 992 DESCRIPTION A class that defines a registered means to describe 993 a policy condition. 994 DERIVED FROM policyCondition 995 TYPE auxiliary 996 AUXILIARY CLASSES none 997 POSSIBLE SUPERIORS policyRule 998 OID 999 MUST vendorPolicyConstraintData 1000 vendorPolicyConstraintEncoding 1001 MAY 1003 The attribute definitions for vendorPolicyCondition are as follows: 1005 NAME vendorPolicyConstraintData 1006 DESCRIPTION Escape mechanism for representing constraints that 1007 have not been modeled as specific attributes. The 1008 format of the values is identified by the OID 1009 stored in the attribute 1010 vendorPolicyConstraintEncoding. 1011 SYNTAX OctetString 1012 OID 1013 EQUALITY octetStringMatch 1014 MULTI-VALUED 1016 NAME vendorPolicyConstraintEncoding 1017 DESCRIPTION An OID identifying the format and semantics for 1018 this instance's vendorPolicyConstraintData 1019 attribute. 1020 SYNTAX OID 1021 OID 1022 EQUALITY objectIdentifierMatch 1023 SINGLE-VALUED 1025 5.7. The Class policyAction 1027 The purpose of a policy action is to execute one or more operations 1028 that will affect network traffic and/or systems, devices, etc. in 1029 order to achieve a desired policy state. 1031 The class definition is as follows: 1033 NAME policyAction 1034 DESCRIPTION A class representing an action to be performed as a 1035 result of a policy rule. 1036 DERIVED FROM top 1037 TYPE auxiliary 1038 AUXILIARY CLASSES none 1039 POSSIBLE SUPERIORS policyRule 1040 OID 1041 MUST policyActionName 1042 MAY 1044 The one attribute definition is as follows: 1046 NAME policyActionName 1047 DESCRIPTION The user-friendly name of this policy action. 1048 SYNTAX IA5String 1049 OID 1050 EQUALITY caseExactIA5Match 1051 SINGLE-VALUED 1053 5.8. The Class vendorPolicyAction 1055 The class definition is as follows: 1057 NAME vendorPolicyAction 1058 DESCRIPTION A class that defines a registered means to describe 1059 a policy action. 1060 DERIVED FROM policyAction 1061 TYPE auxiliary 1062 AUXILIARY CLASSES none 1063 POSSIBLE SUPERIORS policyRule 1064 OID 1065 MUST vendorPolicyActionData vendorPolicyActionEncoding 1066 MAY 1068 The attribute definitions for vendorPolicyAction are as follows: 1070 NAME vendorPolicyActionData 1071 DESCRIPTION Escape mechanism for representing actions that have 1072 not been modeled as specific attributes. The 1073 format of the values is identified by the OID 1074 stored in the attribute vendorPolicyActionEncoding. 1076 SYNTAX OctetString 1077 OID 1078 EQUALITY octetStringMatch 1079 MULTI-VALUED 1081 NAME vendorPolicyActionEncoding 1082 DESCRIPTION An OID identifying the format and semantics for 1083 this instance's vendorPolicyActionData attribute. 1084 SYNTAX OID 1085 OID 1086 EQUALITY objectIdentifierMatch 1087 SINGLE-VALUED 1089 5.9. The Class policyInstance 1091 This class introduces no additional attributes, beyond those defined 1092 in the class policy from which it is derived. Its role in the Core 1093 Schema is to serve as the structural class to which the auxiliary 1094 classes policyCondition and policyAction may be attached when the 1095 complex policy rule structure is required. With its attached 1096 auxiliary class, an instance of policyInstance represents a single 1097 policy condition or a single policy action, but not both. 1099 An instance of this class is named by an attribute it acquires via an 1100 attached auxiliary class. In the Core Schema, the naming attributes 1101 available for this purpose are policyConditionName and 1102 policyActionName. 1104 The class definition is as follows: 1106 NAME policyInstance 1107 DESCRIPTION A structural class to which the auxiliary classes 1108 policyCondition and policyAction may be attached, 1109 when the complex policy rule structure is required. 1110 DERIVED FROM policy 1111 TYPE structural 1112 AUXILIARY CLASSES policyCondition, policyAction 1113 OID 1115 5.10. The Auxiliary Class policyElement 1117 Like policyInstance, this class also introduces no additional 1118 attributes, beyond those defined in the class policy from which it is 1119 derived. Its role is to "tag" an instance of a class defined outside 1120 the realm of policy as being nevertheless relevant to a policy 1121 specification. This tagging can potentially take place at two levels: 1123 o Every instance to which policyElement is attached becomes an 1124 instance of the class policy, since policyElement is a subclass of 1125 policy. Thus a DIT search with the filter "objectClass=policy" 1126 will return the instance. (As noted earlier, this approach does 1127 not work for some directory implementations. To accommodate these 1128 implementations, policy-related entries SHOULD be tagged with the 1129 keyword "POLICY".) 1131 o With the policyKeywords attribute that it inherits from policy, an 1132 instance to which policyElement is attached can be tagged as being 1133 relevant to a particular type or category of policy, using standard 1134 keywords, administrator-defined keywords, or both. 1136 The class definition is as follows: 1138 NAME policyElement 1139 DESCRIPTION An auxiliary class used to tag instances of classes 1140 defined outside the realm of policy as relevant to 1141 a particular policy specification. 1142 DERIVED FROM policy 1143 TYPE auxiliary 1144 AUXILIARY CLASSES none 1145 OID 1147 5.11. The Auxiliary Class policySubtreesPtrAuxClass 1149 This auxiliary class provides a single, multi-valued attribute that 1150 points to a set of objects that are at the root of DIT subtrees 1151 containing policy-related information. By attaching this attribute to 1152 instances of various other classes, a policy administrator has a 1153 flexible way of providing an entry point into the directory that 1154 allows a client to locate and retrieve the policy information relevant 1155 to it. 1157 These entries may be placed in the DIT such that a well-known DN can 1158 be used by placing the structural entry (e.g. container) with the 1159 policySubtreesPtrAuxClass attached thereto in the root of the 1160 directory suffix. In this case, the subtree entry point can contain 1161 and/or point to all related policy entries for any well-known policy 1162 disciplines. Similarly, the subtree entry point may be placed in the 1163 DIT such that the PDPs starting point is a subtree with policy-related 1164 entries that are dependent on a hierarchically-related set of subtrees 1165 (e.g., region, division, corporate). In this latter case, DNs may be 1166 provided to the PDPs via SNMP or other techniques. 1168 This object does not provide the semantic linkages between individual 1169 policy objects, such as those between a policy group and the policy 1170 rules that belong to it. Its only role is to enable efficient bulk 1171 retrieval of policy-related objects, as described in Section 4.4. 1172 Once the objects have been retrieved, a directory client can determine 1173 the semantic linkages by following DN pointers such as 1174 policyRulesAuxContainedSet locally. 1176 Since policy-related objects will often be included in the DIT subtree 1177 beneath an object to which this auxiliary class is attached, a client 1178 SHOULD request the policy-related objects from the subtree under the 1179 object with these pointers at the same time that it requests the 1180 pointers themselves. Since policySubtreesPtrAuxClass is a subclass of 1181 the abstract class "policy", this can be accomplished with a single 1182 search operation with scope set to subtree and a filter set to select 1183 policy-related objects. 1185 Since clients are expected to behave in this way, the policy 1186 administrator SHOULD make sure that this subtree does not contain so 1187 many objects unrelated to policy that an initial search done in this 1188 way results in a performance problem. For example, 1189 policySubtreesPtrAuxClass SHOULD NOT be attached to the partition root 1190 for a large directory partition containing a relatively few policy- 1191 related objects along with a large number of objects unrelated to 1192 policy. A better approach would be to introduce a container object 1193 immediately below the partition root, attach policySubtreesPtrAuxClass 1194 to this container object, and then place the policy-related objects in 1195 the subtree under it. 1197 The class definition is as follows: 1199 NAME policySubtreesPtrAuxClass 1200 DESCRIPTION An auxiliary class providing a DN pointer to roots 1201 of DIT subtrees contained policy-related objects. 1202 DERIVED FROM top 1203 TYPE auxiliary 1204 AUXILIARY CLASSES none 1205 OID 1206 MUST policySubtreesAuxContainedSet 1208 5.11.1. The Attribute policySubtreesAuxContainedSet 1210 This attribute provides an unordered set of DN pointers to one or more 1211 objects under which policy-related information is present. The 1212 objects pointed to may or may not themselves contain policy-related 1213 information. 1215 The attribute definition is as follows: 1217 NAME policySubtreesAuxContainedSet 1218 DESCRIPTION Distinguished names of objects that serve as roots 1219 for DIT subtrees containing policy-related objects. 1220 No order is implied. 1221 SYNTAX DN 1222 OID 1223 EQUALITY distinguishedNameMatch 1224 MULTI-VALUED 1226 5.12. The Auxiliary Class policyGroupContainmentAuxClass 1228 This auxiliary class provides a single, multi-valued attribute that 1229 points to a set of policyGroups. By attaching this attribute to 1230 instances of various other classes, a policy administrator has a 1231 flexible way of providing an entry point into the directory that 1232 allows a client to locate and retrieve the policyGroups relevant to 1233 it. 1235 As is the case with policyRules, a policy administrator might have 1236 several different pointers to a policyGroup in the overall directory 1237 structure. The policyGroupContainmentAuxClass is the mechanism that 1238 makes it possible for the policy administrator to define all these 1239 pointers. 1241 The class definition is as follows: 1243 NAME policyGroupContainmentAuxClass 1244 DESCRIPTION An auxiliary class used to bind policyGroups 1245 to an appropriate container object. 1246 DERIVED FROM top 1247 TYPE auxiliary 1248 AUXILIARY CLASSES none 1249 OID 1250 MUST policyGroupsAuxContainedSet 1252 5.12.1. The Attribute policyGroupsAuxContainedSet 1254 This attribute provides an unordered set of DN pointers to one or more 1255 policyGroups associated with the instance of a structural class to 1256 which this attribute has been appended. The attribute definition is 1257 as follows: 1259 NAME policyGroupsAuxContainedSet 1260 DESCRIPTION Distinguished names of policyGroups associated in 1261 some way with the instance to which this attribute 1262 has been appended. No order is implied. 1263 SYNTAX DN 1264 OID 1265 EQUALITY distinguishedNameMatch 1266 MULTI-VALUED 1268 5.13. The Auxiliary Class policyRuleContainmentAuxClass 1270 This auxiliary class provides a single, multi-valued attribute that 1271 points to a set of policyRules. By attaching this attribute to 1272 instances of various other classes, a policy administrator has a 1273 flexible way of providing an entry point into the directory that 1274 allows a client to locate and retrieve the policyRules relevant to it. 1276 A policy administrator might have several different pointers to a 1277 policyRule in the overall directory structure. For example, there 1278 might be pointers to all policyRules for traffic originating in a 1279 particular subnet from a directory entry that represents that subnet. 1280 At the same time, there might be pointers to all policyRules related 1281 to a particular DiffServ setting from an instance of a policyGroup 1282 explicitly introduced as a container for DiffServ-related policyRules. 1283 The policyRuleContainmentAuxClass is the mechanism that makes it 1284 possible for the policy administrator to define all these pointers. 1286 Note that the cn attribute does NOT need to be defined for this class. 1287 This is because an auxiliary class is used as a means to collect 1288 common attributes and treat them as properties of an object. A good 1289 analogy is a #include file, except that since an auxiliary class is a 1290 class, all the benefits of a class (e.g., inheritance) can be applied 1291 to an auxiliary class. 1293 The class definition is as follows: 1295 NAME policyRuleContainmentAuxClass 1296 DESCRIPTION An auxiliary class used to bind policyRules to an 1297 appropriate container object. 1298 DERIVED FROM top 1299 TYPE auxiliary 1300 AUXILIARY CLASSES none 1301 OID 1302 MUST policyRulesAuxContainedSet 1304 5.13.1. The Attribute policyRulesAuxContainedSet 1306 This attribute provides an unordered set of DN pointers to one or more 1307 policyRules associated with the instance of a structural class to 1308 which this attribute has been appended. The attribute definition is: 1310 NAME policyRulesAuxContainedSet 1311 DESCRIPTION Distinguished names of policyRules associated in 1312 some way with the instance to which this attribute 1313 has been appended. No order is implied. 1314 SYNTAX DN 1315 OID 1316 EQUALITY distinguishedNameMatch 1317 MULTI-VALUED 1319 6. Extending the Core Schema 1321 The following subsections provide general guidance on how to create a 1322 domain-specific schema derived from the Core Schema, discuss how the 1323 vendor classes in the Core Schema should be used, and explain how 1324 policyTimePeriodConditions are related to other policy conditions. 1326 6.1. Subclassing policyCondition and policyAction 1328 In Section 4.3 above, there is a discussion of how, by representing 1329 policy conditions and policy actions as auxiliary classes in a schema, 1330 the flexibility is retained to instantiate a particular policy as 1331 either a simple policy rule or a complex one. This flexibility is 1332 lost if a schema takes either of two "hard-coded" paths: 1334 o If the schema subclasses policyRule to add domain-specific 1335 characteristics that implicitly express a policy condition, a 1336 policy action, or both, then the schema supports only the simple 1337 policy rule form. 1339 o If the schema introduces structural subclasses of policyCondition, 1340 policyAction, or both, then the schema supports only the complex 1341 policy rule form. 1343 Even if the authors of a domain-specific schema can only envision one 1344 of these forms of policy rules being used when the schema is 1345 instantiated, it costs nothing extra to express the schema as 1346 auxiliary subclasses of policyCondition and policyAction. For 1347 standardized schemata, this document specifies that domain-specific 1348 information MUST be expressed in auxiliary subclasses of 1349 policyCondition and policyAction. It is RECOMMENDED that non- 1350 standardized schemata follow this practice as well. 1352 6.2. Using the Vendor Policy Encoding Attributes 1354 As discussed Section 5.6 "The Class vendorPolicyCondition", the 1355 attributes vendorPolicyConstraintData and 1356 vendorPolicyConstraintEncoding are included in the 1357 vendorPolicyCondition to provide an escape mechanism for representing 1358 "exceptional" policy conditions. The attributes 1359 vendorPolicyActionData and vendorPolicyActionEncoding in the 1360 vendorPolicyAction class play the same role with respect to actions. 1361 This enables interoperability between different vendors. 1363 For example, imagine a network composed of access devices from vendor 1364 A, edge and core devices from vendor B, and a policy server from 1365 vendor C. It is desirable for this policy server to be able to 1366 configure and manage all of the devices from vendors A and B. 1367 Unfortunately, these devices will in general have little in common 1368 (e.g., different mechanisms, different ways for controlling those 1369 mechanisms, different operating systems, different commands, and so 1370 forth). The escape conditions provide a way for vendor-specific 1371 commands to be encoded as OctetStrings, so that devices from different 1372 vendors can be commonly managed by a single policy server. 1374 6.3. Using Time Validity Periods 1376 Time validity periods are defined as a subclass of policyCondition, 1377 called policyTimePeriodCondition. This is to allow their inclusion in 1378 the AND/OR condition definitions for a policyRule. Care should be 1379 taken not to subclass policyTimePeriodCondition to add domain-specific 1380 condition properties. For example, it would be incorrect to add 1381 IPSec- or QoS-specific condition properties to the 1382 policyTimePeriodCondition class, just because IPSec or QoS includes 1383 time in its condition definition. The correct subclassing would be to 1384 create IPSec or QoS-specific subclasses of policyCondition and then 1385 combine instances of these domain-specific condition classes with the 1386 validity period criteria. This is accomplished using the AND/OR 1387 aggregation capabilities for policyConditions in policyRules. 1389 7. Security Considerations 1391 o General: See reference [10]. 1393 o Users: See reference [10]. 1395 o Administrators of Schema: In general, most LDAP-accessible 1396 directories do not permit old or out-of-date schemas, or schema 1397 elements to be deleted. Instead, they are rendered inactive. This 1398 makes it that much more important to get it right the first time on 1399 an operational system, in order to avoid complex inactive schema 1400 artifacts from lying about in the operational directory. The good 1401 news is that it is expected that large network operators will 1402 change schema design infrequently, and, when they do, the schema 1403 creation changes will be tested on an off-line copy of the 1404 directory before the operational directory is updated. Typically, 1405 a small group of directory schema administrators will be authorized 1406 to make these changes in a service provider or enterprise 1407 environment. The ability to maintain audit trails is also required 1408 here. 1410 o Administrators of Schema Content (Directory Entries): This group 1411 requires authorization to load values (entries) into a policy 1412 repository directory schema, i.e. read/write access. An audit 1413 trail capability is also required here. 1415 o Applications and PDPs: These entities must be authorized for read- 1416 only access to the policy repository directory, so that they may 1417 acquire policy for the purposes of passing it to their respective 1418 enforcement entities. 1420 o Security Disciplines: 1422 o Audit Trail (Non-repudiation): In general, standardizing 1423 mechanisms for non-repudiation is outside the scope of the IETF; 1424 however, we can certainly document the need for this function in 1425 systems which maintain and distribute policy. The dependency for 1426 support of this function is on the implementers of these systems, 1427 and not on any specific standards for implementation. The 1428 requirement for a policy system is that a minimum level of 1429 auditing via an auditing facility must be provided. Logging 1430 should be enabled. This working group will not specify what this 1431 minimal auditing function consists of. 1433 o Access Control/Authorization: Access Control List (ACL) 1434 functionality must be provided. Standards for directories which 1435 use LDAPv3 as an access mechanism are still being worked on in 1436 the LDAPext working group, as of this writing. The two 1437 administrative sets of users documented above will form the basis 1438 for two administrative use cases which require support. 1440 o Authentication: In the LDAP-accessible directory case, both TLS 1441 and Kerboros are acceptable for authentication. Existing LDAP 1442 implementations provide these functions within the context of the 1443 BIND request, which is adequate. We advise against using weaker 1444 mechanisms, such as clear text and HTTP Digest. Mutual 1445 authentication is recommended. The LDAPv3 protocol supports 1446 this, but implementations vary in the functionality that they 1447 support. 1449 o Integrity/Privacy: In the LDAP-accessible directory case, TLS 1450 is acceptable for encryption and data integrity on the wire. If 1451 physical or virtual access to the policy repository is in 1452 question, it may also be necessary to encrypt the policy data as 1453 it is stored on the file system; however, specification of 1454 mechanisms for this purpose are outside the scope of this 1455 working group. In any case, we recommend that the physical 1456 server be located in a physically secure environment. 1458 In the case of PDP-to-PEP communications, the use of IPSEC is 1459 recommended for providing confidentiality, data origin 1460 authentication, integrity and replay prevention. See [RAPFRAME] 1461 reference. 1463 o Denial of Service: We recommend the use of multiple policy 1464 repository directories, such that a denial of service attack on any 1465 one directory server will not make all policy data inaccessible to 1466 legitimate users. However, this still leaves a denial of service 1467 attack exposure. Our belief is that the use of a policy schema, in 1468 a centrally administered but physically distributed policy 1469 directory, does not increase the risk of denial of service attacks; 1470 however, such attacks are still possible. If executed 1471 successfully, such an attack could prevent PDP�s from accessing a 1472 policy repository, and thus prevent them from acquiring new policy. 1473 In such a case, the 1474 PDP�s, and associated PEP�s would continue operating under the 1475 policies in force before the denial of service attack was launched. 1476 Note that exposure of policy systems to denial of service attacks 1477 is not any greater than the exposure of DNS with DNSSEC in place. 1479 o Other LDAP-accessible Directory Schema Considerations: 1481 o Replication: Replication among directory copies across servers 1482 should also be protected. Replicating over connections secured 1483 by SSL or IPSEC is recommended. 1485 8. Intellectual Property 1487 The IETF takes no position regarding the validity or scope of any 1488 intellectual property or other rights that might be claimed to pertain 1489 to the implementation or use of the technology described in this 1490 document or the extent to which any license under such rights might or 1491 might not be available; neither does it represent that it has made any 1492 effort to identify any such rights. Information on the IETF's 1493 procedures with respect to rights in standards-track and standards- 1494 related documentation can be found in BCP-11. 1496 Copies of claims of rights made available for publication and any 1497 assurances of licenses to be made available, or the result of an 1498 attempt made to obtain a general license or permission for the use of 1499 such proprietary rights by implementers or users of this specification 1500 can be obtained from the IETF Secretariat. 1502 The IETF invites any interested party to bring to its attention any 1503 copyrights, patents or patent applications, or other proprietary 1504 rights which may cover technology that may be required to practice 1505 this standard. Please address the information to the IETF Executive 1506 Director. 1508 9. Acknowledgments 1510 This document is closely aligned with the work being done in the 1511 Distributed Management Task Force (DMTF) Service Level Agreements and 1512 Networks working groups. As noted, the Core Schema described here was 1513 initially defined in references [2] and [3]. We would especially like 1514 to thank Raju Rajan, Sanjay Kamat, Andrea Westerinen, Lee Rafalow, Raj 1515 Yavatkar, Glenn Waters, David Black, Michael Richardson, Mark Stevens, 1516 David Jones, and Hugh Mahon for their helpful comments. 1518 10. References 1520 [1] J. Strassner and E. Ellesson, "Terminology for describing network 1521 policy and services", draft-strassner-policy-terms-02.txt, June 1522 1999. 1524 [2] Bhattacharya, P., and R. Adams, W. Dixon, R. Pereira, R. Rajan, "An 1525 LDAP Schema for Configuration and Administration of IPSec based 1526 Virtual Private Networks (VPNs)", Internet-Draft work in progress, 1527 October 1998 1529 [3] Rajan, R., and J. C. Martin, S. Kamat, M. See, R. Chaudhury, D. 1530 Verma, G. Powers, R. Yavatkar, "Schema for Differentiated Services 1531 and Integrated Services in Networks", Internet-Draft work in 1532 progress, October 1998 1534 [4] J. Strassner and S. Judd, "Directory-Enabled Networks", version 1535 3.0c5 (August 1998). 1537 [5] Bradner, S., "Key words for use in RFCs to Indicate Requirement 1538 Levels", BCP 14, RFC 2119, March 1997. 1540 [6] Hovey, R., and S. Bradner, "The Organizations Involved in the IETF 1541 Standards Process", BCP 11, RFC 2028, October 1996. 1543 [7] Wahl, M., and S. Kille, T. Howes, "Lightweight Directory Access 1544 Protocol (v3): UTF-8 String Representation of Distinguished 1545 Names", RFC 2253, December 1997. 1547 [8] J. Strassner, policy architecture BOF presentation, 42nd IETF 1548 Meeting, Chicago, Illinois, October, 1998 1550 [9] DMTF web site, http://www.dmtf.org. 1552 [10] Moore B., and E. Ellesson, J. Strassner, "Policy Framework Core 1553 Information Model", draft-ietf-policy-core-info-model-00.txt, June 1554 1999. 1556 11. Authors' Addresses 1558 John Strassner 1559 Cisco Systems, Bldg 1 1560 170 West Tasman Drive 1561 San Jose, CA 95134 1562 Phone: +1 408-527-1069 1563 Fax: +1 408-527-1722 1564 E-mail: johns@cisco.com 1566 Ed Ellesson 1567 IBM Corporation, JDGA/501 1568 4205 S. Miami Blvd. 1569 Research Triangle Park, NC 27709 1570 Phone: +1 919-254-4115 1571 Fax: +1 919-254-6243 1572 E-mail: ellesson@raleigh.ibm.com 1574 Bob Moore 1575 IBM Corporation, JDGA/501 1576 4205 S. Miami Blvd. 1577 Research Triangle Park, NC 27709 1578 Phone: +1 919-254-4436 1579 Fax: +1 919-254-6243 1580 E-mail: remoore@us.ibm.com 1582 12. Full Copyright Statement 1584 Copyright (C) The Internet Society (1999). All Rights Reserved. 1586 This document and translations of it may be copied and furnished to 1587 others, and derivative works that comment on or otherwise explain it 1588 or assist in its implementation may be prepared, copied, published and 1589 distributed, in whole or in part, without restriction of any kind, 1590 provided that the above copyright notice and this paragraph are 1591 included on all such copies and derivative works. However, this 1592 document itself may not be modified in any way, such as by removing 1593 the copyright notice or references to the Internet Society or other 1594 Internet organizations, except as needed for the purpose of developing 1595 Internet standards in which case the procedures for copyrights defined 1596 in the Internet Standards process must be followed, or as required to 1597 translate it into languages other than English. 1599 The limited permissions granted above are perpetual and will not be 1600 revoked by the Internet Society or its successors or assigns. 1602 This document and the information contained herein is provided on an 1603 "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING 1604 TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT 1605 NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN 1606 WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF 1607 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.