2 Referencing Policies
2.1 Overview and Purpose of Policy ReferencesLocating a P3P policy is one of the first steps in the operation of the P3P protocol. Services use policy references to state what policy applies to a specific URI or set of URIs. User agents use policy references to locate the privacy policy that applies to a page, so that they can process that policy for the benefit of their user. Policy references are used extensively as a performance optimization. P3P policies are typically several kilobytes of data, while a URI that references a privacy policy is typically less than 100 bytes. In addition to the bandwidth savings, policy references also reduce the need for computation: policies can be uniquely associated with URIs, so that a user agent need only parse and process a policy once rather than process it with every document to which the policy applies. Furthermore, by placing the information about relevant policies in a centralized location, Web site administration is simplified. A policy reference file is used to associate P3P policies with certain regions of URI-space. The policy reference file is an XML (see [XML]) file that can specify the policy for a single Web document, portions of a Web site, or for an entire site. The policy reference file may refer to one or more P3P policies; this allows for a single reference file to cover an entire site, even if different P3P policies apply to different portions of the site. The policy reference file is used to make any or all of the following statements:
All of these statements are made in the body of the policy reference file. 2.2 Locating Policy Reference FilesThis section describes the mechanisms used to indicate the location of a policy reference file. Detailed syntax is also given for the supported mechanisms. The location of the policy reference file can be indicated using one of three mechanisms. The policy reference file may be located in a predefined "well-known" location, or a document may indicate a policy reference file through an HTML link tag, or through an HTTP header. Note that if user agents support retrieving HTML content over HTTP, they MUST handle all three mechanisms listed above interchangeably. See also the requirements for non-ambiguity. Note that policies are applied at the level of HTTP entities. An entity, retrieved by fetching a URI, has a P3P policy associated with it. A "page" from the user's perspective may be composed of multiple HTTP entities; each entity may have its own P3P policy associated with it. As a practical note, however, placing many different P3P policies on different entities on a single page may make rendering the page and informing the user of the relevant policies difficult for user agents. Additionally, services are recommended to attempt to craft their policy reference files such that a single policy reference file covers any given "page"; this will speed up the user's browsing experience. For a user agent to process the policy that applies to a given entity, it must locate the policy reference file for that entity, fetch the policy reference file, parse the policy reference file, fetch any required P3P policies, and then parse the P3P policy or policies. This document does not specify how P3P policies may be associated with documents retrieved by means other than HTTP. However, it does not preclude future development of mechanisms for associating P3P policies with documents retrieved over other protocols. Furthermore, additional methods of associating P3P policies with documents retrieved using HTTP may be developed in the future. 2.2.1 Well-Known LocationWeb sites using P3P SHOULD place a policy reference file in a "well-known" location. To do this, a policy reference file would be placed in the site's /w3c directory, under the name p3p.xml . Thus a user agent could request this policy reference file by using a GET request for the resource /w3c/p3p.xml . Note that sites are not required to use this mechanism; however, by using this mechanism, sites can ensure that their P3P policy will be accessible to user agents before any other resources are requested from the site. This will reduce the need for user agents to access the site using safe zone practices. Additionally, if a site chooses to use this mechanism, the policy reference file located in the well-known location is not required to cover the entire site. For example, sites where not all of the content is under the control of a single organization MAY choose not to use this mechanism, or MAY choose to post a policy reference file which covers only a limited portion of the site. Use of the well-known location for a policy reference file does not preclude use of other mechanisms for specifying a policy reference file. Portions of the site MAY use any of the other supported mechanisms to specify a policy reference file, so long as the non-ambiguity requirements are met. For example, imagine a shopping-mall Web site run by the MallExample company. On their Web site ( mall.example.com ), companies offering goods or services at the mall would get a company-specific subtree of the site, perhaps in the path /companies/ company-name . The MallExample company may choose to put a policy reference file in the well-known location which covers all of their site except the /companies subtree. Then if the ShoeStoreExample company has some content in /companies/shoestoreexample , they could use one of the other mechanisms to indicate the location of a policy reference file covering their portion of the mall.example.com site. One case where using the well-known location for policy reference files is expected to be particularly useful is in the case of a site which has divided its content across several hosts . For example, consider a site which uses a different logical host for all of its Web-based applications than for its static HTML content. The other mechanisms allowed for specifying the location of a policy reference file require that some URI on the host being accessed must be fetched to locate the policy reference file. However, the well-known location mechanism has no such requirement. Consider the example of an HTML form located on www.example.com . Imagine that the action URI on that form points to server cgi.example.com . The policy reference file that covers the form is unable to make any statements about the action URI that processes the form. However, the site administrator publishes a policy reference file at http://cgi.example.com/w3c/p3p.xml that covers the action URI, thus enabling a user agent to easily locate the P3P policy that applies to the action URI before submitting the form contents. 2.2.2 HTTP HeadersAny document retrieved by HTTP MAY point to a policy reference file through the use of a new response header, the P3P header ([P3P-HEADER]). If a site is using P3P headers, it SHOULD include this on responses for all appropriate request methods, including HEAD and OPTIONS requests . The P3P header gives one or more comma-separated directives. The syntax follows :
In keeping with the rules for other HTTP headers, the name of the P3P header may be written with any casing. The contents should be specified using the casing precisely as specified in this document. The policyref directive gives a URI which specifies the location of a policy reference file which may reference the P3P policy covering the document that pointed to the reference file, and possibly others as well. When the policyref attribute is a relative URI, that URI is interpreted relative to the request URI. Note that fetching the URI given in the policyref directive MAY result in a 300-class HTTP return code (redirection); user agents MUST interpret those redirects with normal HTTP semantics. Services should note, of course, that use of redirects will increase the time required for user agents to find and interpret their policies. The policyref URI MUST NOT be used for any other purpose beyond locating and referencing P3P policies. The compact-policy-field is used to specify "compact policies." This is described in Section 4. User agents which find unrecognized directives (in the extension-fields ) MUST ignore the unrecognized directives. This is to allow easier deployment of future versions of P3P.
2.2.3 The HTML link TagServers MAY serve HTML content with embedded link tags that indicate the location of the relevant P3P policy reference file. This use of P3P does not require any change in the server behavior. The link tag encodes the policy reference information that could be expressed using the P3P header. The link tag takes the following form:
When the href attribute is a relative URI, that URI is interpreted relative to the request URI. In order to illustrate with an example the use of the link tag, we consider the policy reference expressed in Example 2.1 using HTTP headers. That example can be equivalently expressed using the link tag with the following piece of HTML: <link rel="P3Pv1" href="http://catalog.example.com/P3P/PolicyReferences.xml"> Finally, note that since the p3p-link-tag is embedded in an HTML document, its character encoding will be the same as that of the HTML document. In contrast to P3P policy and policy reference documents (see section 2.3 and section 3 below), the p3p-link-tag need not be encoded using [UTF-8]. Note also that the link tag is not case sensitive 2.2.4 HTTP Ports and Other ProtocolsThe mechanisms described here MAY be used for HTTP transactions over any underlying protocol. This includes plain-text HTTP over TCP/IP connections as well as encrypted HTTP over SSL connections, as well as HTTP over any other communications protocol network designers wish to implement. URLs MAY contain TCP/IP port numbers , as specified in RFC 2396 [URI]. For the purposes of P3P, the different ports on a single host MUST be considered to be separate "sites." Thus, for example, the policy reference file at the well-known location for www.example.com on port 80 ( http://www.example.com/w3c/p3p.xml ) would not give any information about the policies which apply to www.example.com when accessed over SSL (as the SSL communication would take place on a different port, 443 by default). This document does not specify how P3P policies may be associated with documents retrieved by means other than HTTP. However, it does not preclude future development of mechanisms for associating P3P policies with documents retrieved over other protocols. Furthermore, additional methods of associating P3P policies with documents retrieved using HTTP may be developed in the future. 2.3 Policy Reference File Syntax and SemanticsThis section explains the contents of policy reference files in detail. 2.3.1 Example Policy Reference FileConsider the case of a Web site wishing to make the following statements:
These statements could be represented by the following piece of XML:
Note this example also includes via EXPIRY a relative expiry time in the document (cf. Section 2.3.2.3.2). 2.3.2 Policy Reference File DefinitionThis section defines the syntax and semantics of P3P policy reference files. All policies MUST be encoded using [UTF-8]. P3P servers MUST encode their policy references using this syntax. P3P user agents MUST be able to parse this syntax. One significant point to make about the syntax of policy reference files is that the syntax defined here does not have an extension mechanism. The syntax for P3P policies has a powerful extension mechanism, but that mechanism is not supported for policy reference files. 2.3.2.1 Policy Reference File Processing2.3.2.1.1 Significance of OrderA policy reference file may contain multiple POLICY-REF elements. If it does contain more than one element, they MUST be processed by user agents in the order given in the file. When a user agent is attempting to determine what policy applies to a given URI, it MUST use the first POLICY-REF element in the policy reference file which applies to that URI. Note that each POLICY-REF may contain multiple INCLUDE , EXCLUDE , METHOD , COOKIE-INCLUDE , and COOKIE-EXCLUDE elements and that all of these elements within a given POLICY-REF MUST be considered together to determine whether the POLICY-REF applies to a given URI. Thus, it is not sufficient to find an INCLUDE element that matches a given URI, as EXCLUDE or METHOD elements may serve as modifiers that cause the POLICY-REF not to match. 2.3.2.1.2 Wildcards in Policy Reference FilesPolicy reference files make statements about what policy applies to a given URI. Policy reference files support a simple wildcard character to allow making statements about regions of URI-space. The character asterisk ("*") is used to represent a sequence of 0 or more of any character. No other special characters (such as those found in regular expressions) are supported. Note that since the asterisk is also a legal character in URIs ([URI]), some special conventions have to be followed when encoding such "extended URIs" in a policy reference file:
The wildcard character MAY be used in the INCLUDE and EXCLUDE elements, in the COOKIE-INCLUDE and COOKIE-EXCLUDE elements, and in the HINT element. 2.3.2.2 The META and POLICY-REFERENCES ElementsThe META element contains a complete policy reference file. Optionally , one POLICIES element can follow. Additionally, other XML markup MAY follow the POLICY-REFERENCES (or POLICIES , if present) element, although that markup MUST be ignored by any P3P1.0 user agent. <POLICY-REFERENCES> This element MAY contain one or more POLICY-REF (policy reference) elements. It MAY also contain one EXPIRY element (indicating their expiration time), and one or more HINT element.
2.3.2.3 Policy Reference File Lifetimes and the EXPIRY Element2.3.2.3.1 Motivation and MechanismIt is desirable for servers to inform user agents about how long they can use the claims made in a policy reference file. By enabling clients to cache the contents of a policy reference file, it reduces the time required to process the privacy policy associated with a Web page. This also reduces load on the network. In addition, clients that don't have a valid policy reference file for a URI will need to use "safe zone" practices for their requests. If clients have policy reference files that they know are still valid, then they can make more informed decisions on how to proceed. In order to achieve these benefits, policy reference files SHOULD contain an EXPIRY element, which indicates the lifetime of the policy reference file. If the policy reference file does not contain an EXPIRY element, then it is given a 24- hour lifetime. The lifetime of a policy reference file tells user agents how long they can rely on the claims made in the policy reference file. By setting the lifetime of a policy reference file, the publishing site agrees that the policies mentioned in the policy reference file are appropriate for the lifetime of the policy reference file. For example, if a policy reference file has a lifetime of 3 days, then a user agent need not reload that file for 3 days, and can assume that the references made in that policy reference file are good for 3 days. All of the policy references made in a single policy reference file will receive the same lifetime. The only way to specify different lifetimes for different policy references is to use separate policy reference files. The same mechanism used to indicate the lifetime of a policy reference file is also used to indicate the lifetime of a P3P policy. Thus P3P POLICIES elements SHOULD have an EXPIRY element associated with them as well. This lifetime applies to all P3P policies contained within that POLICIES element. If there is no EXPIRY element associated with a P3P policy, then it is given a 24-hour lifetime. When picking a lifetime for policies and policy reference files, sites need to pick a lifetime which balances two competing concerns. One concern is that the lifetime ought to be long enough to allow user agents to receive significant benefits from caching. The other concern is that the site would like to be able to change their policy for new data collection without waiting for an extremely long lifetime to expire. It is expected that lifetimes in the range of 17 days would be a reasonable balance between these two competing desires. Sites also need to remember the policy update requirements when updating their policies. When a policy reference file has expired , the information in the policy reference file MUST NOT be used by a user agent until that user agent has successfully revalidated the policy reference file, or has fetched a new copy of the policy reference file. Note that while user agents are not obligated to revalidate policy reference files or policy files that have not expired, they MAY choose to revalidate those files before their expiry period has passed, in order to reduce the need for using "safe zone" practices. A valid P3P user agent implementation doesn't need to contain a cache for policies and policy reference files, though the implementation will have a better performance if it does. 2.3.2.3.2 The EXPIRY ElementThe EXPIRY element can be used in a policy reference file and/or in a POLICIES element to state how long the policy reference file (or policies) remains valid. The expiry is given as either an absolute expiry time, or a relative expiry time. An absolute expiry time is a time, given in GMT, until which the policy reference file (or policies) is valid. A relative expiry time gives a number of seconds for which the policy reference file (or policies) is valid. This expiry time is relative to the time the policy reference file (or policies) was requested or last revalidated by the client. This computation MUST be done using the time of the original request or revalidation, and the current time, with both times generated from the client's clock. Revalidation is defined in section 13.3 of [HTTP1.1]. The minimum amount of time for any relative expiry time is 24 hours, or 86400 seconds. Any relative expiration time shorter than 86400 seconds MUST be treated as being equal to 86400 seconds in a client implementation. If a client encounters an absolute expiration time that is in the past, it MUST act as if NO policy reference file (or policy) is available. See section 2.4.7 "Absence of Policy Reference File" for the required procedure in such cases.
2.3.2.3.3 Requesting Policies and Policy Reference FilesIn a real-world network, there may be caches which will cache the contents of policies and policy reference files. This is good for increasing the overall network performance, but may have deleterious effects on the operation of P3P if not used correctly. There are two specific concerns:
HTTP 1.1 [HTTP1.1] contains powerful cache-control mechanisms to allow clients to place requirements on the operations of network caches; these mechanisms can resolve the problems mentioned above. The specific method will be discussed below. HTTP 1.0, however, does not provide those more sophisticated cache control mechanisms. An HTTP 1.0 network cache will, in all likelihood , compute a cache lifetime for the policy reference file (or policies) based on the file's last-modified date; the resulting cache lifetime could be significantly longer than the lifetime specified by the EXPIRY element. The network cache could then serve the policy reference file (or policies) to clients beyond the lifetime in the EXPIRY ; the result would be that user-agents would receive a useless policy reference file (or policies). The second problem with HTTP 1.0 network caches is that a user agent has no way to know how long the reference file may have been stored by the network cache. If the policy reference file (or policies) relies on relative expiry, it would then be impossible for the user agent to determine if the reference file's lifetime has already expired, or when it will expire. Thus, if a user agent is requesting a policy reference file or a policy, and does not know for certain that there are no HTTP 1.0 caches in the path to the origin server, then the request must force an end-to-end revalidation. This can be done with the Pragma: no-cache HTTP request-header. Note that neither HTTP nor P3P define a way to determine if there is a HTTP 1.0-compliant cache in any given network path, so unless the user agent has this information derived from an outside source, it MUST force the end-to-end revalidation. If the user agent has some way to know that all caches in the network path to the origin server are compliant with HTTP 1.1 (or that there are no caches in the network path to the origin server), then the client MUST do the following:
Note that it is impossible for a client to accurately predict the amount of latency that may affect an HTTP request. Thus, if the policy reference file covering a request is going to expire soon, clients MAY wish to consider warning their users and/or revalidating the policy reference file before continuing with the request. 2.3.2.3.4 Error Handling for Policy Reference File and Policy LifetimesThe following situations have their semantics specifically defined:
2.3.2.4 The POLICY-REF ElementA policy reference file may refer to multiple P3P policies, specifying information about each. The POLICY-REF element describes attributes of a single P3P policy. Elements within the POLICY-REF element give the location of the policy and specify the areas of URI-space (and cookies) that each policy covers. POLICY-REF Contains information about a single P3P policy.
2.3.2.5 The INCLUDE and EXCLUDE ElementsEach INCLUDE or EXCLUDE element specifies one local URI or set of local URIs. A set of URIs is specified if the wildcard character '*' is used in the URI-pattern. These elements are used to specify the portion of the Web site that is covered by the policy referenced by the enclosing POLICY-REF element. When INCLUDE (and optionally, EXCLUDE ) elements are present in a POLICY-REF element, it means that the policy specified in the about attribute of the POLICY-REF element applies to all the URIs at the requested host corresponding to the local-URI(s) matched by any of the INCLUDE s, but not matched by an EXCLUDE element. A policy referenced in a policy reference file can be applied only to URIs on the DNS (Domain Name System) host that reference it. The INCLUDE and EXCLUDE elements MUST specify URI patterns relative to the root of the DNS host to which they are applied. This requirement does NOT apply to the location of the P3P policy file (the about attribute on the POLICY-REF element). If a METHOD element (section 2.3.2.8) specifies one or more methods for an enclosing policy reference, it follows that all methods not mentioned are consequently not covered by this policy. In the case that this is the only policy reference for a given URI prefix, user agents MUST assume that NO policy is in effect for all methods NOT mentioned in the policy reference file. It is legal but pointless to supply a METHOD element without any INCLUDE or COOKIE-INCLUDE elements. It is legal, but pointless, to supply an EXCLUDE element without any INCLUDE elements; in that case, the EXCLUDE element MUST be ignored by user agents. Note that the set of URIs specified with INCLUDE and EXCLUDE does not include cookies that might be triggered when requesting one of such URIs: in order to associate policies with cookies, the COOKIE-INCLUDE and COOKIE-EXCLUDE elements are needed.
2.3.2.6 The HINT ElementPolicy reference hints are a performance optimization that can be used under certain conditions. A DNS host may declare a policy reference for itself using the well-known location, the P3P response header, or the HTML link tag. The host MAY further provide a hint to additional policy references, such as those declared by other hosts. For example, an HTML page might hint at policy references for its hyperlinks , embedded content, and form submission URIs. User agents MAY use the hint mechanism to discover policy references before requesting the affected URIs when the policy references are not available from the well-known location. Any policy reference file MAY contain zero or more policy reference hints. Each hint is contained in a HINT element, and consists of single host or domain of hosts to which the hinted policy reference can be applied. When using a hint applicable to multiple hosts, the policy reference is expected in the same relative location on each host, but the content may vary according to the host. Therefore, a user agent that finds a policy reference on a particular host via the hint mechanism MUST NOT apply it to another host. The domain attribute is used to domain-match (possibly using the '*' wildcard) the host(s) to which the hinted policy reference file can be applied. The path attribute specifies the location of the hinted policy reference files relative to the applicable host rather than the policy reference file containing the hint. Here is an example of HINT elements that hint at the location of policy reference files on the host example.org and on any host in the domain shop.example.com :
If a hinted policy reference file is not found, expired, or otherwise invalid, the user agent MUST ignore the hint. Before using a hinted policy reference, the user agent MUST check the well-known location and give precedence to any policy references directly declared by the host, with the well-known location taking the highest precedence. If a hinted policy reference is not directly declared by the host as expected, the user agent MAY ignore it.
2.3.2.7 The COOKIE-INCLUDE and COOKIE-EXCLUDE ElementsThe COOKIE-INCLUDE and COOKIE-EXCLUDE elements are used to associate policies to cookies. A cookie policy MUST cover any data (within the scope of P3P) that is stored in that cookie or linked via that cookie. It MUST also reference all purposes associated with data stored in that cookie or enabled by that cookie. In addition, any data/purpose stored or linked via a cookie MUST also be put in the cookie policy. In addition, if that linked data is collected by HTTP, then the policy that covers that GET / POST /whatever request must cover that data collection. For example, when CatalogExample asks customers to fill out a form with their name, billing, and shipping information, the P3P policy that covers the form submittal will disclose that CatalogExample collects this data and explain how it is used. If CatalogExample sets a cookie so that it can recognize its customers and observe their behavior on its web site, it would have a separate policy for this cookie. However, if this cookie is also linked to the user's name, billing, and shipping informationperhaps so CatalogExample can generate custom catalog pages based on where the customer livesthen that data must also be disclosed in the cookie policy. For the purpose of this specification, state management mechanisms use either SET-COOKIE or SET-COOKIE2 headers, and cookie-namespace is defined as the value of the NAME, VALUE, Domain and Path attributes, specified in [COOKIES] and [STATE]. Each COOKIE-INCLUDE or COOKIE-EXCLUDE element can be used to match (similarly to INCLUDE and EXCLUDE ) the NAME, VALUE, Domain and Path components of a cookie, expressing the cookies which are covered by the policy specified by the about attribute when the cookies are set from the documents on the Web site where the policy reference file resides:
Include (resp. exclude) cookies that match the name , value , domain and path attributes.
All four attributes are optional. If an attribute is absent, the COOKIE-INCLUDE (resp. COOKIE-EXCLUDE ) will match cookies that have that attribute set to any value. When COOKIE-INCLUDE (and optionally, COOKIE-EXCLUDE ) elements are present in a POLICY-REF element, the policy specified in the about attribute of the POLICY-REF element applies to every cookie that is matched by any COOKIE-INCLUDE 's, and not matched by a COOKIE-EXCLUDE element. A site MUST NOT declare policies for cookies unless the cookies are set by its own site. User agents MUST accordingly interpret COOKIE-INCLUDE and COOKIE-EXCLUDE elements in a policy reference file to determine the policy that applies to cookies. Note that COOKIE-INCLUDE and COOKIE-EXCLUDE are the only mechanisms for associating policies with cookies in policy reference files (see Section 4). The policy that applies to a cookie applies until the policy expires, even if the associated policy reference file expires prior to policy expiry (but after the cookie was set). If the policy associated with a cookie has expired, then the user agent SHOULD reevaluate the cookie policy before sending the cookie. In addition, user agents MUST use only non-expired policies and policy reference files when evaluating new set-cookie events. Example 2.4 states that /P3P/Policies.xml#first applies to all cookies.
Example 2.5 states that /P3P/Policies.xml#first applies to all cookies, except cookies with the cookie name value of "obnoxious-cookie" , a domain value of "example.com" , and a path value of "/" , and that /P3P/Policies.xml#second applies to all cookies with the cookie name of "obnoxious-cookie" , a domain value of ".example.com" , and a path value of "/" .
Note that [STATE] states default values for the domain and path attributes of cookies: these should be used in the comparison if those attributes are not found in a specific cookie. Also, conforming to [STATE], if an explicitly specified Domain value does not start with a full stop ("."), the user agent MUST prepend a full stop for it; and, note that every Path begins with the "/" symbol. 2.3.2.8 The METHOD ElementBy default, a policy reference applies to the stated URIs regardless of the method used to access the resource. However, a Web site may wish to define different P3P policies depending on the method to be applied to a resource. For example, a site may wish to collect more data from users when they are performing PUT or DELETE methods than when performing GET methods. The METHOD element in a policy reference file is used to state that the enclosing policy reference only applies when the specified methods are used to access the referenced resources. The METHOD element may be repeated to indicate multiple applicable methods. If the METHOD element is not present in a POLICY-REF element, then that POLICY-REF element covers the resources indicated regardless of the method used to access them. So, to state that /P3P/Policies.xml#first applies to all documents in the subtree /docs/ for GET and HEAD methods, while /P3P/Policies.xml#second applies for PUT and DELETE methods, the following policy reference would be written:
Note that HTTP requires the same behavior for GET and HEAD requests, thus it is inappropriate to specify different P3P policies for these methods. The syntax for the METHOD element is:
Finally, note that the METHOD element is designed to be used in conjunction with INCLUDE or COOKIE-INCLUDE elements. A METHOD element by itself will never apply a POLICY-REF to a URI. 2.3.3 Applying a Policy to a URIA policy reference file specifies the policy which applies to a given URI. The meaning of this is that the indicated policy describes all effects of performing any of the methods listed in the policy reference file against the given URI. There is a general rule which describes what it means for a P3P policy to cover a URI: the referenced policy MUST cover actions that the user's client software is expected to perform as a result of requesting that URI . Obviously, the policy must describe all data collection performed by site as a result of processing the request for the URI. Thus, if a given URI is covered for terms of GET requests, then the policy given by the policy reference file MUST describe all data collection performed by the site when that URI is fetched. Likewise, if a URI is covered for POST requests, then any data collection that occurs as a result of posting a form or other content to that URI MUST be described by the policy. The concept of "actions that the client software is expected to perform" includes the setting of client-side cookies or other state-management mechanisms invoked by the response. If executable code is returned when a URI is requested, then the P3P policy covering that URI MUST cover certain actions which will occur when that code is executed. The covered actions are any actions which could take place without the user explicitly invoking them. If explicit user action causes data to be collected, then the P3P policy covering the URI for that action would disclose that data collection. Some specific examples:
2.3.4 Forms and Related MechanismsForms deserve special consideration, as they often link to CGI scripts or other server-side applications in their action URIs. It is often the case that those action URIs are covered by a different policy than the form itself. If a user agent is unable to find a matching include-rule for a given action URI in the policy reference file that was referenced from the page, it SHOULD assume that no policy is in effect. Under these circumstances, user agents SHOULD check the well-known location on the host of the action URI to attempt to find a policy reference file that covers the action URI. If this does not provide a P3P policy to cover the action URI, then a user agent MAY try to retrieve the policy reference file by using the HINT mechanism on the action URI, and/or by issuing a HEAD request to the action URI before actually submitting any data in order to find the policy in effect. Services SHOULD ensure that server-side applications can properly respond to such HEAD requests and return the corresponding policy reference link in the headers. In case the underlying application does not understand the HEAD request and no policy has been predeclared for the action URI in question, user agents MUST assume that no policy is in effect and SHOULD inform the user about this or take the corresponding actions according to the user's preferences. Note that services might want to make use of the <METHOD> element in order to declare policies for server-side applications that only cover a subset of supported methods, e.g., POST or GET . Under such circumstances, it is acceptable that the application in question only supports the methods given in the policy reference file (i.e., HEAD requests need not be supported). User agents SHOULD NOT attempt to issue a HEAD request to an action URI if the relevant methods specified in the form's method attribute have been properly predeclared in the page's policy reference file. In some cases, different data is collected at the same action URI depending on some selection in the form. For example, a search service might offer to both search for people (by name and/or email) and (arbitrary) images. Using a set of radio buttons on the form, a single server-side application located at one and the same action URI handles both cases and collects the required information necessary for the search. If a service wants to predeclare the data collection practices of the server-side application it MAY declare all of the data collection practices in a single policy file (using a <INCLUDE> declaration matching the action URI). In this case, user agents MUST assume that all data elements are collected under every circumstance. This solution offers the convenience of a single policy but might not properly reflect the fact that only parts of the listed data elements are collected at a time. Services SHOULD make sure that a simple HEAD request to the action URI (i.e., without any arguments, especially without the value of the selected radio button) will return a policy that covers all cases. Note that if a form is handled through use of the GET method, then the action URI reflects the choice of form elements selected by the user. In some cases, it will be possible to make use of the wildcard syntax allowed in policy reference files to specify different policies for different uses of the same form action-handler URI. Therefore, user agents MUST include the query-string portion of URIs when making comparisons with INCLUDE and EXCLUDE elements in policy reference files. 2.4 Additional Requirements2.4.1 Non-ambiguityUser agents need to be able to determine unambiguously what policy applies to a given URI. Therefore, sites SHOULD avoid declaring more than one non-expired policy for a given URI. In some rare cases sites MAY declare more than one non-expired policy for a given URI, for example, during a transition period when the site is changing its policy. In those cases, the site will probably not be able to determine reliably which policy any given user has seen, and thus it MUST honor all policies (this is also the case for compact policies, cf. Section 4.1 and Section 4.6). Sites MUST be cautious in their practices when they declare multiple policies for a given URI, and ensure that they can actually honor all policies simultaneously . If a policy reference file at the well-known location declares a non-expired policy for a given URI, this policy applies, regardless of any conflicting policy reference files referenced through HTTP headers or HTML link tags. If an HTTP response includes references to more than one policy reference file, P3P user agents MUST ignore all references after the first one. If an HTML file includes HTML link tag references to more than one policy reference file, P3P user agents MUST ignore all references after the first one. If a user agent discovers more than one non-expired P3P policy for a given URI (for example because a page has both a P3P header and a link tag that reference different policy reference files, or because P3P headers for two pages on the site reference different policy reference files that declare different policies for the same URI), the user agent MAY assume any (or all) of these policies apply as the site MUST honor all of them. 2.4.2 Multiple LanguagesMultiple language versions (translations) of the same policy can be offered by the server using the HTTP "Content-Language" header to properly indicate that a particular language has been used for the policy. This is useful so that human-readable fields such as entity and consequence can be presented in multiple languages. The same mechanism can also be used to offer multiple language versions for data schemas. Whenever Content-Language is used to distinguish policies at the same URI that are offered in multiple languages, the policies MUST have the same meaning in each language. Two policies (or two data schemas) are taken to be identical if
Due to the use of the Accept-Language mechanism, implementers should take note that user agents may see different language versions of a policy or policy reference file despite sending the same Accept-Language request header if a new language version of a policy or data schema has been added. 2.4.3 The "Safe Zone"P3P defines a special set of "safe zone" practices, which SHOULD be used by all P3P-enabled user agents and services for the communications which take place as part of fetching a P3P policy or policy reference file. In particular, requests to the well-known location for policy reference files SHOULD be covered by these "safe zone" practices. Communications covered by the safe zone practices SHOULD have only minimal data collection, and any data that is collected is used only in non-identifiable ways. To support this safe zone, P3P user agents SHOULD suppress the transmission of data unnecessary for the purpose of finding a site's policy until the policy has been fetched. Therefore safe-zone practices for user agents include the following requirements:
Safe-zone practices for servers include the following requirements:
Note that the safe zone requirements do not say that sites cannot keep identifiable informationonly that they SHOULD NOT use in an identifiable way any information collected while serving a policy file. Tracking down the source of a denial of service attack, for example, would be a legitimate reason to use this information and ignore this recommendation. 2.4.4 Non-Discrimination of PoliciesServers SHOULD make every effort to help user agents find P3P policies. In particular, servers SHOULD place a policy reference file at the well-known location whenever possible. When the P3P HTTP header is used as an alternative, servers SHOULD:
2.4.5 Security of Policy TransportP3P policies and references to P3P policies SHOULD NOT, in themselves , contain any sensitive information. This means that there are no additional security requirements for transporting a reference to a P3P policy beyond the requirements of the document it is associated with; so, if an HTML document would normally be served over a non-encrypted session, then the P3P protocol would not require nor recommend that the document be served over an encrypted session when a reference to a P3P policy is included with that document. 2.4.6 Policy UpdatesNote that when a Web site changes its P3P policy, the old policy applies to data collected when it was in effect. It is the responsibility of the site to keep records of past P3P policies and policy reference files along with the dates when they were in effect, and to apply these policies appropriately. If a site wishes to apply a new P3P policy to previously collected data, it MUST provide appropriate notice and opportunities for users to accept the new policy that are consistent with applicable laws, industry guidelines, or other privacy-related agreements the site has made. 2.4.7 Absence of Policy Reference FileIf no policy reference file is available for a given site, user agents MUST assume (an empty) policy reference file exists at the well-known location with a 24 hour expiry, and therefore if the user returns to the site after 24 hours, the user agent MUST attempt to fetch a policy reference file from the well-known location again. User agents MAY check the well-known location more frequently, or upon a certain event such as the user clicking a browser refresh button. Sites MAY place a policy reference file at the well-known location that indicates that no policy is available, but set the expiry such that user agents know they need not check every 24 hours. 2.4.8 Asynchronous EvaluationUser agents MAY asynchronously fetch and evaluate P3P policies. That is, P3P policies need not necessarily be fetched and evaluated prior to other HTTP transactions. This behavior may be dependent on the user's preferences and the type of request being made. Until a policy is evaluated, the user agent SHOULD treat the site as if it has no privacy policy. Once the policy has been evaluated, the user agent SHOULD apply the user's preferences. To promote deterministic behavior, the user agent SHOULD defer application of a policy until a consistent point in time. For example, a web browser might apply a user's preferences just after the user agent completes a navigation, or when confirming a form submission. 2.5 Example ScenariosAs an aid to sites deploying P3P, several example scenarios are presented, along with descriptions of how P3P is used on those sites. Scenario 1: Web site basic.example.com uses a variety of images, all of which it hosts. It also includes some forms, which are all submitted directly to the site. This site can declare a single P3P policy for the entire site (or if different privacy policies apply to different parts of the site, it can declare multiple P3P policies). As long as all of the images and form action URIs are in directories covered by the site's P3P policy, user agents will automatically recognize the images and forms as covered by the site's policy. Scenario 2: Web site busy.example.com uses a content distribution network called cdn.example.com to host its images so as to reduce the load on its servers. Thus, all of the images on the site have URIs at cdn.example.com. CDN acts as an agent to Busy in this situation, and collects no data other than log data. This log data is used only for Web site and system administration in support of providing the services that Busy contracted for. Busy's privacy policy applies to the images hosted by CDN, so Busy uses the HINT element in its policy reference file to point to a suitable policy reference file at CDN, indicating that such images are covered by example.com P3P policy. Scenario 3: Web site busy.example.com also has a contract with an advertising company called clickads.example.com to provide banner ads on its site. The contract allows Clickads to set cookies so as to make sure each user doesn't see a given ad more than three times. Clickads collects statistics on how many users view each ad and reports them to the companies whose products are being advertised. But these reports do not reveal information about any individual users. As was the case in Scenario 2, Busy's privacy policies applies to these ads hosted by Clickads, so Busy uses the HINT element in its policy reference file to point to a suitable policy reference file at Clickads, indicating that Busy P3P policy applies to such embedded content served by clickads.example.com. The companies whose products are being advertised need not be mentioned in the Busy privacy policy because the only data they are receiving is aggregate data. Scenario 4: Web site busy.example.com also has a contract with funchat.example.com to host a chat room for its users. When users enter the chat room they are actually leaving the Busy site. However, the chat room has the Busy logo and is actually covered by the Busy privacy policy. In this instance Funchat is acting as an agent for Busy, butunlike the previous examplestheir content is not embedded in the Busy site. Busy can use the HINT element in its policy reference file to point to a suitable Funchat policy reference file, that indicates that Funchat chat room is covered by Busy privacy policy, therefore facilitating a smoother transition to the chat room. Scenario 5: Web site bigsearch.example.com has a form that allows users to type in a search query and have it performed on their choice of search engines located on other sites. When a user clicks the "submit" button, the search query is actually submitted directly to these search enginesthe action URI is not on bigsearch.example.com but rather on the search engine selected by the user. Bigsearch can declare the privacy policies for these search engines by using the HINT element to point to their corresponding policy reference files. So when a user clicks the "submit" button, their user agent can check its privacy policy before posting any data. In order to make this search choice mechanism work, Bigsearch might actually have a form with an action URI on its own site, which redirects to the appropriate search engine. In this case, the user agent should check the search engine privacy policy upon receiving the redirect response. Scenario 6: Web site bigsearch.example.com also has a form that allows users to type in a search query and have it simultaneously performed on ten different search engines. Bigsearch submits the queries, gets back the results from each search engine, removes the duplicates, and presents the results to the user. In this case, the user interacts only with Bigsearch. Thus, the only P3P policy involved is the one that covers the Bigsearch Web site. However, Bigsearch must disclose that it shares the users' search queries with third parties (the search Web sites), unless Bigsearch has a contract with these search engines and they act as agents to Bigsearch. Scenario 7: Web site bigsearch.example.com also has banner advertisements provided by a company called adnetwork.example.com. Adnetwork uses cookies to develop profiles of users across many different Web sites so that it can provide them with ads better suited to their interests. Because the data about the sites that users are visiting is being used for purposes other than just serving ads on the Bigsearch Web site, Adnetwork cannot be considered an agent in this context. Adnetwork must create its own P3P policy and use its own policy reference file to indicate what content it applies to. In addition, Bigsearch may optionally use the HINT element in its policy reference file to indicate that the Adnetwork P3P policy reference file applies to these advertisements. Bigsearch should only do this if Adnetwork has told it what P3P policy applies to these advertisements and has agreed to notify Bigsearch if the policy reference needs to be changed. Scenario 8: Web site busy.example.com uses cookies throughout its web site. It discloses a cookie policy, separate from its regular P3P policy to cover these cookies. It uses the COOKIE-INCLUDE element in its policy reference file to declare the appropriate policy for these cookies. As a performance optimization, it also makes available a compact policy by sending a P3P header that includes this compact policy whenever it sets a cookie. Scenario 9: Web site config.example.com provides a service in which they optimize various kinds of web content based on each user's computer and Internet configuration. Users go to the Config web site and answer questions about their computer, monitor, and Internet connection. Config encodes the responses and stores them in a cookie. Later, when the user is visiting Busya Web site that has contracted with Configwhenever the browser requests content that can be optimized (certain images, audio files, etc.), Busy will redirect the user to Config, which will read the user's cookie, and deliver the appropriate content. In this case, Config should declare a privacy policy that describes the kinds of data collected and stored in its cookies, and how that data is used. It should use a COOKIE-INCLUDE element in its policy reference file to declare the policy for the cookies. It will probably reference Busy's P3P policy for the actual images or audio files delivered, as it is acting much like CDN acts in scenario 2. Busy will probably also use HINT elements in its policy reference file to reference the policy for the Config-delivered content.  |
EAN: 2147483647
Pages: 150