RFC 3835
An Architecture for Open Pluggable Edge Services (OPES)
RFC 3835: An Architecture for Open Pluggable Edge Services (OPES) 💖
okay bestie, so this is RFC 3835 and its title is An Architecture for Open Pluggable Edge Services (OPES) 🏛️ It was published in August 2004 by the Network Working Group, and it's Informational 📘 which means it's sharing info, not a formal standard. The authors are A. Barbir (Nortel Networks), R. Penno (Nortel Networks), R. Chen (AT&T Labs), M. Hofmann (Bell Labs/Lucent Technologies), and H. Orman (Purple Streak Development) 🫶 The title block doesn't list any document it obsoletes or updates.
Status of This Memo
this memo provides information for the Internet community 🌸 it does not specify an Internet standard of any kind. distribution of this memo is unlimited ✨
Copyright Notice
Copyright (C) The Internet Society (2004).
Abstract
this memo defines an architecture that enables the creation of an application service in which a data provider, a data consumer, and zero or more application entities cooperatively implement a data stream service 🧚
Table of Contents
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . 2
2 . The Architecture . . . . . . . . . . . . . . . . . . . . . . . 3
2.1. OPES Entities. . . . . . . . . . . . . . . . . . . . . . 3
2.1.1. Data Dispatcher. . . . . . . . . . . . . . . . . 5
2.2. OPES Flows . . . . . . . . . . . . . . . . . . . . . . . 6
2.3. OPES Rules . . . . . . . . . . . . . . . . . . . . . . . 6
2.4. Callout Servers. . . . . . . . . . . . . . . . . . . . . 7
2.5. Tracing Facility . . . . . . . . . . . . . . . . . . . . 8
3. Security and Privacy Considerations . . . . . . . . . . . . . 9
3.1. Trust Domains. . . . . . . . . . . . . . . . . . . . . . 9
3.2. Establishing Trust and Service Authorization . . . . . . 11
3.3. Callout Protocol . . . . . . . . . . . . . . . . . . . . 11
3.4. Privacy. . . . . . . . . . . . . . . . . . . . . . . . . 12
3.5. End-to-end Integrity . . . . . . . . . . . . . . . . . . 12
4. IAB Architectural and Policy Considerations for OPES . . . . . 12
4.1. IAB consideration (2.1) One-party Consent. . . . . . . . 12
4.2. IAB consideration (2.2) IP-Layer Communications. . . . . 13
4.3. IAB consideration (3.1 and 3.2) Notification . . . . . . 13
4.4. IAB consideration (3.3) Non-Blocking . . . . . . . . . . 13
4.5. IAB consideration (4.1) URI Resolution . . . . . . . . . 13
4.6. IAB consideration (4.2) Reference Validity . . . . . . . 13
4.7. IAB consideration (4.3) Application Addressing
Extensions . . . . . . . . . . . . . . . . . . . . . . . 14
4.8. IAB consideration (5.1) Privacy. . . . . . . . . . . . . 14
5. Security Considerations . . . . . . . . . . . . . . . . . . . 14
6. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 14
7. Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
8. References . . . . . . . . . . . . . . . . . . . . . . . . . . 15
8.1. Normative References . . . . . . . . . . . . . . . . . . 15
8.2. Informative References . . . . . . . . . . . . . . . . . 15
9. Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . 15
10. Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . 16
11. Full Copyright Statement . . . . . . . . . . . . . . . . . . . 171. Introduction ✨
okay so picture this: a provider is sending a data stream to a consumer, and sometimes you need other application entities in the mix too, not just the two of them 💅 for example, somebody might want to customize a stream for a consumer based on what that consumer can handle, like its display capabilities 📱
sometimes it's lowkey better to do that customization at a network location between the provider and the consumer host, instead of at one of the endpoints 🦋 for certain services done on behalf of the end-user, that might be the only way to deploy it 😭 so zero or more extra application entities can join the data stream service. there are so many provisioning scenarios that make a data stream service super attractive 🌈 The OPES Use Cases and Deployment Scenarios [1] document has examples of OPES services: ones that modify requests, ones that modify responses, and ones that create responses. It is recommended that the document on OPES Use Cases and Deployment Scenarios [1] be read before reading this document 📖
this document presents the architectural components of Open Pluggable Edge Services (OPES) that are needed in order to perform a data stream service 🧩 The architecture addresses the IAB considerations described in [2]. these considerations are covered in various parts of the document. Section 2.5 addresses tracing, and section 3 addresses security considerations. Section 4 provides a summary of IAB considerations and how the architecture addresses them 💜
the document is organized like this: Section 2 introduces the OPES architecture. Section 3 discusses OPES security and privacy considerations. Section 4 addresses IAB considerations for OPES. Section 5 discusses security considerations. Section 6 addresses IANA considerations. Section 7 provides a summary of the architecture and the requirements for interoperability 🎀
2. The Architecture
the architecture of Open Pluggable Edge Services (OPES) can be described in terms of three interrelated concepts, mainly 🧠
- OPES entities: processes operating in the network;
- OPES flows: data flows that are cooperatively realized by the OPES entities; and,
- OPES rules: these specify when and how to execute OPES services.
2.1. OPES Entities
an OPES entity is an application that operates on a data flow between a data provider application and a data consumer application. OPES entities can be:
- an OPES service application, which analyzes and possibly transforms messages exchanged between the data provider application and the data consumer application;
- a data dispatcher, which invokes an OPES service application based on an OPES ruleset and application-specific knowledge.
the cooperative behavior of OPES entities adds extra functionality to each data flow, as long as it matches the OPES rules 🌸 In the network, OPES entities live inside OPES processors. In the current work, an OPES processor MUST include a data dispatcher. Furthermore, the data provider and data consumer applications are not considered OPES entities 🙈
to provide verifiable system integrity (see section 3.1 on trust domains below) and to make end-to-end encryption and data integrity control easier to deploy 🔐, OPES processors MUST be:
- explicitly addressable at the IP layer by the end user (data consumer application). This requirement does not preclude a chain of OPES processors, with the first one in the chain explicitly addressed at the IP layer by the end user (data consumer application).
- consented to by either the data consumer or data provider application. The details of this process are beyond the scope of the current work.
the OPES architecture is largely independent of the protocol that the data provider application and the data consumer application use to exchange data 🦋 However, this document selects HTTP [3] as the example for the underlying protocol in OPES flows.
2.1.1. Data Dispatcher
data dispatchers include a ruleset that can be compiled from several sources, and it MUST resolve into an unambiguous result 🧚 The combined ruleset lets an OPES processor figure out which service applications to invoke for which data flow. So the data dispatcher is basically an enhanced policy enforcement point, where policy rules get evaluated and service-specific data handlers and state information are maintained, as shown in Figure 1 👑
+----------+
| callout |
| server |
+----------+
||
||
||
||
+--------------------------+
| +-----------+ || |
| | OPES | || |
| | service | || |
| |application| || |
| +-----------+ || |
| +----------------------+ |
OPES flow <---->| | data dispatcher and | |<----> OPES flow
| | policy enforcement | |
| +----------------------+ |
| OPES |
| processor |
+--------------------------+
Figure 1: Data Dispatchersthe architecture allows for more than one policy enforcement point to be present on an OPES flow 💖
2.2. OPES Flows
an OPES flow is a cooperative undertaking between a data provider application, a data consumer application, zero or more OPES service applications, and one or more data dispatchers 🫶
since policies are enforced by data dispatchers, the presence of at least one data dispatcher is required in the OPES flow 📋
data OPES OPES data
consumer processor A processor N provider
+-----------+ +-----------+ . +-----------+ +-----------+
| data | | OPES | . | OPES | | data |
| consumer | | service | . | service | | provider |
|application| |application| . |application| |application|
+-----------+ +-----------+ . +-----------+ +-----------+
| | | | . | | | |
| HTTP | | HTTP | . | HTTP | | HTTP |
| | | | . | | | |
+-----------+ +-----------+ . +-----------+ +-----------+
| TCP/IP | | TCP/IP | . | TCP/IP | | TCP/IP |
+-----------+ +-----------+ . +-----------+ +-----------+
|| || || . || || ||
================ =====.======== ===========
| <----------------- OPES flow -------------------> |
Figure 2: An OPES flowFigure 2 shows two data dispatchers present in the OPES flow 🌈 the architecture allows for one or more data dispatchers to be present in any flow ✨
🎀 to be continued: part 2 is coming, bestie! 🎀
2.3. OPES Rules
okay so 🎀 OPES decides how it treats your data based on a ruleset 💅. The ruleset is made of OPES rules, and each rule is a set of conditions plus the actions that go with them. Together they're the superset of all OPES rules on the processor, and they decide which service applications get to operate on a data stream ✨. In this model, all data dispatchers are invoked for all flows 🦋.
To keep things predictable 🧚, the OPES architecture requires a standardized schema for defining and interpreting the ruleset 📋. It does not require any particular way of loading a ruleset into a data dispatcher 🌸. That's a local matter for each implementation, like using a text editor or a secure upload protocol, as long as the method follows the requirements in section 3 🫶.
2.4. Callout Servers
The OPES ruleset gets evaluated to decide which service applications will operate on a data stream 💖. How that evaluation works is not the focus of the architecture, except that it MUST result in the same unambiguous result in all implementations 🔥.
Sometimes it's useful for the OPES processor to spread out the service work by talking to one or more callout servers 🌈. A data dispatcher calls on a callout server's services using the OPES callout protocol (OCP) 📞. The requirements for the OCP are in [5]. The OCP is application-agnostic 🙈, so it doesn't know the semantics of the protocol it's wrapping (HTTP, for example). Still, the data dispatcher MUST incorporate a service aware vectoring capability that parses the data flow according to the ruleset and delivers the data to either the local or remote OPES service application 👑.
Figure 3 shows the whole setup and how the different OPES pieces are positioned and interact 🦋.
+--------------------------+
| +-----------+ |
| | OPES | |
| | service | | +---------------+ +-----------+
| |application| | | Callout | | Callout |
| +-----------+ | | Server A | | Server X |
| || | | +--------+ | | |
| +----------------------+ | | | OPES | | | |
| | data dispatcher | | | | Service| | | +--------+|
| +----------------------+ | | | Appl A | | | | OPES ||
| || || | | +--------+ | | |Service ||
| +---------+ +-------+ | | || | | | Appl X ||
| | HTTP | | | | | +--------+ | ... | +--------||
| | | | OCP |=========| | OCP | | | || |
| +---------+ +-------+ | | +--------+ | | +------+ |
| | | || | +---------------+ | | OCP | |
| | TCP/IP | =======================================| | |
| | | | | +------+ |
| +---------+ | +-----------+
+--------||-||-------------+
|| ||
+--------+ || || +--------+
|data |== =========================================|data |
|producer| |consumer|
+--------+ +--------+
Figure 3: Interaction of OPES Entities2.5. Tracing Facility
Okay this one is about receipts 🧾✨ Each data dispatcher is required to provide tracing facilities so the right people can verify it's doing its job 🔍. Tracing has to be possible on the OPES flow, per OPES processor, using in-band annotation 💜. One of those annotations could be a URI pointing to more detailed info on the OPES services running in that flow 🌸.
In-band annotation MAY require header extensions on the application protocol in use (HTTP, for example) 🎀. Here's the important part though: an OPES processor in the request/response flow SHALL NOT interfere with non-OPES aware clients and servers 🫶. Those clients and servers don't need to support these extensions to the base protocol 💅.
OPES processors MUST obey the tracing, reporting, and notification requirements set by the center of authority in their trust domain 👑. As part of that, an OPES processor may be told to reject or ignore requirements that come from other trust domains 🙅♀️.
3. Security and Privacy Considerations
Okay bestie, this is the serious part 😭🔐 Every data flow MUST be secured under several policies 🛡️. The primary stakeholders are the data consumer and the data provider 💖. The secondary stakeholders are the entities they may have delegated their trust to 🤝. The other stakeholders are the owners of the callout servers 🧚. Any of these parties might be in the OPES flow 🌈.
These parties MUST have a model of their trust policy, explicit or implicit 📜. That model covers which of the other parties they trust to operate on their data and what security enhancements they need for communication 🔒. Trust can be delegated for all data, or it can be restricted all the way down to an application data unit 🎯.
All parties involved in enforcing policies MUST communicate those policies to the parties involved 📣. Those parties are trusted to adhere to the communicated policies 💅.
To delegate fine-grained trust, the parties MUST convey policy information by implicit contract, by a setup protocol, by a dynamic negotiation protocol, or in-line with application data headers 🧵.
3.1. Trust Domains
Delegation of authority starts at either a data consumer or a data provider and moves out to more distant entities in a "stepwise" way 🪜. Stepwise means A delegates to B, B delegates to C, and so on 🔗. The entities that get "colored" by the delegation form a trust domain with respect to the original delegating party 🌈. The only colors defined are "provider" and "consumer" 🎨. So if the first step in the chain is the data provider, the chain gets that "provider" color 🩷. Delegation of authority (coloring) propagates from the content producer start of authority or from the content consumer start of authority, which may be different from the endpoints in the data flow 💜.
Figure 4 shows administrative domains, out-of-band rules, and policy distribution 🗺️.
provider administrative domain consumer administrative domain
+------------------------------+ +-------------------------------+
| +--------------+ | | +--------------+ |
| |Provider | <- out-of-band rules, -> |Consumer | |
| |Administrative|~~>~~~: policies and ~<~|Administrative| |
| |Authority | : service authorization : |Authority | |
| +--------------+ : | | : +--------------+ |
| : : | | : : |
| : : | | : : |
| +----------+ : | | : +----------+ |
| | callout | +---------+ | | +---------+ | callout | |
| | server |====| | | | | |====| server | |
| +----------+ | | | | | | +----------+ |
| | OPES | | | | OPES | |
| +----------+ |processor| | | |processor| +----------+ |
| | | | | | | | | | | |
| | data | | | | | | | | data | |
| | provider | | | | | | | | consumer | |
| | | +---------+ | | +---------+ +----------+ |
| +----------+ || || | | || || +----------+ |
| || || || | | || || || |
| ============= ================= =========== |
| | | |
+-------------------------------+ +-------------------------------+
| <----------------- OPES flow -----------------> |
Figure 4: OPES administrative domains and policy distributionTo understand trust relationships between OPES entities, each one is labeled as residing in an administrative domain 🏷️. Entities tied to a given OPES flow can live in one or more administrative domains 🏠.
An OPES processor can be in several trust domains at any time 🌟. There's no restriction on whether OPES processors are authorized by data consumers and/or data providers 💁. The original party gets to decide whether to forbid redelegation or limit it 🚫.
An OPES processor MUST have a representation of its trust domain memberships that it can report in whole or in part for tracing purposes 📊. It MUST include the name of the party that delegated each privilege to it 🏷️.
3.2. Establishing Trust and Service Authorization
The OPES processor will have a configuration policy that says what privileges the callout servers have and how they get identified 🪪. OPES uses standard protocols for authentication and other security communication with callout servers 🔐.
An OPES processor will have a trusted way of receiving configuration info, like rules for the data dispatcher, trusted callout servers, and primary parties that opt in or opt out of individual services 🎛️.
Protocols for policy/rule distribution are out of scope for this document, but the OPES architecture assumes a mechanism like that exists 🤍.
Requirements for the authorization mechanism are set in a separate document [4] 📚.
Service requests can be done in-band 📨. For example, a user agent could signal a request to bypass OPES services with an HTTP header string "Bypass-OPES" 🙋♀️. Such requests MUST be authenticated 🔑. How OPES entities honor those requests depends on the authorization policies in effect at that moment ⏰.
3.3. Callout Protocol
Whether OPES processors use the measures from the previous section when talking to callout servers depends on how the primary parties delegated trust to the OPES processors, and on the trust relationship between the OPES processors and the callout server 🤔. Strong authentication, message authentication codes, and encryption SHOULD be used 🛡️. If the OPES processors sit in a single administrative domain with strong confidentiality and integrity guarantees, then cryptographic protection is recommended but optional 🧁.
If the delegation mechanism names the trusted parties and their privileges in a way that allows authentication, then the OPES processors are responsible for enforcing the policy and for using authentication as part of that enforcement 🔏.
The callout servers MUST be aware of the policy governing the communication path 🗺️. They MUST not, for example, communicate confidential information to auxiliary servers outside the trust domain 🚫😭. Absolutely not.
A separate security association MUST be used for each channel established between an OPES processor and a callout server 🔐. The channels MUST be separate for different primary parties 💅✨.
3.4. Privacy 🔒🎀
okay so some data from OPES flow endpoints counts as "private" or "sensitive" 🥺, and OPES processors MUST tell the primary parties what their privacy policy is and MUST respect the policies the primary parties have. bestie, the privacy info MUST be shared on a per-flow basis 💅. the way to do this is with privacy techniques that already exist, like P3P [7] and HTTP privacy capabilities ✨.
callout servers MUST also get involved in handling private data 🫶. they MUST be ready to announce their own capabilities, and they MUST enforce the policy the primary parties need 🔥.
3.5. End-to-End Integrity 🦋
digital signatures can mark data changes so that a third party can check whether those changes do or don't match the originating party's policy 🧚. this needs an inline way to specify policy and bind it to the data, a trace of changes plus the identity of whoever made each change, and strong identification and authentication methods 💜. no cap, that's a lot of moving parts, but it's so worth it.
strong end-to-end integrity can cover some of what "tracing" is supposed to do 🌈.
4. IAB Architectural and Policy Considerations for OPES 🏛️✨
this section covers the IAB considerations for OPES [2] and sums up how the architecture handles each one 💖.
4.1. IAB Consideration (2.1) One-Party Consent 🙋♀️
the IAB recommends that all OPES services get explicitly authorized by one of the application-layer end-hosts (so either the data consumer application or the data provider application) 🎀.
the current work requires that either the data consumer application or the data provider application consent to OPES services 🫶. these requirements got addressed in sections 2 (section 2.1) and 3 ✅.
4.2. IAB Consideration (2.2) IP-Layer Communications 🌐
the IAB recommends that OPES processors MUST be explicitly addressed at the IP layer by the end user (data consumer application) 📡.
this got addressed in section 2.1, by the requirement that OPES processors be addressable at the IP layer by the data consumer application 💅.
4.3. IAB Consideration (3.1 and 3.2) Notification 📣
the IAB recommends that the OPES architecture incorporate tracing facilities 🔍. tracing lets data consumer and data provider applications detect and respond to actions by OPES processors that are considered inappropriate to them 👀.
section 3.2 of this document talks about the tracing and notification facilities that MUST be supported by OPES services 💜.
4.4. IAB Consideration (3.3) Non-Blocking 🚫🧱
the OPES architecture requires specifying extensions to HTTP 🌸. these extensions let the data consumer application ask the data provider application for a non-OPES version of the content 🙈. these requirements are covered in Section 3.2 ✨.
4.5. IAB Consideration (4.1) URI Resolution 🔗
this consideration recommends that OPES documentation MUST be clear that OPES services are applied to the result of URI resolution, not to URI resolution itself 💖.
this got addressed in sections 2.5 and 3.2, by requiring OPES entities to document all the transformations they performed 📝.
4.6. IAB Consideration (4.2) Reference Validity 🧩
this consideration recommends that all proposed services MUST define their impact on inter- and intra-document reference validity 🦄.
this got addressed in section 2.5 and throughout the document, since OPES entities are required to document the transformations they performed 🌈.
4.7. IAB Consideration (4.3) Application Addressing Extensions 🧭
this consideration recommends that any OPES services that can't be achieved while respecting the above two considerations MAY be reviewed as potential requirements for Internet application addressing architecture extensions, but they MUST NOT be undertaken as ad hoc fixes 🙅♀️.
the current work does not require extensions of the Internet application addressing architecture 💅.
4.8. IAB Consideration (5.1) Privacy 🔐
this consideration recommends that the overall OPES framework MUST provide mechanisms for end users to determine the privacy policies of OPES intermediaries 🕵️♀️.
this got addressed in section 3 💜.
5. Security Considerations 🛡️😭
okay this section is SO important bestie 🚨. the proposed work has to deal with security from a bunch of different angles 🌪️. there are security and privacy issues that relate to the data consumer application, the callout protocol, and the OPES flow 💀. there's an analysis of the threats against OPES entities in [6] 📚, so go read that too 🫶.
6. IANA Considerations 🧾
the proposed work will evaluate current protocols for OCP 🔎. if the work determines that a new protocol needs to be developed, there may be a need to request new numbers from IANA 🔢✨.
7. Summary 🎬
okay the big takeaway: although the architecture supports a wide range of cooperative transformation services, it has few requirements for interoperability 🌷.
the necessary and sufficient elements are specified in these documents 📑:
- the OPES ruleset schema, which defines the syntax and semantics of the rules interpreted by a data dispatcher 📜; and,
- the OPES callout protocol (OCP) [5], which defines the requirements for the protocol between a data dispatcher and a callout server 🧚.
8. References 📚🎀
8.1. Normative References 💜
[1] Barbir, A., Burger, E., Chen, R., McHenry, S., Orman, H., and R.
Penno, "Open Pluggable Edge Services (OPES) Use Cases and
Deployment Scenarios", RFC 3752, April 2004.
[2] Floyd, S. and L. Daigle, "IAB Architectural and Policy
Considerations for Open Pluggable Edge Services", RFC 3238,
January 2002.
[3] Fielding, R., Gettys, J., Mogul, J., Frystyk, H., Masinter, L.,
Leach, P., and T. Berners-Lee, "Hypertext Transfer Protocol --
HTTP/1.1", RFC 2616, June 1999.
[4] Barbir, A., Batuner, O., Beck, A., Chan, T., and H. Orman,
"Policy, Authorization, and Enforcement Requirements of the Open
Pluggable Edge Services (OPES)", RFC 3838, August 2004.
[5] Beck, A., Hofmann, M., Orman, H., Penno, R., and A. Terzis,
"Requirements for Open Pluggable Edge Services (OPES) Callout
Protocols", RFC 3836, August 2004.
[6] Barbir, A., Batuner, O., Srinivas, B., Hofmann, M., and H.
Orman, "Security Threats and Risks for Open Pluggable Edge
Services (OPES)", RFC 3837, August 2004.8.2. Informative References 🌸
[7] Cranor, L. et. al, "The Platform for Privacy Preferences 1.0
(P3P1.0) Specification", W3C Recommendation 16
http://www.w3.org/TR/2002/REC-P3P-20020416/, April 2002.9. Acknowledgements 🙏💖
this document is the product of the OPES WG 🥰. Oskar Batuner (Independent consultant) and Andre Beck (Lucent) are additional authors who contributed to this document 🫶.
earlier versions of this work were done by Gary Tomlinson (The Tomlinson Group) and Michael Condry (Intel) 🧡.
the authors gratefully acknowledge the contributions of: John Morris, Mark Baker, Ian Cooper and Marshall T. Rose 🌟.
10. Authors' Addresses 📮✨
Abbie Barbir
Nortel Networks
3500 Carling Avenue
Nepean, Ontario K2H 8E9
Canada
Phone: +1 613 763 5229
EMail: abbieb@nortelnetworks.com
Yih-Farn Robin Chen
AT&T Labs - Research
180 Park Avenue
Florham Park, NJ 07932
US
Phone: +1 973 360 8653
EMail: chen@research.att.com
Markus Hofmann
Bell Labs/Lucent Technologies
Room 4F-513
101 Crawfords Corner Road
Holmdel, NJ 07733
US
Phone: +1 732 332 5983
EMail: hofmann@bell-labs.com
Hilarie Orman
Purple Streak Development
EMail: ho@alum.mit.edu
Reinaldo Penno
Nortel Networks
600 Technology Park Drive
Billerica, MA 01821
USA
EMail: rpenno@nortelnetworks.com11. Full Copyright Statement ⚖️
Copyright (C) The Internet Society (2004). This document is subject
to the rights, licenses and restrictions contained in BCP 78, and
except as set forth therein, the authors retain all their rights.
This document and the information contained herein are provided on an
"AS IS" basis and THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS
OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY AND THE INTERNET
ENGINEERING TASK FORCE DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE
INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED
WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.Intellectual Property 🧠
The IETF takes no position regarding the validity or scope of any
Intellectual Property Rights or other rights that might be claimed to
pertain to the implementation or use of the technology described in
this document or the extent to which any license under such rights
might or might not be available; nor does it represent that it has
made any independent effort to identify any such rights. Information
on the procedures with respect to rights in RFC documents can be
found in BCP 78 and BCP 79.
Copies of IPR disclosures made to the IETF Secretariat and any
assurances of licenses to be made available, or the result of an
attempt made to obtain a general license or permission for the use of
such proprietary rights by implementers or users of this
specification can be obtained from the IETF on-line IPR repository at
http://www.ietf.org/ipr.
The IETF invites any interested party to bring to its attention any
copyrights, patents or patent applications, or other proprietary
rights that may cover technology that may be required to implement
this standard. Please address the information to the IETF at ietf-
ipr@ietf.org.Acknowledgement 💜
funding for the RFC Editor function is currently provided by the Internet Society 🌈✨
📦 where this page comes from
- ietf: rfc3835 2004-08
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms