<?xml version="1.0" encoding="US-ASCII"?>
<?xml-stylesheet type='text/xsl' href='rfc2629.xslt' ?>
<?rfc toc="yes" ?>
<?rfc symrefs="yes" ?>
<?rfc sortrefs="no"?>
<?rfc iprnotified="no" ?>
<?rfc strict="no" ?>
<?rfc compact="yes" ?>
<?rfc subcompact="yes" ?>
<!DOCTYPE rfc SYSTEM "rfc2629.dtd" [
<!ENTITY RFC4474 SYSTEM "http://xml.resource.org/public/rfc/bibxml/reference.RFC.4474.xml">
<!ENTITY RFC4745 SYSTEM "http://xml.resource.org/public/rfc/bibxml/reference.RFC.4745.xml">
<!ENTITY RFC4825 SYSTEM "http://xml.resource.org/public/rfc/bibxml/reference.RFC.4825.xml">
<!ENTITY I-D.tschofenig-sipping-spit-policy SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.tschofenig-sipping-spit-policy.xml">
<!ENTITY I-D.ietf-sipping-spam SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.ietf-sipping-spam.xml">
<!ENTITY I-D.ietf-simple-presence-rules SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.ietf-simple-presence-rules.xml">
<!ENTITY I-D.jennings-sip-hashcash SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.jennings-sip-hashcash.xml">
<!ENTITY I-D.ietf-sip-consent-framework SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.ietf-sip-consent-framework.xml">
<!ENTITY I-D.ietf-dkim-overview SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.ietf-dkim-overview.xml">
<!ENTITY I-D.shacham-http-corr-uris SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.shacham-http-corr-uris.xml">
<!ENTITY I-D.jennings-sipping-pay SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.jennings-sipping-pay.xml">
<!ENTITY I-D.froment-sipping-spit-requirements SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.froment-sipping-spit-requirements.xml">
<!ENTITY I-D.schwartz-sipping-spit-saml SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.schwartz-sipping-spit-saml.xml">
<!ENTITY I-D.niccolini-sipping-feedback-spit SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.niccolini-sipping-feedback-spit.xml">
<!ENTITY I-D.wing-sipping-spam-score SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.wing-sipping-spam-score.xml">
<!ENTITY I-D.tschofenig-sipping-captcha SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.tschofenig-sipping-captcha.xml">
]>
<rfc category="info" docName="draft-tschofenig-sipping-framework-spit-reduction-02.txt"
  ipr="full3978">
  <front>
    <title abbrev="Framework for Reducing Spam">A Framework to tackle Spam and Unwanted
      Communication for Internet Telephony</title>

    <author fullname="Hannes Tschofenig" initials="H." surname="Tschofenig">
      <organization>Nokia Siemens Networks</organization>
      <address>
        <postal>
          <street>Otto-Hahn-Ring 6</street>
          <city>Munich</city>
          <region>Bavaria</region>
          <code>81739</code>
          <country>Germany</country>
        </postal>
        <email>Hannes.Tschofenig@nsn.com</email>
        <uri>http://www.tschofenig.com</uri>
      </address>
    </author>

    <author fullname="Henning Schulzrinne" initials="H." surname="Schulzrinne">
      <organization>Columbia University</organization>
      <address>
        <postal>
          <street>Department of Computer Science</street>
          <street>450 Computer Science Building</street>
          <city>New York</city>
          <region>NY</region>
          <code>10027</code>
          <country>US</country>
        </postal>
        <phone>+1 212 939 7004</phone>
        <email>hgs@cs.columbia.edu</email>
        <uri>http://www.cs.columbia.edu</uri>
      </address>
    </author>

    <author fullname="Dan Wing" initials="D" surname="Wing">
      <organization>Cisco Systems</organization>
      <address>
        <postal>
          <street/>
          <city/>
          <region/>
          <code/>
          <country/>
        </postal>
        <phone/>
        <email>dwing@cisco.com</email>
      </address>
    </author>

    <author fullname="Jonathan Rosenberg" initials="J." surname="Rosenberg">
      <organization>Cisco Systems</organization>
      <address>
        <postal>
          <street>600 Lanidex Plaza</street>
          <city>Parsippany</city>
          <region>New York</region>
          <code>07054</code>
          <country>USA</country>
        </postal>
        <email>jdrosen@cisco.com</email>
        <uri>http://www.jdrosen.net</uri>
      </address>
    </author>

    <author fullname="David Schwartz" initials="D." surname="Schwartz">
      <organization>Kayote Networks</organization>
      <address>
        <postal>
          <street>Malcha Technology Park</street>
          <city>Jerusalem</city>
          <code>96951</code>
          <country>Israel</country>
        </postal>
        <email>david.schwartz@kayote.com</email>
      </address>
    </author>

    <date year="2007"/>
    <area>Real-time Applications and Infrastructure</area>
    <workgroup>SIPPING</workgroup>
    <keyword>Internet-Draft</keyword>
    <keyword>Spam for Internet Telephony (SPIT)</keyword>

    <abstract>
      <t>Spam, defined as sending unsolicited messages to someone in bulk, might be a problem on SIP
        open-wide deployed networks. A number of solutions have been proposed for dealing with Spam
        for Internet Telephony (SPIT), for example, content filtering, black lists, white lists,
        consent-based communication, reputation systems, address obfuscation, limited use addresses,
        turing tests, computational puzzles, payments at risk, circles of trust, and many others.
        This document describes the big picture that illustrates how the different building blocks
        fit together and can be deployed incrementally.</t>
    </abstract>
  </front>

  <middle>
    <!-- ////////////////////////////////////////////////////////////////////////////////// -->

    <section anchor="introduction" title="Introduction">
      <t>The problem of Spam for Internet Telephony (SPIT) is an imminent challenge and only the
        combination of several techniques can provide a framework for dealing with unwanted
        communication attempts.</t>

      <t><xref target="I-D.ietf-sipping-spam"/> provides four core recommendations that need to be
        considered for a SPIT solution, namely</t>

      <t>
        <list style="symbols">
          <t>Strong Identity</t>

          <t>White Lists</t>

          <t>Solve the Introduction Problem</t>

          <t>Don't Wait Until its Too Late</t>
        </list>
      </t>

      <t>This document illustrates how existing building blocks can be put together to form a
        solution to deal with SPIT. New building blocks can be added to provide more efficient SPIT
        handling, since there is no single solution that provides 100 % protection.</t>

      <t>The main purpose of this document is largely to define a model of internal device
        processing, protocol interfaces, and terminology to illustrate a way in which SPIT
        prevention techniques can be added in a seamless fashion. We focus only on the most
        important solution components and consider many other aspects either outside the scope of
        this work (see <xref target="outside"/>) and postpone them for future work.</t>
    </section>

    <!-- ////////////////////////////////////////////////////////////////////////////////// -->

    <section anchor="terminology" title="Terminology">
      <t>The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT",
        "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in
        RFC 2119 <xref target="RFC2119"/>.</t>
    </section>

    <!-- ////////////////////////////////////////////////////////////////////////////////// -->

    <section title="Framework">
      <t>The framework considered in this document assumes that an end user uploads authorization
        policies to a SIP proxy of its VoIP provider. That VoIP provider enforces those
        authorization policies. This separation allows the end user to delegate some authorization
        decisions to the VoIP provider.</t>

      <t><xref target="overview"/> below shows the interaction between the end host and a SIP proxy
        belonging to its VoIP provider. The end user, in the role of a recipient for communication
        attempts, may upload authorization policies. The entity that writes the rules is referred as
        Rule Maker. The Rule Maker does not necessarily need to be recipient of the communication
        but it could instead be entity that acts on behalf of him or her. Note that a combination is
        possible as well where different entities contribute to the set of rules. These policies are
        processed by corresponding module within the SIP proxy, called Authorization Engine, that
        interacts with the message routing functionality. A part of the rule set might, however,
        also be created automatically as part of interactive interactions (e.g., monitoring ongoing
        communication attempts).</t>

      <t>
        <figure anchor="overview" title="Overview">
          <artwork><![CDATA[
            +---------------------------------------------------------+
            |                 Authorization                           |
            |  re-route       Policy                   +------------+ |
            |      ^          (implicit)         ######| Rule Maker | |
            |      o          +#######+          #     +------------+ |
            |      o          #       #          #                    |
            |  +---o----------#-------#--+       # Authorization      |
            |  |   o          #       #  |<####### Policy             |
+--------+  |  |   o   Proxy  #       #  |                            |
|        |  |  |   o          #       #  |<*******************+       |
| Sender |<***>|+-------+     v       #  |                    *       |
|        |  |  ||Msg.   |   +-----------+| Authorization      *       |
+--------+  |  ||Routing|   |  Authz.   || Policy (explicit)  *       |
  ^    o    |  ||Engine |<->|  Engine   |<#################+  *       |
  *    o    |  |+-------+   +-----------+|                 #  *       |
  *    o    |  +-^--*--^-----------------+                 #  v       |
  *    o    |    o  *  o                              +-------------+ |
  *    o    |    o  *  o                              |             | |
  *    +oooo|oooo+  *  +ooooooooooooooooooooooooooooo>|  Recipient/ | |
  +**************************************************>|  Rule Maker | |
            |                                         +-------------+ |
            |                                                         |
            |                                                         |
            +-------------------Domain Boundary-----------------------+

Legend:
         
oooo: SIP message interaction
****: Protocol Interaction for authorizing the message sender
####: Management of authorization policies          
          ]]></artwork>
        </figure>
      </t>

      <t>Assume that an arbitrary sender transmits a message towards the recipients URI that finally
        hits the SIP proxy on the recipients side. Information provided within that message are used
        as input to the rule evaluation. Any part of the message may serve as input to the
        evaluation process but for practical reasons only a few selected fields do most of the work.
        In this document, we argue that the authenticated identity of the sender is the most
        valuable information item. In the future, when standardization progresses then, for example,
        reputation information obtained from social networks may offer additional input to the
        authorization process.</t>
      <t>The protocol interaction for authorizing the message sender refers to the ability of the
        recipient or the proxy to interact with the sender to request authorization. The request for
        authorization is a pull model whereby the proxy or the recipient challenges the sender
        (e.g., via hash cash <xref target="I-D.jennings-sip-hashcash"/>, or SIP payment <xref
          target="I-D.jennings-sipping-pay"/>, or Completely Automated Public Turing Test to Tell
        Computers and Humans Apart (CAPTCHA) based robot challenges <xref
          target="I-D.tschofenig-sipping-captcha"/>) for authorization. SIP Identity on the other
        hand realizes as push model whereby authentication information is pushed towards the
        recipient.</t>
      <t><xref target="authz-engine"/> shows this integration step. The conditions part of the rule
        offer a mechanisms to incrementally extend the overall framework with new SPIT prevention
        solution components. Depending on the rule evaluation the message may be rerouted to another
        entity, such as an answering machine, to the recipient, rejected or other actions are
        triggered. The latter aspect is particularly interesting since it allows further solution
        components to be executed.</t>
      <t>
        <figure anchor="authz-engine" title="Message Filtering and Routing">
          <artwork><![CDATA[
  SIP msg with
  authenticated
  identity       +---------------+
  -------------->|               |---------------->
  Additional     |               | Spam marked msg
  Msg fields     | Authorization |
  -------------->| Engine        |---------------->
  Other SPIT     |               | Re-routed msg
  Prevention     |               |
  Components     |               |---------------->
  -------------->+---------------+ Forwarded to
                       |   |       original recipient
                       |   |
           <-----------+   +----------->||
       Politely blocked     Blocked
          ]]></artwork>
        </figure>
      </t>
      <t>Note that some traffic analysis and consequently some form of content filtering (e.g., of
        MESSAGEs) can be applied locally within the VoIP provider's domain also under the control of
        the end user. For example, consider a Voice over IP provider that wants to utilize a
        statistical analysis tool for Spam prevention. It is not necessary to standardized the
        algorithms; the impact for the authorization policies is mainly the ability to allow the
        Rule Maker to enable or to disable the usage of these statistical techniques for SPIT
        filtering and potentially to map the output of the analysis process to value range from 0
        (i.e., the message is not classified as Spam) and 100 (i.e., the message was classified as
        Spam). Conveying Spam marking is proposed in <xref target="I-D.schwartz-sipping-spit-saml"
        />, in <xref target="I-D.niccolini-sipping-feedback-spit"/> and in <xref
          target="I-D.wing-sipping-spam-score"/>. A Rule Maker may decide to act with an
        appropriate action on a certain level of Spam marking. </t>

      <t>In a minimalistic SPIT framework only authenticated identities in combination with
        authorization policies are used. This should serve as a starting point for future work.</t>

      <t>
        <list style="hanging">
          <t hangText="Authenticated Identities:"><vspace blankLines="1"/> SIP Identity <xref
              target="RFC4474"/> is assumed to be used to provide the receiver of a communication
            attempt with the authenticated identity. SIP Identity is a reasonable simple
            specification and does not rely on a huge amount of infrastructure support.<vspace
              blankLines="1"/>
            <list style="empty">
              <t>Note: SIP Identity is comparable to DomainKeys Identified Mail (DKIM) <xref
                  target="I-D.ietf-dkim-overview"/> used for associating a "responsible" identity
                with an email message and provides a means of verifying that the association is
                legitimate.</t>
            </list>
            <vspace blankLines="1"/></t>

          <t hangText="Authorization Policies:"><vspace blankLines="1"/> When the white lists are
            stored and managed only at the end host then the authorization policies and the protocol
            to modify the policies do not need to be standardized since they are purely
            implementation specific details. Even if the authorization policies are managed
            centrally or some amount of policy enforcement is done by trusted intermediaries then
            still there might not be a need to standardize an authorization policy language if the
            policies can be modified via a webpage. This type of policy handling is done in many
            cases today already for various applications. <vspace blankLines="1"/> Unfortunately,
            this approach tends to become cumbersome to manage for end users and therefore it is
            better to hide a lot of policy details from the end user itself and to make use of
            context information, for example, address books and authorization policies available
            already created for presence based systems. <vspace blankLines="1"/> In some cases the
            above-described approach is not sufficient whereby it is necessary to define a
            standardized protocol, for example, if policies are used by different entities, created
            and modified in an automatic way and when multiple entities manipulate policies
            (potentially on behalf of the person affected by the policies), e.g., the user may have
            multiple devices. <vspace blankLines="1"/> An example solution for authorization
            policies providing Spam prevention capabilities are described in <xref
              target="I-D.tschofenig-sipping-spit-policy"/> with the requirements detailed in <xref
              target="I-D.froment-sipping-spit-requirements"/>.</t>
        </list>
      </t>

      <t>The white list needs to be created somehow and hence there is an introduction problem.
          <xref target="communication-patterns"/> discusses this aspect in more details.</t>

      <!--      <t>Based on the above-described framework we discuss extensions in the subsequent
      sections.</t>
-->
    </section>

    <section anchor="communication-patterns" title="Communication Patterns and User Groups">
      <t>When communication takes place then at least three types of groups can be identified.</t>

      <section title="Closed Groups">
        <t>People in this group communicate only with the peers in their group. They do not
          appreciate communication attempts from outside. Communication is possible only for people
          within this list. Here is an example of a closed group: Consider parents that do not want
          their children from getting contacted by strangers. Hence, they may want to create a white
          list containing the identifies of known friends, parents and other relatives on behalf of
          their kids.</t>
        <t>The usage of authorization policies for usage with closed groups is straight forward. The
          introduction problem is also not considered very large given that the identities are
          typically known.</t>
      </section>

      <section title="Semi-Open Groups">
        <t>In a semi-open environment all members of the same group are allowed to get in contact
          with everyone else (e.g., for example in a company environment). For members outside the
          company the communication patters depend on the role of the person (e.g., standardization
          people, sales people, etc.) and on the work style of the person.</t>

        <t>For this category we distinguish a number of (non-spam) message sources based on their
          characteristics:</t>

        <t>
          <list style="symbols">
            <t>"friends" or "acquaintances", i.e., those we have communicated with before.</t>

            <t>strangers, divided into 'interesting' and 'uninteresting'. The latter are messages
              from people that someone does not care to have a conversation with or respond to, at
              least at that particular moment.</t>
          </list>
        </t>

        <t>Strangers can be defined by individual names or whole domains. A special class of
          'stranger' messages are transaction-related communications, such as Instant Messaging or
          automated calls from an airline or shipping company.</t>

        <t>One way to deal with the introduction problem is to make use of techniques like hash cash
            <xref target="I-D.jennings-sip-hashcash"/> or Completely Automated Public Turing Test to
          Tell Computers and Humans Apart (CAPTCHA) based robot challenges <xref
            target="I-D.tschofenig-sipping-captcha"/>. Alternatively, a communication attempt may
          also be forwarded to an answering maschine or alternative ways of establishing the initial
          interaction may be proposed. </t>

        <t>The usage of authorization policies for usage with Semi-Open Groups is challenging but is
          considered manageable.</t>

        <!--        <t>In the PSTN a certain amount of protection against unwanted calls is provided due to
          costs for phone calls. With almost free calls (or instant messages) it might be necessary
          to abandon the idea of allowing end-to-end real-time message delivery in all cases in
          order to avoid the alerting the user.</t>
-->
      </section>

      <section title="Open Groups">
        <t>People in this type of group are not allowed to limit communication attempts. Help desks,
          certain people in governmental agencies, banks, insurance companies, etc.</t>

        <t>For open groups a solution for providing SPIT prevention is far more complicated.
          Consider a person working on a customer support helpdesk. Ideally, they would like to
          receive only calls from friendly customers (although the motivation for calling is most
          likely a problem) and the topic of the calls only relates to problems they are able to
          solve. Without listening to the caller they will have a hard time to know whether the call
          could be classified as SPIT. Another extreme case is a Public Safety Answering Point where
          emergency service personell is not allowed to reject calls either. </t>
        <t> Many SPIT prevention techniques might not be applicable since blocking callers is likely
          not possible and applying other techniques, such as turing tests, might not be ideal in an
          case of open groups. </t>
        <t>Statistical analysis may be helpful in some cases to deliver additional information about
          the calling party. Social networks might provide similar techniques based on reputation
          based systems.</t>
      </section>

      <section title="Summary">
        <t>Based on the discussions regarding communication patters and groups the following
          observations can be made:</t>

        <t>
          <list style="symbols">
            <t>A single person very likely has many roles and they may have an impact on the
              communication patterns.<list style="empty">
                <t>For example, consider a person who is working in a company but also want to be
                  available for family members.</t>
              </list></t>

            <t>The context in which a person is may change at any time. For example, a person might
              be available for family members while at work except during an important meeting where
              communication attempts may be rejected. Switching a context has an impact for
              reachability and the means for communicating with a specific recipient, based on
              enabled rule sets.</t>
          </list>
        </t>

        <t>From an authorization policy point of view it is important to be able to express a
          sphere, i.e., the state a user is in and to switch between different spheres easily by
          thereby switching to a different rule set.</t>
      </section>

      <section title="Usability">
        <t>An important aspect in the usage of authorization policies is to assist the user when
          creating policies. Ideally, the policies should be established automatically. Below, there
          are a couple of examples to illustrate the idea given that these aspects are largely
          implementation issues:</t>

        <t>
          <list style="symbols">
            <t>It must be possible for the proxy to automatically add addresses on outbound messages
              and calls to the rule set. This approach is similar to stateful packet filtering
              firewalls where outbound packets establish state at the firewall to allow inbound
              packets to traverse it again.</t>

            <t>Already available information in the address book can be used for building the policy
              rules there is quite likely already a relationship available with these persons
              existent.</t>

            <t>A large amount of email is non-personal, automated communication, such as
              newsletters, confirmations and legitimate advertisements. These are often tagged as
              spam by content filters. This type of correspondence is usually initiated by a
              transaction over the web, such as a purchase or signing up for a service. <xref
                target="I-D.shacham-http-corr-uris"/>, for example, defines an HTTP header for
              conveying future correspondence addresses that can be integrated in the rule set.</t>
          </list>
        </t>
      </section>

      <!--  <t>There are, however, a couple of challenges that need to be addressed:</t>
      <t>
        <list style="symbols">
          <t>How is a communication attempt authorized that resulted on a previous real-world
            interaction? For example, Joe gives Jane a business card (but not vice versa or Joe has
            not updated her authorization policy). When Jane contacts Joe, Jane is not authorized
            yet.</t>
          <t>Is it necessary that some parties must be allowed to override the authorization
            policies when contacted by someone? </t>
        </list>
      </t>
      
      <t>When considering past experience on presence systems a couple of answers are available for
        the above-mentioned problems. Consent-based communication, for example, is a potential
        solution to communication attempts by unknown parties. In other cases it might be more
        reasonable to to make use of limited use addresses when a long-lasting communication is not
        desired.</t>        
      -->
    </section>

    <!-- ////////////////////////////////////////////////////////////////////////////////// -->

    <section title="Protocol Interactions">
      <t>This section describes the necessary building blocks that are necessary to tie the
        framework together. We will describe two different environments, namely one where rule
        enforcement happens at the end host and another one where a trusted network intermediary
        performs the actions.</t>

      <section title="End Host based Rule Enforcement">
        <t>
          <list style="symbols">
            <t>SIP Identity <xref target="RFC4474"/> is mandatory to implement at the end host and
              used to determine the authenticated identity of the sending side.</t>

            <t>Authorization policies are purely implementation specific matter.</t>
          </list>
        </t>
      </section>

      <t>Since a purely end host based rule enforcement suffers from a number of drawbacks, rule
        enforcement by a trusted intermediary is also offered.</t>

      <section title="Rule Enforcement via a Trusted Intermediary">
        <t>
          <list style="symbols">
            <t>SIP Identity <xref target="RFC4474"/> or a corresponding mechanism is mandatory to
              implement at the trusted intermediary (e.g., the immediate VoIP provider) and it
              determines the authenticated identity of the sending side.</t>

            <t>Authorization Policies based on the Common Policy framework <xref target="RFC4745"/>,
              as extended in <xref target="I-D.tschofenig-sipping-spit-policy"/> for the purpose of
              SPIT prevention, are mandatory to implement at the end host side and at the trusted
              intermediary. The implementation of the rule evaluation engine might only be necessary
              on the trusted VoIP proxy. Harmonization with the work done for presence authorization
                <xref target="I-D.ietf-simple-presence-rules"/>, which is based on Common Policy
                <xref target="RFC4745"/>, can be accomplished and is highly desirable.</t>

            <t>XML Configuration Access Protocol (XCAP) <xref target="RFC4825"/> is used to create,
              modify and delete authorization policies and is mandatory to implement at the end host
              side and at the trusted intermediary.</t>
          </list>
        </t>
      </section>

      <section title="Incremental Deployment">
        <t>An important property is incremental deployment of additional solution components that
          can be added and used when they become available. This section aims to illustrate how the
          extensibility is accomplished, based on an example.</t>

        <t>Consider a VoIP provider that provides authorization policies that provide the following
          functionality equivalent to the Common Policy framework, i.e., identity-based, sphere and
          validity based conditions initially. For actions only 'redirection' and 'blocking' is
          provided. In our example we give this basic functionality the AUID
          'new-spit-policy-example' with the namespace
          'urn:ietf:params:xml:ns:new-spit-policy-example'.</t>

        <t>When a client queries the capabilities of a SIP proxy in the VoIP providers network using
          XCAP the following exchange may take place.</t>

        <t>
          <figure title="Initial XCAP Query for Capabilities">
            <artwork><![CDATA[
GET   /xcap-caps/global/index HTTP/1.1
Host: xcap.example.com
      ]]></artwork>
          </figure>
        </t>

        <t>
          <figure title="Initial XCAP Response with the supported Capabilities">
            <artwork><![CDATA[              
 HTTP/1.1 200 OK
   Etag: "wwhha"
   Content-Type: application/xcap-caps+xml

   <?xml version="1.0" encoding="UTF-8"?>
   <xcap-caps xmlns="urn:ietf:params:xml:ns:xcap-caps">
     <auids>
          <auid>new-spit-policy-example</auid> 
          <auid>xcap-caps</auid>
     </auids>
     <namespaces>
        <namespace>urn:ietf:params:xml:ns:xcap-caps</namespace>
        <namespace>urn:ietf:params:xml:ns:spit-policy</namespace>
        <namespace>urn:ietf:params:xml:ns:common-policy</namespace>
     </namespaces>
   </xcap-caps>
      ]]></artwork>
          </figure>
        </t>

        <t>As shown in the example above, Common Policy and the example SPIT extension is
          implemented and the client can upload rules according to the definition of the rule set
          functionality.</t>

        <t>Later, when the VoIP provider updates the functionality of authorization policies as more
          sophisticated mechanisms become available and get implemented the functionality of the
          authorization policy engine is enhanced with, for example, hashcash and the ability to
          perform statistical analysis of signaling message. The latter functionality comes with the
          ability to mark messages are Spam and the ability for end users to enable/disable this
          functionality. We use the namespaces 'urn:ietf:params:xml:ns:hashcash' and
          'urn:ietf:params:xml:ns:statistical-analysis' for those.</t>

        <t>A end user could now make use of these new functions and a capability query of the SIP
          proxy would provide the following response.</t>

        <t>
          <figure title="Second XCAP Query for Capabilities">
            <artwork><![CDATA[
GET   /xcap-caps/global/index HTTP/1.1
Host: xcap.example.com
      ]]></artwork>
          </figure>
        </t>

        <t>
          <figure title="Second XCAP Response with the supported Capabilities">
            <artwork><![CDATA[              
 HTTP/1.1 200 OK
   Etag: "wwhha"
   Content-Type: application/xcap-caps+xml

   <?xml version="1.0" encoding="UTF-8"?>
   <xcap-caps xmlns="urn:ietf:params:xml:ns:xcap-caps">
     <auids>
          <auid>spit-policy</auid> 
          <auid>xcap-caps</auid>
          <auid>hashcash</auid>
          <auid>statistical-analysis</auid>
     </auids>
     <namespaces>
        <namespace>urn:ietf:params:xml:ns:spit-policy</namespace>
        <namespace>urn:ietf:params:xml:ns:common-policy</namespace>
        <namespace>urn:ietf:params:xml:ns:hashcash</namespace>
        <namespace>urn:ietf:params:xml:ns:statistical-analysis</namespace>
     </namespaces>
   </xcap-caps>
      ]]></artwork>
          </figure>
        </t>

        <t>New SPIT handling functionality may extend condition, actions and/or transformation
          elements of a rule.</t>
      </section>
    </section>

    <!-- ////////////////////////////////////////////////////////////////////////////////// -->

    <section title="Privacy Considerations">
      <t>This document does not propose to distribute the user's authorization policies to other
        VoIP providers nor is the configuration of policies at SIP proxies other than the trusted
        user's VoIP provider necessary. Furthemore, if blocking or influencing of the message
        processing is executed by the VoIP provider then they have to be explicitly enabled by the
        end user. Blocking of messages, even if it is based on "super-clever" machine learning
        techniques often introduces unpredictability.</t>

      <t>Legal norms from fields of law can take regulative effects in the context of SPIT
        processing, such as constitutional law, data protection law, telecommunication law,
        teleservices law, criminal law, and possibly administrative law. See, for example, <xref
          target="Law1"/>, <xref target="Law2"/> and <xref target="Law3"/>. For example, it is
        mandatory to pass full control of SPIT filtering to the end user, as this minimises legal
        problems.</t>

      <t>An overview about regulatory aspects can be found in <xref target="Spit-AL"/>.</t>
    </section>

    <!-- ////////////////////////////////////////////////////////////////////////////////// -->

    <section title="Example">
      <t>This section shows an example whereby we consider a user Bob@company-example.com that
        writes (most likely via a nice user interface) the following policies. We use a high-level
        language to show the main idea of the policies.</t>

      <t>
        <figure title="Example of Bob's Rule Set">
          <artwork><![CDATA[              
RULE 1: 
     IF identity=alice@foo.example.com THEN ACCEPT
     IF identity=tony@bar.example.com THEN ACCEPT

RULE 2: 
     IF domain=company-example.com THEN ACCEPT

RULE 3: 
     IF unauthenticated THEN 
            EXECUTE hashcash
            
RULE 4:
     IF <hashcash result="success"/>
     THEN
        REDIRECT sip:voicebox@company-example.com

RULE 5:
     IF <hashcash result="failure"/>
     THEN
        block
            ]]></artwork>
        </figure>
      </t>

      <t>At some point in time Bob uploads his policies to the SIP proxy at his VoIP providers SIP
        proxy.</t>

      <t>
        <figure title="Uploading Policies using XCAP">
          <artwork><![CDATA[                    
      PUT
      /spit-policy/users/sip:bob@company-example.com/index/~~/ruleset
            
      HTTP/1.1
      Content-Type:application/spit+xml
      Host: proxy.home-example.com
            
       <<<< Added policies go in here. >>>>
       [Editor's Note: In a future version an XML example 
                       policy document will be listed here.]
      ]]></artwork>
        </figure>
      </t>

      <t>When BoB receives a call from his friends, alice@foo.example and tony@bar.example.com, then
        all the rules related to the spit policy are checked. Only the first rule (rule 1) matches
        and is applied. Thus, the call is forwarded without any further checks based on Rule 1. The
        rules assume that the authenticated identity of the caller has been verified.</t>

      <t>When Bob receives a call from a co-worker, Charlie@company-example.com, Rule 2 is applied
        since the domain part in the rule matches the domain part of Charlie's identity.</t>

      <t>Now, when Bob receives a contact from an unknown user, called Mallice in this example. Rule
        3 indicates that an extended return-routability test using hashcash <xref
          target="I-D.jennings-sip-hashcash"/> is used with the call being redirected to Bob's
        voicebox afterwards. This exchange is shown in <xref target="malice"/>.</t>

      <t>
        <figure anchor="malice" title="Example Exchange: Malice contacts Bob">
          <artwork><![CDATA[                    
UA                         Proxy                                 Bob's
Malice                                                          Voicebox
  |         INVITE           |                                      |
  |------------------------->|Puzzle: work=15;                      |
  |                          |pre="VgVGYixbRg0mdSwTY3YIfCBuAAA=";   |
  |         419 with Puzzle  |image="NhhMQ2l7SE0VBmZFKksUC19ia04="; |
  |                          |value=160                             |
  |<-------------------------|                                      |
  |                          |                                      |
  |         ACK              |                                      |
  |------------------------->|                                      |
  |                          |Puzzle: work=0;                       |
  |                          |pre="VgVGYixbRg0mdSwTY3YIfCBuYmg=";   |
  |                          |image="NhhMQ2l7SE0VBmZFKksUC19ia04="  |
  |  INVITE with Solution    |value=160                             |
  |------------------------->|             INVITE                   |
  |                          |------------------------------------->|
  |                          |                                      |
  |                          |             180 Ringing              |
  |        180 Ringing       |<-------------------------------------|
  |<-------------------------|                                      |
  |                          |             200 OK                   |
  |        200 OK            |<-------------------------------------|
  |<-------------------------|                                      |
  |                          |      ACK                             |
  |---------------------------------------------------------------->|
  |                          |                                      |
      ]]></artwork>
        </figure>
      </t>
      <t>Depending on the outcome of the exchange the call is forwarded to a mailbox
        sip:voicebox@company-example.com (in case Malory returned the correct solution, see Rule 4)
        or blocked in case an incorrect response was provided. It might be quite easy to see how
        this rule set can be extended to support other SPIT handling mechanisms as well (e.g.,
        CAPTCHAs, SIP Pay, etc.). </t>
    </section>

    <!-- ////////////////////////////////////////////////////////////////////////////////// -->

    <section title="Security Considerations">
      <t>This document aims to describe a framework for addressing Spam for Internet Telephony
        (SPIT) in order to make it simple for users to influence the behavior of SIP message routing
        with an emphasis on SPIT prevention.</t>

      <t>The framework relies on three building blocks, namely SIP Identity, authorization policies
        based on Common Policy and Presence Authorization Policy, and XCAP.</t>

      <t>As a high-level overview, the framework allows the user to control end-to-end connectivity
        at the SIP message routing level whereby the glue that lets all parts fit together is based
        on authorization policies. Several other solution components can be developed independently
        and can be plugged into the framework as soon as available.</t>

      <t>It must be avoided to introduce Denial of Service attacks against the recipient by
        misguiding him or her to install authorization policies that allow senders to bypass the
        policies although that was never intended by the recipient. Additionally, it must not be
        possible by extensions to the authorization policy framework to create policies to block
        legitimate senders or to stall the processing of the authorization policy engine.</t>
    </section>

    <!-- ////////////////////////////////////////////////////////////////////////////////// -->

    <section title="Acknowledgments">
      <t>We would like to thank</t>
      <t>
        <list style="empty">
          <t>Jeremy Barkan, Dan York, Alexey Melnikov, Thomas Schreck, Eva Leppanen, Cullen
            Jennings, Marit Hansen and Markus Hansen for their review comments to a pre-00 version. </t>
          <t>Jeremy Barkan, Eva Leppanen, Michaela Greiler, Joachim Charzinski, Saverio Niccolini,
            Albert Caruana, and Juergen Quittek for their comments to the 00 version.</t>
        </list>
      </t>

    </section>

    <!-- ////////////////////////////////////////////////////////////////////////////////// -->
  </middle>

  <!-- ////////////////////////////////////////////////////////////////////////////////// -->

  <back>
    <references title="Normative References">
      <reference anchor="RFC2119">
        <front>
          <title abbrev="RFC Key Words">Key words for use in RFCs to Indicate Requirement Levels</title>

          <author fullname="Scott Bradner" initials="S." surname="Bradner">
            <organization>Harvard University</organization>
          </author>

          <date month="March" year="1997"/>
        </front>

        <format octets="4723" target="ftp://ftp.isi.edu/in-notes/rfc2119.txt" type="TXT"/>
      </reference> &RFC4474; &RFC4745; &RFC4825; </references>

    <references title="Informative References"> &I-D.ietf-sipping-spam;
      &I-D.ietf-simple-presence-rules; &I-D.jennings-sip-hashcash;
      &I-D.wing-sipping-spam-score; &I-D.ietf-sip-consent-framework;
      &I-D.ietf-dkim-overview; &I-D.tschofenig-sipping-spit-policy;
      &I-D.schwartz-sipping-spit-saml; &I-D.shacham-http-corr-uris;
      &I-D.jennings-sipping-pay; &I-D.froment-sipping-spit-requirements;
      &I-D.niccolini-sipping-feedback-spit; 
      &I-D.tschofenig-sipping-captcha; <reference anchor="Spit-AL">
        <front>
          <title>Developing a Legally Compliant Reachability Management System as a Countermeasure
            against SPIT, Third Annual VoIP Security Workshop, Berlin, available at
            https://tepin.aiki.de/blog/uploads/spit-al.pdf</title>
          <author fullname="Markus Hansen" initials="M." surname="Hansen">
            <organization/>
          </author>
          <author fullname="Marit Hansen" initials="M." surname="Hansen">
            <organization/>
          </author>
          <author fullname="Jan M&#246;ller" initials="J." surname="M&#246;ller">
            <organization/>
          </author>
          <author fullname="Thomas Rohwer" initials="T." surname="Rohwer">
            <organization/>
          </author>
          <author fullname="Carsten Tolkmitt" initials="C." surname="Tolkmitt">
            <organization/>
          </author>
          <author fullname="Henning Waack" initials="H." surname="Waack">
            <organization/>
          </author>
          <date month="June" year="2006"/>
        </front>
      </reference>
      <reference anchor="Law1">
        <front>
          <title>Bundesnetzagentur: Eckpunkte der regulatorischen Behandlung von Voice over IP
            (VoIP), available at http://www.bundesnetzagentur.de/media/archive/3186.pdf</title>
          <author>
            <organization/>
          </author>
          <date day="9" month="September" year="2005"/>
        </front>
      </reference>
      <reference anchor="Law2">
        <front>
          <title>70. Konferenz der Datenschutzbeauftragten des Bundes und der L&#228;nder:
            Entschlie&#223;ung Telefonieren mit Internettechnologie (Voice over IP &#8211;
            VoIP), available at http://www.datenschutzzentrum.de/material/themen/press
            e/20051028-dsbk-voip.htm</title>

          <author>
            <organization/>
          </author>
          <date day="28" month="Oktober" year="2005"/>
        </front>
      </reference>
      <reference anchor="Law3">
        <front>
          <title>Working Party 29 Opinion 2/2006 on privacy issues related to the provision of email
            screening services, WP 118, available at
            http://ec.europa.eu/justice_home/fsj/privacy/docs/wpdocs/2006/wp118_en.pdf</title>
          <author>
            <organization/>
          </author>
          <date day="21" month="February" year="2006"/>
        </front>
      </reference>
    </references>

    <!-- ////////////////////////////////////////////////////////////////////////////////// -->

    <section anchor="outside" title="Outside the Scope">
      <t>We consider the following aspects outside the scope of this document:</t>

      <t>
        <list style="symbols">
          <t>Mechanisms to publish SPIT causing parties on the Internet, i.e., information about
            domains that create SPIT.</t>

          <!-- <t>Mechanisms to mark a message as a SPIT message. We treat this as a purely domain
            specific aspect although it is conceivable to convey this information to the end host
            (or to other entities)</t>
          -->

          <t>Determining the source of unwanted traffic in real-time.</t>

          <t>Pushing packet filters and authorization policies towards the SPIT sending domain.</t>
        </list>
      </t>
    </section>

    <!-- ////////////////////////////////////////////////////////////////////////////////// -->
  </back>
</rfc>
