<?xml version="1.0" encoding="UTF-8"?>


<!DOCTYPE rfc SYSTEM "rfc2629-xhtml.ent">

<rfc xmlns:xi="http://www.w3.org/2001/XInclude" 
     ipr="trust200902"
     docName="draft-ietf-dots-architecture-18" 
     number="8811"
     submissionType="IETF" 
     category="info" 
     consensus="true" 
     obsoletes="" 
     updates="" 
     xml:lang="en" 
     tocInclude="true" 
     sortRefs="true" 
     symRefs="true" 
     version="3">

  <front>
    <title abbrev="DOTS Architecture">DDoS Open Threat Signaling (DOTS) Architecture</title>
    <seriesInfo name="RFC" value="8811"/>
    <author initials="A." surname="Mortensen" fullname="Andrew Mortensen" role="editor">
      <organization>Forcepoint</organization>
      <address>
        <postal>
          <street/>
          <city/>
          <code/>
          <country>United States of America</country>
        </postal>
        <email>andrewmortensen@gmail.com</email>
      </address>
    </author>
    <author initials="T." surname="Reddy.K" fullname="Tirumaleswar Reddy.K" role="editor">
      <organization>McAfee, Inc.</organization>
      <address>
        <postal>
          <street>Embassy Golf Link Business Park</street>
          <city>Bangalore</city><region>Karnataka</region>
          <code>560071</code>
          <country>India</country>
        </postal>
        <email>kondtir@gmail.com</email>
      </address>
    </author>
    <author initials="F." surname="Andreasen" fullname="Flemming Andreasen">
      <organization>Cisco</organization>
      <address>
        <postal>
          <street/>
          <city/>
          <code/>
          <country>United States of America</country>
        </postal>
        <email>fandreas@cisco.com</email>
      </address>
    </author>
    <author initials="N." surname="Teague" fullname="Nik Teague">
      <organization>Iron Mountain</organization>
      <address>
        <postal>
          <street/>
          <city/>
          <code/>
          <country>United States of America</country>
        </postal>
        <email>nteague@ironmountain.co.uk</email>
      </address>
    </author>
    <author initials="R." surname="Compton" fullname="Rich Compton">
      <organization>Charter</organization>
      <address>
        <postal>
          <street/>
          <city/>
          <code/>
        </postal>
        <email>Rich.Compton@charter.com</email>
      </address>
    </author>
    <date year="2020" month="August"/>
    <area>Security</area>
    <workgroup>DOTS</workgroup>

    <abstract>
      <t>This document describes an architecture for establishing and
      maintaining Distributed Denial-of-Service (DDoS) Open Threat Signaling
      (DOTS) within and between domains. The document does not specify
      protocols or protocol extensions, instead focusing on defining
      architectural relationships, components, and concepts used in a DOTS
      deployment.</t>
    </abstract>
  </front>
  <middle>


    <section anchor="context-and-motivation" numbered="true" toc="default">
      <name>Context and Motivation</name>
      <t>Signaling the need for help to defend against an active distributed
      denial-of-service (DDoS) attack requires a common understanding of
      mechanisms and roles among the parties coordinating a defensive
      response. The signaling layer and supplementary messaging are the focus
      of DDoS Open Threat Signaling (DOTS). DOTS defines a method of
      coordinating defensive measures among willing peers to mitigate attacks
      quickly and efficiently, enabling hybrid attack responses coordinated
      locally at or near the target of an active attack, or anywhere in path
      between attack sources and target. Sample DOTS use cases are elaborated
      in <xref target="I-D.ietf-dots-use-cases" format="default"/>.</t>
      <t>This document describes an architecture used in establishing,
      maintaining, or terminating a DOTS relationship within a domain or
      between domains.</t>
      <section anchor="terminology" numbered="true" toc="default">
        <name>Terminology</name>
        <section anchor="key-words" numbered="true" toc="default">
          <name>Key Words</name>

        <t>
    The key words "<bcp14>MUST</bcp14>", "<bcp14>MUST NOT</bcp14>",
    "<bcp14>REQUIRED</bcp14>", "<bcp14>SHALL</bcp14>", "<bcp14>SHALL
    NOT</bcp14>", "<bcp14>SHOULD</bcp14>", "<bcp14>SHOULD NOT</bcp14>",
    "<bcp14>RECOMMENDED</bcp14>", "<bcp14>NOT RECOMMENDED</bcp14>", "<bcp14>MAY</bcp14>", and
    "<bcp14>OPTIONAL</bcp14>" in this document are to be interpreted as described in
    BCP&nbsp;14 <xref target="RFC2119"/> <xref target="RFC8174"/> when, and
    only when, they appear in all capitals, as shown here.
        </t>



        </section>
        <section anchor="definition-of-terms" numbered="true" toc="default">
          <name>Definition of Terms</name>
          <t>This document uses the terms defined in <xref target="RFC8612" format="default"/>.</t>
        </section>
      </section>
      <section anchor="scope" numbered="true" toc="default">
        <name>Scope</name>
        <t>In this architecture, DOTS clients and servers communicate using
        DOTS signal channel <xref target="RFC8782" format="default"/> and data
        channel <xref target="RFC8783" format="default"/> protocols.</t>
        <t>The DOTS architecture presented here is applicable across network
        administrative domains, for example, between an enterprise domain and
        the domain of a third-party attack mitigation service, as well as to
        a single administrative domain. DOTS is generally assumed to be most
        effective when aiding coordination of attack response between two or
        more participating networks, but single domain scenarios are valuable
        in their own right, as when aggregating intra-domain DOTS client
        signals for an inter-domain coordinated attack response.</t>
        <t>This document does not address any administrative or business
        agreements that may be established between involved DOTS
        parties. Those considerations are out of scope. Regardless, this
        document assumes necessary authentication and authorization mechanisms
        are put in place so that only authorized clients can invoke the DOTS
        service.</t>
        <t>A detailed set of DOTS requirements are discussed in <xref
        target="RFC8612" format="default"/>, and the DOTS architecture is
        designed to follow those requirements. Only new behavioral
        requirements are described in this document.</t>
      </section>
      <section anchor="assumptions" numbered="true" toc="default">
        <name>Assumptions</name>
        <t>This document makes the following assumptions:</t>
        <ul spacing="normal">
          <li>All domains in which DOTS is deployed are assumed to offer the
          required connectivity between DOTS agents and any intermediary
          network elements, but the architecture imposes no additional
          limitations on the form of connectivity.</li>
          <li>Congestion and resource exhaustion are intended outcomes of a
          DDoS attack <xref target="RFC4732" format="default"/>. Some
          operators may utilize non-impacted paths or networks for
	  DOTS.  However,
          in general, conditions should be assumed to be hostile, and DOTS must
          be able to function in all circumstances, including when the
          signaling path is significantly impaired. Congestion control
          requirements are discussed in <xref target="RFC8612"
          sectionFormat="of" section="3"/>. The DOTS signal channel defined in <xref
          target="RFC8782" format="default"/> is designed to be extremely
          resilient under extremely hostile network conditions, and it
	  provides
          continued contact between DOTS agents even as DDoS attack traffic
          saturates the link.</li>
          <li>There is no universal DDoS attack scale threshold triggering a
          coordinated response across administrative domains. A network domain
          administrator or service or application owner may arbitrarily set
          attack scale threshold triggers, or manually send requests for
          mitigation.</li>
          <li>Mitigation requests may be sent to one or more upstream DOTS
          servers based on criteria determined by DOTS client administrators
          and the underlying network configuration. The number of DOTS servers
          with which a given DOTS client has established communications is
          determined by local policy and is deployment specific. For example,
          a DOTS client of a multihomed network may support built-in policies
          to establish DOTS relationships with DOTS servers located upstream
          of each interconnection link.</li>
          <li>The mitigation capacity and/or capability of domains receiving
          requests for coordinated attack response is opaque to the domains
          sending the request. The domain receiving the DOTS client signal may
          or may not have sufficient capacity or capability to filter any or
          all DDoS attack traffic directed at a target. In either case, the
          upstream DOTS server may redirect a request to another DOTS
          server. Redirection may be local to the redirecting DOTS server's
          domain or may involve a third-party domain.</li>
          <li>DOTS client and server signals, as well as messages sent through
          the data channel, are sent across any transit networks with the same
          probability of delivery as any other traffic between the DOTS client
          domain and the DOTS server domain. Any encapsulation required for
          successful delivery is left untouched by transit network
          elements. DOTS servers and DOTS clients cannot assume any preferential
          treatment of DOTS signals. Such preferential treatment may be
          available in some deployments (e.g., intra-domain scenarios), and
          the DOTS architecture does not preclude its use when
          available. However, DOTS itself does not address how that may be
          done.</li>
          <li>The architecture allows for, but does not assume, the presence
          of Quality-of-Service (QoS) policy agreements between DOTS-enabled
          peer networks or local QoS prioritization aimed at ensuring delivery
          of DOTS messages between DOTS agents. QoS is an operational
          consideration only, not a functional part of the DOTS
          architecture.</li>
          <li>The signal and data channels are loosely coupled and might not
          terminate on the same DOTS server. How the DOTS servers synchronize
          the DOTS configuration is out of scope of this specification. </li>
        </ul>
      </section>
    </section>
    <section anchor="architecture" numbered="true" toc="default">
      <name>DOTS Architecture</name>
      <t>The basic high-level DOTS architecture is illustrated in <xref target="fig-basic-arch" format="default"/>:</t>
      <figure anchor="fig-basic-arch">
        <name>Basic DOTS Architecture</name>
        <artwork name="" type="" align="left" alt=""><![CDATA[
    +-----------+            +-------------+
    | Mitigator | ~~~~~~~~~~ | DOTS Server |
    +-----------+            +-------------+
                                    |
                                    |
                                    |
    +---------------+        +-------------+
    | Attack Target | ~~~~~~ | DOTS Client |
    +---------------+        +-------------+
]]></artwork>
      </figure>
      <t>A simple example instantiation of the DOTS architecture could be an
      enterprise as the attack target for a volumetric DDoS attack and an
      upstream DDoS mitigation service as the mitigator. The service provided
      by the mitigator is called "DDoS mitigation service". The enterprise
      (attack target) is connected to the Internet via a link that is getting
      saturated, and the enterprise suspects it is under DDoS attack.

      The enterprise has a DOTS client, which obtains information about the
      DDoS attack and signals the DOTS server for help in mitigating the
      attack. In turn, the DOTS server invokes one or more mitigators, which
      are tasked with mitigating the actual DDoS attack and, hence, aim to
      suppress the attack traffic while allowing valid traffic to reach the
      attack target.</t>
      <t>The scope of the DOTS specifications is the interfaces between the
      DOTS client and DOTS server. The interfaces to the attack target and the
      mitigator are out of scope of DOTS. Similarly, the operation of both the
      attack target and the mitigator is out of scope of DOTS. Thus, DOTS
      specifies neither how an attack target decides it is under DDoS attack
      nor does DOTS specify how a mitigator may actually mitigate such an
      attack. A DOTS client's request for mitigation is advisory in nature
      and might not lead to any mitigation at all, depending on the DOTS
      server domain's capacity and willingness to mitigate on behalf of the
      DOTS client domain.</t>
      <t>The DOTS client may be provided with a list of DOTS servers, each
      associated with one or more IP addresses. These addresses may or may not
      be of the same address family. The DOTS client establishes one or more
      sessions by connecting to the provided DOTS server addresses.</t>
      <t>As illustrated in <xref target="fig-interfaces" format="default"/>,
      there are two interfaces between a DOTS server and a DOTS client: a
      signal channel and (optionally) a data channel.</t>
      <figure anchor="fig-interfaces">
        <name>DOTS Interfaces</name>
        <artwork name="" type="" align="left" alt=""><![CDATA[
  +---------------+                                 +---------------+
  |               | <------- Signal Channel ------> |               |
  |  DOTS Client  |                                 |  DOTS Server  |
  |               | <=======  Data Channel  ======> |               |
  +---------------+                                 +---------------+
]]></artwork>
      </figure>
      <t>The primary purpose of the signal channel is for a DOTS client to ask
      a DOTS server for help in mitigating an attack and for the DOTS server
      to inform the DOTS client about the status of such mitigation. The DOTS
      client does this by sending a client signal that contains information
      about the attack target(s). The client signal may also include telemetry
      information about the attack, if the DOTS client has such information
      available. In turn, the DOTS server sends a server signal to inform the
      DOTS client of whether it will honor the mitigation request. Assuming it
      will, the DOTS server initiates attack mitigation and periodically
      informs the DOTS client about the status of the mitigation.  Similarly,
      the DOTS client periodically informs the DOTS server about the client's
      status, which, at a minimum, provides client (attack target) health
      information; it should also include efficacy information about the
      attack mitigation as it is now seen by the client. At some point, the
      DOTS client may decide to terminate the server-side attack mitigation,
      which it indicates to the DOTS server over the signal channel. A
      mitigation may also be terminated if a DOTS client-specified mitigation
      lifetime is exceeded. Note that the signal channel may need to operate
      over a link that is experiencing a DDoS attack and, hence, is subject to
      severe packet loss and high latency.</t>
      <t>While DOTS is able to request mitigation with just the signal
      channel, the addition of the DOTS data channel provides for additional,
      more efficient capabilities. The primary purpose of the data channel is
      to support DOTS-related configuration and policy information exchange
      between the DOTS client and the DOTS server. Examples of such
      information include, but are not limited to:</t>
      <ul spacing="normal">
        <li>Creating identifiers, such as names or aliases, for resources for
        which mitigation may be requested. Such identifiers may then be used
        in subsequent signal channel exchanges to refer more efficiently to
        the resources under attack. </li>
      </ul>
      <ul spacing="normal">
        <li>Drop-list management, which enables a DOTS client to inform the
        DOTS server about sources to suppress.</li>
        <li>Accept-list management, which enables a DOTS client to inform the
        DOTS server about sources from which traffic is always accepted.</li>
        <li>Filter management, which enables a DOTS client to install or
        remove traffic filters dropping or rate-limiting unwanted
        traffic.</li>
        <li>DOTS client provisioning.</li>
      </ul>
      <t>Note that, while it is possible to exchange the above information
      before, during, or after a DDoS attack, DOTS requires reliable delivery
      of this information and does not provide any special means for ensuring
      timely delivery of it during an attack. In practice, this means that
      DOTS deployments should rely on such information being exchanged only
      under normal traffic conditions.</t>
      <section anchor="operations" numbered="true" toc="default">
        <name>DOTS Operations</name>
        <t>DOTS does not prescribe any specific deployment models; however,
        DOTS is designed with some specific requirements around the different
        DOTS agents and their relationships.</t>
        <t>First of all, a DOTS agent belongs to a domain that has an identity
        that can be authenticated and authorized. DOTS agents communicate
        with each other over a mutually authenticated signal channel and
        (optionally) data channel. However, before they can do so, a service
        relationship needs to be established between them.  The details and
        means by which this is done is outside the scope of DOTS; however, an
        example would be for an enterprise A (DOTS client) to sign up for DDoS
        service from provider B (DOTS server). This would establish a
        (service) relationship between the two that enables enterprise A's
        DOTS client to establish a signal channel with provider B's DOTS
        server. A and B will authenticate each other, and B can verify that A
        is authorized for its service.</t>
        <t>From an operational and design point of view, DOTS assumes that the
        above relationship is established prior to a request for DDoS attack
        mitigation. In particular, it is assumed that bidirectional
        communication is possible at this time between the DOTS client and
        DOTS server. Furthermore, it is assumed that additional service
        provisioning, configuration, and information exchange can be performed
        by use of the data channel if operationally required. It is not until
        this point that the mitigation service is available for use.</t>
        <t>Once the mutually authenticated signal channel has been
        established, it will remain active. This is done to increase the
        likelihood that the DOTS client can signal the DOTS server for help
        when the attack target is being flooded, and similarly raise the
        probability that DOTS server signals reach the client regardless of
        inbound link congestion.  This does not necessarily imply that the
        attack target and the DOTS client have to be co-located in the same
        administrative domain, but it is expected to be a common scenario.</t>
        <t>DDoS mitigation with the help of an upstream mitigator may involve
        some form of traffic redirection whereby traffic destined for the
        attack target is steered towards the mitigator. Common mechanisms to
        achieve this redirection depend on BGP <xref target="RFC4271"
        format="default"/> and DNS <xref target="RFC1035"
        format="default"/>. In turn, the mitigator inspects and scrubs the
        traffic and forwards the resulting (hopefully non-attack) traffic to
        the attack target. Thus, when a DOTS server receives an attack
        mitigation request from a DOTS client, it can be viewed as a way of
        causing traffic redirection for the attack target indicated.</t>
        <t>DOTS relies on mutual authentication and the pre-established
        service relationship between the DOTS client domain and the DOTS
        server domain to provide authorization. The DOTS server should enforce
        authorization mechanisms to restrict the mitigation scope a DOTS
        client can request, but such authorization mechanisms are
        deployment specific.</t>
        <t>Although co-location of DOTS server and mitigator within the same
        domain is expected to be a common deployment model, it is assumed that
        operators may require alternative models. Nothing in this document
        precludes such alternatives.</t>
      </section>
      <section anchor="components" numbered="true" toc="default">
        <name>Components</name>


        <section anchor="dots-client" numbered="true" toc="default">
          <name>DOTS Client</name>
          <t>A DOTS client is a DOTS agent from which requests for help
          coordinating an attack response originate. The requests may be in
          response to an active, ongoing attack against a target in the DOTS
          client domain, but no active attack is required for a DOTS client to
          request help. Operators may wish to have upstream mitigators in the
          network path for an indefinite period and are restricted only by
          business relationships when it comes to duration and scope of
          requested mitigation.</t>
          <t>The DOTS client requests attack response coordination from a DOTS
          server over the signal channel, including in the request the DOTS
          client's desired mitigation scoping, as described in <xref
          target="RFC8612" format="default"/> (SIG-008). The actual mitigation
          scope and countermeasures used in response to the attack are up to
          the DOTS server and mitigator operators, as the DOTS client may have
          a narrow perspective on the ongoing attack. As such, the DOTS
          client's request for mitigation should be considered advisory:
          guarantees of DOTS server availability or mitigation capacity
          constitute Service Level Agreements (SLAs) and are out of scope for this
          document.</t>
          <t>The DOTS client adjusts mitigation scope and provides available
          mitigation feedback (e.g., mitigation efficacy) at the direction of
          its local administrator. Such direction may involve manual or
          automated adjustments in response to updates from the DOTS
          server.</t>
          <t>To provide a metric of signal health and distinguish an idle
          signal channel from a disconnected or defunct session, the DOTS
          client sends a heartbeat over the signal channel to maintain its
          half of the channel. The DOTS client similarly expects a heartbeat
          from the DOTS server and may consider a session terminated in the
          extended absence of a DOTS server heartbeat.</t>
        </section>

        <section anchor="dots-server" numbered="true" toc="default">
          <name>DOTS Server</name>

          <t>A DOTS server is a DOTS agent capable of receiving, processing,
          and possibly acting on requests for help coordinating attack
          responses from DOTS clients.  The DOTS server authenticates and
          authorizes DOTS clients as described in <xref target="dots-sessions"
          format="default"/> and maintains session state, tracks requests
          for mitigation, reports on the status of active mitigations, and
          terminates sessions in the extended absence of a client heartbeat
          or when a session times out.</t>
          <t>Assuming the preconditions discussed below exist, a DOTS client
          maintaining an active session with a DOTS server may reasonably
          expect some level of mitigation in response to a request for
          coordinated attack response.</t>

          <t>For a given DOTS client (administrative) domain, the DOTS server
          needs to be able to determine whether a given resource is in that
          domain. For example, this could take the form of associating a set
          of IP addresses and/or prefixes per DOTS client domain.  The DOTS
          server enforces authorization of signals for mitigation, filtering
          rules, and aliases for resources from DOTS clients. The mechanism of
          enforcement is not in scope for this document but is expected to
          restrict mitigation requests, filtering rules, aliases for addresses
          and prefixes, and/or services owned by the DOTS client domain, such
          that a DOTS client from one domain is not able to influence the
          network path to another domain. A DOTS server <bcp14>MUST</bcp14>
          reject mitigation requests, filtering rules, and aliases for
          resources not owned by the requesting DOTS client's administrative
          domain. The exact mechanism for the DOTS servers to validate that
          the resources are within the scope of the DOTS client domain is
          deployment specific. For example, if the DOTS client domain uses
          Provider-Aggregatable prefixes for its resources and leverages the
          DDoS mitigation service of the Internet Transit Provider (ITP); the
          ITP knows the prefixes assigned to the DOTS client domain because
          they are assigned by the ITP itself. However, if the DDoS Mitigation
          is offered by a third-party DDoS mitigation service provider; it
          does not know the resources owned by the DOTS client domain. The
          DDoS mitigation service provider and the DOTS client domain can opt
          to use the identifier validation challenges discussed in <xref
          target="RFC8555" format="default"/> and <xref target="RFC8738"
          format="default"/> to identify whether or not the DOTS client domain
          actually controls the resources. The challenges for validating
          control of resources must be performed when no attack traffic is
          present and works only for "dns" and "ip" identifier types. Further,
          if the DOTS client lies about the resources owned by the DOTS client
          domain, the DDoS mitigation service provider can impose penalties
          for violating the SLA. A DOTS server <bcp14>MAY</bcp14> also refuse
          a DOTS client's mitigation request for arbitrary reasons, within any
          limits imposed by business or SLAs between client and server
          domains.  If a DOTS server refuses a DOTS client's request for
          mitigation, the DOTS server <bcp14>MUST</bcp14> include the refusal
          reason in the server signal sent to the client.</t>
          <t>A DOTS server is in regular contact with one or more
          mitigators. If a DOTS server accepts a DOTS client's request for
          help, the DOTS server forwards a translated form of that request to
          the mitigator(s) responsible for scrubbing attack traffic. Note that
          the form of the translated request passed from the DOTS server to
          the mitigator is not in scope; it may be as simple as an alert to
          mitigator operators, or highly automated using vendor or open
          application programming interfaces supported by the mitigator. The
          DOTS server <bcp14>MUST</bcp14> report the actual scope of any
          mitigation enabled on behalf of a client.</t>
          <t>The DOTS server <bcp14>SHOULD</bcp14> retrieve available metrics
          for any mitigations activated on behalf of a DOTS client and
          <bcp14>SHOULD</bcp14> include them in server signals sent to the
          DOTS client originating the request for mitigation.</t>
          <t>To provide a metric of signal health and distinguish an idle
          signal channel from a disconnected or defunct channel, the DOTS
          server <bcp14>MUST</bcp14> send a heartbeat over the signal channel
          to maintain its half of the channel. The DOTS server similarly
          expects a heartbeat from the DOTS client and <bcp14>MAY</bcp14>
          consider a session terminated in the extended absence of a DOTS
          client heartbeat.</t>
        </section>
        <section anchor="dots-gateway" numbered="true" toc="default">
          <name>DOTS Gateway</name>
          <t>Traditional client/server relationships may be expanded by
          chaining DOTS sessions. This chaining is enabled through "logical
          concatenation" of a DOTS server and a DOTS client, resulting in an
          application analogous to the Session Initiation Protocol (SIP) <xref
          target="RFC3261" format="default"/> logical entity of a Back-to-Back
          User Agent (B2BUA) <xref target="RFC7092" format="default"/>. The
          term "DOTS gateway" is used here in the descriptions of selected
          scenarios involving this application.</t>
          <t>A DOTS gateway may be deployed client side, server side, or both.
          The gateway may terminate multiple discrete client connections and
          may aggregate these into a single or multiple DOTS session(s).</t>
          <t>The DOTS gateway will appear as a server to its downstream agents
          and as a client to its upstream agents, a functional concatenation
          of the DOTS client and server roles, as depicted in <xref
          target="fig-dots-gateway" format="default"/>:</t>
          <figure anchor="fig-dots-gateway">
            <name>DOTS Gateway</name>
            <artwork name="" type="" align="left" alt=""><![CDATA[
                      +-------------+
                      |    | D |    |
      +----+          |    | O |    |         +----+
      | c1 |----------| s1 | T | c2 |---------| s2 |
      +----+          |    | S |    |         +----+
                      |    | G |    |
                      +-------------+
]]></artwork>
          </figure>
          <t>The DOTS gateway <bcp14>MUST</bcp14> perform full stack DOTS
          session termination and reorigination between its client and server
          side. The details of how this is achieved are implementation
          specific. </t>
        </section>
      </section>
      <section anchor="agent-relationships" numbered="true" toc="default">
        <name>DOTS Agent Relationships</name>
        <t>So far, we have only considered a relatively simple scenario of a
        single DOTS client associated with a single DOTS server; however, DOTS
        supports more advanced relationships.</t>
        <t>A DOTS server may be associated with one or more DOTS clients, and those DOTS
clients may belong to different domains. An example scenario is a mitigation
provider serving multiple attack targets (<xref target="fig-multi-client-server" format="default"/>).</t>
        <figure anchor="fig-multi-client-server">
          <name>DOTS Server with Multiple Clients</name>
          <artwork name="" type="" align="left" alt=""><![CDATA[
   DOTS clients       DOTS server
   +---+
   | c |-----------
   +---+           \
   c1.example.org   \
                     \
   +---+              \ +---+
   | c |----------------| S |
   +---+              / +---+
   c1.example.com    /  dots1.example.net
                    /
   +---+           /
   | c |-----------
   +---+
   c2.example.com
]]></artwork>
        </figure>
        <t>A DOTS client may be associated with one or more DOTS servers, and those DOTS
servers may belong to different domains.  This may be to ensure high
availability or coordinate mitigation with more than one directly connected
ISP.  An example scenario is for an enterprise to have DDoS mitigation service
from multiple providers, as shown in <xref target="fig-multi-homed-client" format="default"/>.</t>
        <figure anchor="fig-multi-homed-client">
          <name>Multihomed DOTS Client</name>
          <artwork name="" type="" align="left" alt=""><![CDATA[
   DOTS client        DOTS servers
                       +---+
            -----------| S |
           /           +---+
          /            dots1.example.net
         /
   +---+/              +---+
   | c |---------------| S |
   +---+\              +---+
         \             dots.example.org
          \
           \           +---+
            -----------| S |
                       +---+
   c.example.com       dots2.example.net
]]></artwork>
        </figure>
        <t>Deploying a multihomed client requires extra care and planning, as the DOTS
servers with which the multihomed client communicates might not be affiliated.
Should the multihomed client simultaneously request for mitigation from all
servers with which it has established signal channels, the client may
unintentionally inflict additional network disruption on the resources it
intends to protect. In one of the worst cases, a multihomed DOTS client could
cause a permanent routing loop of traffic destined for the client's
protected services, as the uncoordinated DOTS servers' mitigators all try to
divert that traffic to their own scrubbing centers.</t>
        <t>The DOTS protocol itself provides no fool-proof method to prevent such
self-inflicted harms as a result of deploying multihomed DOTS clients. If
DOTS client implementations nevertheless include support for multihoming, they
are expected to be aware of the risks, and consequently to include measures
aimed at reducing the likelihood of negative outcomes. Simple measures might
include:</t>
        <ul spacing="normal">
          <li>Requesting mitigation serially, ensuring only one mitigation request for
a given address space is active at any given time;</li>
          <li>Dividing the protected resources among the DOTS servers, such that no two
mitigators will be attempting to divert and scrub the same traffic;</li>
          <li>Restricting multihoming to deployments in which all DOTS servers are
coordinating management of a shared pool of mitigation resources.</li>
        </ul>
        <section anchor="gatewayed-signaling" numbered="true" toc="default">
          <name>Gatewayed Signaling</name>
          <t>As discussed in <xref target="dots-gateway" format="default"/>, a
          DOTS gateway is a logical function chaining DOTS sessions through
          concatenation of a DOTS server and DOTS client.</t>
          <t>An example scenario, as shown in <xref
          target="fig-client-gateway-agg" format="default"/> and <xref
          target="fig-client-gateway-noagg" format="default"/>, is for an
          enterprise to have deployed multiple DOTS-capable devices that are
          able to signal intra-domain using TCP <xref target="RFC0793"
          format="default"/> on uncongested links to a DOTS gateway that may
          then transform these to a UDP <xref target="RFC0768"
          format="default"/> transport inter-domain where connection-oriented
          transports may degrade; this applies to the signal channel only, as
          the data channel requires a connection-oriented transport. The
          relationship between the gateway and its upstream agents is opaque
          to the initial clients.</t>
          <figure anchor="fig-client-gateway-agg">
            <name>Client-Side Gateway with Aggregation</name>
            <artwork name="" type="" align="left" alt=""><![CDATA[
      +---+
      | c |\
      +---+ \              +---+
             \-----TCP-----| D |               +---+
      +---+                | O |               |   |
      | c |--------TCP-----| T |------UDP------| S |
      +---+                | S |               |   |
             /-----TCP-----| G |               +---+
      +---+ /              +---+
      | c |/
      +---+
      example.com       example.com           example.net
      DOTS clients      DOTS gateway (DOTSG)  DOTS server
]]></artwork>
          </figure>
          <figure anchor="fig-client-gateway-noagg">
            <name>Client-Side Gateway without Aggregation</name>
            <artwork name="" type="" align="left" alt=""><![CDATA[
      +---+
      | c |\
      +---+ \              +---+
             \-----TCP-----| D |------UDP------+---+
      +---+                | O |               |   |
      | c |--------TCP-----| T |------UDP------| S |
      +---+                | S |               |   |
             /-----TCP-----| G |------UDP------+---+
      +---+ /              +---+
      | c |/
      +---+
      example.com       example.com           example.net
      DOTS clients      DOTS gateway (DOTSG)  DOTS server
]]></artwork>
          </figure>
          <t>This may similarly be deployed in the inverse scenario where the gateway resides
in the server-side domain and may be used to terminate and/or aggregate multiple
clients to a single transport as shown in <xref target="fig-server-gateway-agg" format="default"/> and
<xref target="fig-server-gateway-noagg" format="default"/>.</t>
          <figure anchor="fig-server-gateway-agg">
            <name>Server-Side Gateway with Aggregation</name>
            <artwork name="" type="" align="left" alt=""><![CDATA[
      +---+
      | c |\
      +---+ \              +---+
             \-----UDP-----| D |               +---+
      +---+                | O |               |   |
      | c |--------TCP-----| T |------TCP------| S |
      +---+                | S |               |   |
             /-----TCP-----| G |               +---+
      +---+ /              +---+
      | c |/
      +---+
      example.com       example.net           example.net
      DOTS clients      DOTS gateway (DOTSG)  DOTS server
]]></artwork>
          </figure>
          <figure anchor="fig-server-gateway-noagg">
            <name>Server-Side Gateway without Aggregation</name>
            <artwork name="" type="" align="left" alt=""><![CDATA[
      +---+
      | c |\
      +---+ \              +---+
             \-----UDP-----| D |------TCP------+---+
      +---+                | O |               |   |
      | c |--------TCP-----| T |------TCP------| S |
      +---+                | S |               |   |
             /-----UDP-----| G |------TCP------+---+
      +---+ /              +---+
      | c |/
      +---+
      example.com       example.net           example.net
      DOTS clients      DOTS gateway (DOTSG)  DOTS server
]]></artwork>
          </figure>
          <t>This document anticipates scenarios involving multiple DOTS gateways. An example
is a DOTS gateway at the network client's side and another one at the server
side. The first gateway can be located at Customer Premises Equipment (CPE) to aggregate requests from
multiple DOTS clients enabled in an enterprise network. The second DOTS gateway
is deployed on the provider side. This scenario can be seen as a combination of
the client-side and server-side scenarios.</t>
        </section>
      </section>
    </section>
    <section anchor="concepts" numbered="true" toc="default">
      <name>Concepts</name>
      <section anchor="dots-sessions" numbered="true" toc="default">
        <name>DOTS Sessions</name>
        <t>In order for DOTS to be effective as a vehicle for DDoS mitigation
        requests, one or more DOTS clients must establish ongoing
        communication with one or more DOTS servers. While the preconditions
        for enabling DOTS in or among network domains may also involve
        business relationships, SLAs, or other formal or
        informal understandings between network operators, such considerations
        are out of scope for this document.</t>
        <t>A DOTS session is established to support bilateral exchange of data
        between an associated DOTS client and a DOTS server. In the DOTS
        architecture, data is exchanged between DOTS agents over signal and
        data channels. As such, a DOTS session can be a DOTS signal channel
        session, a DOTS data channel session, or both. The DOTS server couples
        the DOTS signal and data channel sessions using the DOTS client
        identity. The DOTS session is further elaborated in the DOTS signal
        channel protocol defined in <xref target="RFC8782" format="default"/>
        and the DOTS data channel protocol defined in <xref target="RFC8783"
        format="default"/>.</t>
        <t>A DOTS agent can maintain one or more DOTS sessions.</t>
        <t>A DOTS signal channel session is associated with a single transport
        connection (TCP or UDP session) and a security association (a TLS or
        DTLS session). Similarly, a DOTS data channel session is associated
        with a single TCP connection and a TLS security association.</t>
        <t>Mitigation requests created using the DOTS signal channel are not bound
        to the DOTS signal channel session. Instead, mitigation requests are
        associated with a DOTS client and can be managed using different DOTS
        signal channel sessions.</t>
        <section anchor="dots-session-preconditions" numbered="true" toc="default">
          <name>Preconditions</name>
          <t>Prior to establishing a DOTS session between agents, the owners
          of the networks, domains, services or applications involved are
          assumed to have agreed upon the terms of the relationship
          involved. Such agreements are out of scope for this document but
          must be in place for a functional DOTS architecture.</t>
          <t>It is assumed that, as part of any DOTS service agreement, the
          DOTS client is provided with all data and metadata required to
          establish communication with the DOTS server. Such data and metadata
          would include any cryptographic information necessary to meet the
          message confidentiality, integrity, and authenticity requirement
          (SEC-002) in <xref target="RFC8612" format="default"/> and might
          also include the pool of DOTS server addresses and ports the DOTS
          client should use for signal and data channel messaging.</t>
        </section>
        <section anchor="establishing-dots-session" numbered="true" toc="default">
          <name>Establishing the DOTS Session</name>
          <t>With the required business agreements in place, the DOTS client
          initiates a DOTS session by contacting its DOTS server(s) over the
          signal channel and (possibly) the data channel. To allow for DOTS
          service flexibility, neither the order of contact nor the time
          interval between channel creations is specified. A DOTS client
          <bcp14>MAY</bcp14> establish the signal channel first, and then the
          data channel, or vice versa.</t>
          <t>The methods by which a DOTS client receives the address and
          associated service details of the DOTS server are not prescribed by
          this document. For example, a DOTS client may be directly configured
          to use a specific DOTS server IP address and port, and be directly
          provided with any data necessary to satisfy the Peer Mutual
          Authentication requirement (SEC-001) in <xref target="RFC8612"
          format="default"/>, such as symmetric or asymmetric keys, usernames,
          passwords, etc. All configuration and authentication information
          in this scenario is provided out of band by the domain operating the
          DOTS server.</t>
          <t>At the other extreme, the architecture in this document allows
          for a form of DOTS client auto-provisioning. For example, the domain
          operating the DOTS server or servers might provide the client domain
          only with symmetric or asymmetric keys to authenticate the
          provisioned DOTS clients. Only the keys would then be directly
          configured on DOTS clients, but the remaining configuration required
          to provision the DOTS clients could be learned through mechanisms
          similar to DNS SRV <xref target="RFC2782" format="default"/> or DNS
          Service Discovery <xref target="RFC6763" format="default"/>.</t>
          <t>The DOTS client <bcp14>SHOULD</bcp14> successfully authenticate
          and exchange messages with the DOTS server over both the signal and (if
          used) data channel as soon as possible to confirm that both channels
          are operational.</t>
          <t>As described in <xref target="RFC8612" format="default"/>
          (DM-008), the DOTS client can configure preferred values for
          acceptable signal loss, mitigation lifetime, and heartbeat intervals
          when establishing the DOTS signal channel session. A DOTS signal
          channel session is not active until DOTS agents have agreed on the
          values for these DOTS session parameters, a process defined by the
          protocol.</t>
          <t>Once the DOTS client begins receiving DOTS server signals, the
          DOTS session is active. At any time during the DOTS session, the
          DOTS client may use the data channel to manage aliases, manage drop-
          and accept-listed prefixes or addresses, leverage vendor-specific
          extensions, and so on. Note that unlike the signal channel, there is
          no requirement that the data channel remains operational in attack
          conditions. (See "Data Channel Requirements" <xref
          target="RFC8612" sectionFormat="of" section="2.3"/>).</t>
        </section>
        <section anchor="maintaining-dots-session" numbered="true" toc="default">
          <name>Maintaining the DOTS Session</name>
          <t>DOTS clients and servers periodically send heartbeats to each
          other over the signal channel, discussed in <xref target="RFC8612"
          format="default"/> (SIG-004).  DOTS agent operators
          <bcp14>SHOULD</bcp14> configure the heartbeat interval such that the
          frequency does not lead to accidental denials of service due to the
          overwhelming number of heartbeats a DOTS agent must field.</t>
          <t>Either DOTS agent may consider a DOTS signal channel session
          terminated in the extended absence of a heartbeat from its peer
          agent. The period of that absence will be established in the
          protocol definition.</t>
        </section>
      </section>
      <section anchor="modes-of-signaling" numbered="true" toc="default">
        <name>Modes of Signaling</name>
        <t>This section examines the modes of signaling between agents in a DOTS
architecture.</t>
        <section anchor="direct-signaling" numbered="true" toc="default">
          <name>Direct Signaling</name>
          <t>A DOTS session may take the form of direct signaling between the DOTS
clients and servers, as shown in <xref target="fig-direct-signaling" format="default"/>.</t>
          <figure anchor="fig-direct-signaling">
            <name>Direct Signaling</name>
            <artwork name="" type="" align="left" alt=""><![CDATA[
        +-------------+                            +-------------+
        | DOTS client |<------signal session------>| DOTS server |
        +-------------+                            +-------------+
]]></artwork>
          </figure>
          <t>In a direct DOTS session, the DOTS client and server are
          communicating directly.  Direct signaling may exist inter- or
          intra-domain. The DOTS session is abstracted from the underlying
          networks or network elements the signals traverse; in direct
          signaling, the DOTS client and server are logically adjacent.</t>
        </section>
        <section anchor="redirected-signaling" numbered="true" toc="default">
          <name>Redirected Signaling</name>
          <t>In certain circumstances, a DOTS server may want to redirect a DOTS client to
an alternative DOTS server for a DOTS signal channel session. Such
circumstances include but are not limited to:</t>
          <ul spacing="normal">
            <li>Maximum number of DOTS signal channel sessions with clients has been reached;</li>
            <li>Mitigation capacity exhaustion in the mitigator with which the
specific DOTS server is communicating;</li>
            <li>Mitigator outage or other downtime such as scheduled maintenance;</li>
            <li>Scheduled DOTS server maintenance;</li>
            <li>Scheduled modifications to the network path between DOTS server and DOTS
client.</li>
          </ul>
          <t>A basic redirected DOTS signal channel session resembles the following, as
shown in <xref target="fig-redirected-signaling" format="default"/>.</t>
          <figure anchor="fig-redirected-signaling">
            <name>Redirected Signaling</name>
            <artwork name="" type="" align="left" alt=""><![CDATA[
        +-------------+                            +---------------+
        |             |<-(1)--- DOTS signal ------>|               |
        |             |      channel session 1     |               |
        |             |<=(2)== redirect to B ======|               |
        | DOTS client |                            | DOTS server A |
        |             |X-(4)--- DOTS signal ------X|               |
        |             |      channel session 1     |               |
        |             |                            |               |
        +-------------+                            +---------------+
               ^
               |
              (3) DOTS signal channel
               |      session 2
               v
        +---------------+
        | DOTS server B |
        +---------------+
]]></artwork>
          </figure>
          <ol spacing="normal" type="1">
            <li>Previously established DOTS signal channel session 1 exists between a DOTS
client and DOTS server A.</li>
            <li>DOTS server A sends a server signal redirecting the client to DOTS server B.</li>
            <li>If the DOTS client does not already have a separate DOTS signal channel
session with the redirection target, the DOTS client initiates and
establishes DOTS signal channel session 2 with DOTS server B.</li>
            <li>Having redirected the DOTS client, DOTS server A ceases sending server
signals. The DOTS client likewise stops sending client signals to DOTS server
A. DOTS signal channel session 1 is terminated.</li>
          </ol>
        </section>
        <section anchor="recursive-signaling" numbered="true" toc="default">
          <name>Recursive Signaling</name>
          <t>DOTS is centered around improving the speed and efficiency of
          a coordinated response to DDoS attacks. One scenario not yet discussed
          involves coordination among federated domains operating DOTS servers
          and mitigators.</t>
          <t>In the course of normal DOTS operations, a DOTS client communicates the need for
mitigation to a DOTS server, and that server initiates mitigation on a
mitigator with which the server has an established service relationship. The
operator of the mitigator may in turn monitor mitigation performance and
capacity, as the attack being mitigated may grow in severity beyond the
mitigating domain's capabilities.</t>
          <t>The operator of the mitigator has limited options in the event a DOTS
client-requested mitigation is being overwhelmed by the severity of the attack.
Out-of-scope business or SLAs may permit the mitigating
domain to drop the mitigation and let attack traffic flow unchecked to the
target, but this only encourages attack escalation. In the case where
the mitigating domain is the upstream service provider for the attack target,
this may mean the mitigating domain and its other services and users continue to
suffer the incidental effects of the attack.</t>
          <t>A recursive signaling model as shown in <xref target="fig-recursive-signaling" format="default"/> offers
an alternative. In a variation of the use case "Upstream DDoS Mitigation by an
Upstream Internet Transit Provider" described in <xref target="I-D.ietf-dots-use-cases" format="default"/>, a
domain operating a DOTS server and mitigator also operates a DOTS client. This
DOTS client has an established DOTS session with a DOTS server belonging to a
separate administrative domain.</t>
          <t>With these preconditions in place, the operator of the mitigator being
overwhelmed or otherwise performing inadequately may request mitigation for the
attack target from this separate DOTS-aware domain. Such a request recurses the
originating mitigation request to the secondary DOTS server in the hope of
building a cumulative mitigation against the attack.</t>
          <figure anchor="fig-recursive-signaling">
            <name>Recursive Signaling</name>
            <artwork name="" type="" align="left" alt=""><![CDATA[
                     example.net domain
                     . . . . . . . . . . . . . . . . .
                     .    Gn                         .
       +----+    1   .  +----+       +-----------+   .
       | Cc |<--------->| Sn |~~~~~~~| Mitigator |   .
       +----+        .  +====+       |     Mn    |   .
                     .  | Cn |       +-----------+   .
     example.com     .  +----+                       .
        client       .    ^                          .
                     . . .|. . . . . . . . . . . . . .
                          |
                        2 |
                          |
                     . . .|. . . . . . . . . . . . . .
                     .    v                          .
                     .  +----+       +-----------+   .
                     .  | So |~~~~~~~| Mitigator |   .
                     .  +----+       |     Mo    |   .
                     .               +-----------+   .
                     .                               .
                     . . . . . . . . . . . . . . . . .
                     example.org domain
]]></artwork>
          </figure>
          <t>In <xref target="fig-recursive-signaling" format="default"/>, client Cc signals a request for mitigation
across inter-domain DOTS session 1 to the DOTS server Sn belonging to the
example.net domain. DOTS server Sn enables mitigation on mitigator Mn. DOTS
server Sn is half of DOTS gateway Gn, being deployed logically back to back with
DOTS client Cn, which has preexisting inter-domain DOTS session 2 with the DOTS
server So belonging to the example.org domain. At any point, DOTS server Sn <bcp14>MAY</bcp14>
recurse an ongoing mitigation request through DOTS client Cn to DOTS server So,
in the expectation that mitigator Mo will be activated to aid in the defense of
the attack target.</t>
          <t>Recursive signaling is opaque to the DOTS client. To maximize mitigation
visibility to the DOTS client, however, the recursing domain <bcp14>SHOULD</bcp14> provide
recursed mitigation feedback in signals reporting on mitigation status to the
DOTS client. For example, the recursing domain's DOTS server should incorporate
available metrics such as dropped packet or byte counts from the recursed
domain's DOTS server into mitigation status messages.
</t>

          <t>DOTS clients involved in recursive signaling must be able to withdraw requests
for mitigation without warning or justification per SIG-006 in <xref target="RFC8612" format="default"/>.</t>
          <t>Operators recursing mitigation requests <bcp14>MAY</bcp14>
          maintain the recursed mitigation for a brief protocol-defined
          period in the event the DOTS client originating the mitigation
          withdraws its request for help, as per the discussion of managing
          mitigation toggling in SIG-006 of <xref target="RFC8612"
          format="default"/>.</t>
          <t>Deployment of recursive signaling may result in traffic
          redirection, examination, and mitigation extending beyond the initial
          bilateral relationship between DOTS client and DOTS server. As such,
          client control over the network path of mitigated traffic may be
          reduced. DOTS client operators should be aware of any privacy
          concerns and work with DOTS server operators employing recursive
          signaling to ensure shared sensitive material is suitably
          protected. Typically, there is a contractual SLA negotiated among the DOTS client domain, the recursed domain,
          and the recursing domain to meet the privacy requirements of the
          DOTS client domain and authorization for the recursing domain to
          request mitigation for the resources controlled by the DOTS client
          domain. </t>
        </section>

        <section anchor="anycast-signaling" numbered="true" toc="default">
          <name>Anycast Signaling</name>
          <t>The DOTS architecture does not assume the availability of anycast
          within a DOTS deployment, but neither does the architecture exclude
          it. Domains operating DOTS servers <bcp14>MAY</bcp14> deploy DOTS
          servers with an anycast Service Address as described in BCP 126
          <xref target="RFC4786" format="default"/>. In such a deployment,
          DOTS clients connecting to the DOTS Service Address may be
          communicating with distinct DOTS servers, depending on the network
          configuration at the time the DOTS clients connect.  Among other
          benefits, anycast signaling potentially offers the following:</t>
          <ul spacing="normal">
            <li>Simplified DOTS client configuration, including service
            discovery through the methods described in <xref target="RFC7094"
            format="default"/>. In this scenario, the "instance discovery"
            message would be a DOTS client initiating a DOTS session to the
            DOTS server anycast Service Address, to which the DOTS server
            would reply with a redirection to the DOTS server unicast address
            the client should use for DOTS.</li>
            <li>Region- or customer-specific deployments, in which the DOTS
            Service Addresses route to distinct DOTS servers depending on the
            client region or the customer network in which a DOTS client
            resides.</li>
            <li>Operational resiliency, spreading DOTS signaling traffic
            across the DOTS server domain's networks, and thereby also
            reducing the potential attack surface, as described in BCP 126
            <xref target="RFC4786" format="default"/>.</li>
          </ul>
          <section anchor="anycast-signaling-considerations" numbered="true" toc="default">
            <name>Anycast Signaling Considerations</name>
            <t>As long as network configuration remains stable, anycast DOTS
            signaling is to the individual DOTS client indistinct from direct
            signaling. However, the operational challenges inherent in anycast
            signaling are anything but negligible, and DOTS server operators
            must carefully weigh the risks against the benefits before
            deploying.</t>
            <t>While the DOTS signal channel primarily operates over UDP per
            SIG-001 in <xref target="RFC8612" format="default"/>, the signal
            channel also requires mutual authentication between DOTS agents,
            with associated security state on both ends.</t>
            <t>Network instability is of particular concern with anycast
            signaling, as DOTS signal channels are expected to be long lived
            and potentially operating under congested network conditions
            caused by a volumetric DDoS attack.</t>
            <t>For example, a network configuration altering the route to the
            DOTS server during active anycast signaling may cause the DOTS
            client to send messages to a DOTS server other than the one with
            which it initially established a signaling session. That second
            DOTS server might not have the security state of the existing
            session, forcing the DOTS client to initialize a new DOTS session.
            This challenge might in part be mitigated by use of resumption via
            a pre-shared key (PSK) in TLS 1.3 <xref target="RFC8446"
            format="default"/> and DTLS 1.3 <xref target="I-D.ietf-tls-dtls13"
            format="default"/> (session resumption in TLS 1.2 <xref
            target="RFC5246" format="default"/> and DTLS 1.2 <xref
            target="RFC6347" format="default"/>), but keying material must
            then be available to all DOTS servers sharing the anycast Service
            Address, which has operational challenges of its own.</t>


            <t>While the DOTS client will try to establish a new DOTS session
            with the DOTS server now acting as the anycast DOTS Service
            Address, the link between DOTS client and server may be congested
            with attack traffic, making signal session establishment
            difficult. In such a scenario, anycast Service Address instability
            becomes a sort of signal session flapping, with obvious negative
            consequences for the DOTS deployment.</t>
            <t>Anycast signaling deployments similarly must also take into
            account active mitigations. Active mitigations initiated through a
            DOTS session may involve diverting traffic to a scrubbing
            center. If the DOTS session flaps due to anycast changes as
            described above, mitigation may also flap as the DOTS servers
            sharing the anycast DOTS service address toggles mitigation on
            detecting DOTS session loss, depending on whether or not the client has
            configured mitigation on loss of signal (<xref
            target="auto-mit-signal-loss" format="default"/>).</t>
          </section>
        </section>

        <section anchor="nat-signaling" numbered="true" toc="default">
          <name>Signaling Considerations for Network Address Translation</name>
          <t>Network address translators (NATs) are expected to be a common
          feature of DOTS deployments. The middlebox traversal guidelines in
          <xref target="RFC8085" format="default"/> include general NAT
          considerations that are applicable to DOTS deployments when the
          signal channel is established over UDP.</t>
          <t>Additional DOTS-specific considerations arise when NATs are part
          of the DOTS architecture. For example, DDoS attack detection behind
          a NAT will detect attacks against internal addresses. A DOTS client
          subsequently asked to request mitigation for the attacked scope of
          addresses cannot reasonably perform the task, due to the lack of
          externally routable addresses in the mitigation scope.</t>
          <t>The following considerations do not cover all possible scenarios
          but are meant rather to highlight anticipated common issues when
          signaling through NATs.</t>
          <section anchor="direct-provisioning-of-internal-to-external-address-mappings" numbered="true" toc="default">
            <name>Direct Provisioning of Internal-to-External Address Mappings</name>
            <t>Operators may circumvent the problem of translating internal
            addresses or prefixes to externally routable mitigation scopes by
            directly provisioning the mappings of external addresses to
            internal protected resources on the DOTS client. When the operator
            requests mitigation scoped for internal addresses, directly or
            through automated means, the DOTS client looks up the matching
            external addresses or prefixes and issues a mitigation request
            scoped to that externally routable information.</t>
            <t>When directly provisioning the address mappings, operators must ensure the
mappings remain up to date or they risk losing the ability to request accurate
mitigation scopes. To that aim, the DOTS client can rely on mechanisms such as
<xref target="RFC8512" format="default"/> or <xref target="RFC7658" format="default"/> to retrieve static explicit mappings. This document does not
prescribe the method by which mappings are maintained once they are provisioned
on the DOTS client.</t>
          </section>
          <section anchor="resolving-public-mitigation-scope-with-port-control-protocol-pcp" numbered="true" toc="default">
            <name>Resolving Public Mitigation Scope with Port Control Protocol (PCP)</name>
            <t>Port Control Protocol (PCP) <xref target="RFC6887" format="default"/> may be used to retrieve the external
addresses/prefixes and/or port numbers if the NAT function embeds a PCP server.</t>
            <t>A DOTS client can use the information retrieved by means of PCP to feed the DOTS
protocol(s) messages that will be sent to a DOTS server. These messages will
convey the external addresses/prefixes as set by the NAT.</t>
            <t>PCP also enables discovery and configuration of the lifetime of port mappings
instantiated in intermediate NAT devices. Discovery of port mapping lifetimes
can reduce the dependency on heartbeat messages to maintain mappings and,
therefore, reduce the load on DOTS servers and the network.</t>
          </section>
          <section anchor="resolving-public-mitigation-scope-with-session-traversal-utilities-stun" numbered="true" toc="default">
            <name>Resolving Public Mitigation Scope with Session Traversal Utilities (STUN)</name>
            <t>An internal resource, e.g., a web server, can discover its reflexive transport
address through a STUN Binding request/response transaction, as described in
<xref target="RFC8489" format="default"/>. After learning its reflexive transport address from the STUN server,
the internal resource can export its reflexive transport address and internal
transport address to the DOTS client, thereby enabling the DOTS client to
request mitigation with the correct external scope, as depicted in
<xref target="fig-nat-stun" format="default"/>. The mechanism for providing the DOTS client with the reflexive
transport address and internal transport address is unspecified in this
document.</t>
            <t>In order to prevent an attacker from modifying the STUN messages in transit, the
STUN client and server must use the message-integrity mechanism discussed in
<xref target="RFC8489" sectionFormat="of" section="9"/> or use STUN over DTLS <xref target="RFC7350" format="default"/> or STUN over TLS.
If the STUN client is behind a NAT that performs Endpoint-Dependent Mapping
<xref target="RFC5128" format="default"/>, the internal service cannot provide the DOTS client with the
reflexive transport address discovered using STUN. The behavior of a NAT between
the STUN client and the STUN server could be discovered using the experimental
techniques discussed in <xref target="RFC5780" format="default"/>, but note that there is currently no
standardized way for a STUN client to reliably determine if it is behind a NAT
that performs Endpoint-Dependent Mapping.</t>
            <figure anchor="fig-nat-stun">
              <name>Resolving Mitigation Scope with STUN</name>
              <artwork name="" type="" align="left" alt=""><![CDATA[
            Binding         Binding
+--------+  request  +---+  request  +--------+
|  STUN  |<----------| N |<----------|  STUN  |
| server |           | A |           | client |
|        |---------->| T |---------->|        |
+--------+  Binding  +---+ Binding   +--------+
            response       response    |
                                       | reflexive transport address
                                       | & internal transport address
                                       v
                                     +--------+
                                     |  DOTS  |
                                     | client |
                                     +--------+
]]></artwork>
            </figure>
          </section>
          <section anchor="resolving-requested-mitigation-scope-with-dns" numbered="true" toc="default">
            <name>Resolving Requested Mitigation Scope with DNS</name>
            <t>DOTS supports mitigation scoped to DNS names. As discussed in <xref target="RFC3235" format="default"/>,
using DNS names instead of IP addresses potentially avoids the address
translation problem, as long as the same domain name is internally and externally resolvable. 
For example, a detected attack's internal target address can be mapped to a DNS name through a reverse lookup. The DNS name
returned by the reverse lookup can then be provided to the DOTS client as the
external scope for mitigation. For the reverse DNS lookup, DNS Security
Extensions (DNSSEC) <xref target="RFC4033" format="default"/> must be used  where the authenticity of response
is critical.</t>
          </section>
        </section>
      </section>
      <section anchor="mit-request-triggers" numbered="true" toc="default">
        <name>Triggering Requests for Mitigation</name>
        <t><xref target="RFC8612" format="default"/> places no limitation on the circumstances in which a DOTS client
operator may request mitigation, nor does it demand justification for any
mitigation request, thereby reserving operational control over DDoS defense for
the domain requesting mitigation. This architecture likewise does not prescribe
the network conditions and mechanisms triggering a mitigation request from a
DOTS client.</t>

        <t>However, considering selected possible mitigation triggers from an architectural
perspective offers a model for alternative or unanticipated triggers for DOTS
deployments. In all cases, what network conditions merit a mitigation request
are at the discretion of the DOTS client operator.</t>
        <t>The mitigation request itself is defined by DOTS; however, the interfaces
required to trigger the mitigation request in the following scenarios are
implementation specific.</t>
        <section anchor="manual-mit-request" numbered="true" toc="default">
          <name>Manual Mitigation Request</name>
          <t>A DOTS client operator may manually prepare a request for mitigation, including
scope and duration, and manually instruct the DOTS client to send the mitigation
request to the DOTS server. In context, a manual request is a request directly
issued by the operator without automated decision making performed by a device
interacting with the DOTS client. Modes of manual mitigation requests include
an operator entering a command into a text interface, or directly interacting
with a graphical interface to send the request.</t>
          <t>An operator might do this, for example, in response to notice of an attack
delivered by attack detection equipment or software, and the alerting detector
lacks interfaces or is not configured to use available interfaces to translate
the alert to a mitigation request automatically.</t>
          <t>In a variation of the above scenario, the operator may have preconfigured on the
DOTS client mitigation requests for various resources in the operator's domain.
When notified of an attack, the DOTS client operator manually instructs the DOTS
client to send the relevant preconfigured mitigation request for the resources
under attack.</t>
          <t>A further variant involves recursive signaling, as described in
<xref target="recursive-signaling" format="default"/>. The DOTS client in this case is the second half of a
DOTS gateway (back-to-back DOTS server and client). As in the previous scenario,
the scope and duration of the mitigation request are preexisting but, in this
case, are derived from the mitigation request received from a downstream DOTS
client by the DOTS server. Assuming the preconditions required by
<xref target="recursive-signaling" format="default"/> are in place, the DOTS gateway operator may at any time
manually request mitigation from an upstream DOTS server, sending a mitigation
request derived from the downstream DOTS client's request.</t>
          <t>The motivations for a DOTS client operator to request mitigation manually are
not prescribed by this architecture but are expected to include some of the
following:</t>
          <ul spacing="normal">
            <li>Notice of an attack delivered via email or alternative messaging</li>
            <li>Notice of an attack delivered via phone call</li>
            <li>Notice of an attack delivered through the interface(s) of networking
monitoring software deployed in the operator's domain</li>
            <li>Manual monitoring of network behavior through network monitoring software</li>
          </ul>
        </section>
        <section anchor="auto-conditional-mit" numbered="true" toc="default">
          <name>Automated Conditional Mitigation Request</name>
          <t>Unlike manual mitigation requests, which depend entirely on the DOTS client
operator's capacity to react with speed and accuracy to every detected or
detectable attack, mitigation requests triggered by detected attack conditions
reduce the operational burden on the DOTS client operator and minimize the
latency between attack detection and the start of mitigation.</t>
          <t>Mitigation requests are triggered in this scenario by operator-specified network
conditions. Attack detection is deployment specific and not constrained by this
architecture. Similarly, the specifics of a condition are left to the discretion
of the operator, though common conditions meriting mitigation include the
following:</t>
          <ul spacing="normal">
            <li>Detected attack exceeding a rate in packets per second (pps).</li>
            <li>Detected attack exceeding a rate in bytes per second (bps).</li>
            <li>Detected resource exhaustion in an attack target.</li>
            <li>Detected resource exhaustion in the local domain's mitigator.</li>
            <li>Number of open connections to an attack target.</li>
            <li>Number of attack sources in a given attack.</li>
            <li>Number of active attacks against targets in the operator's domain.</li>
            <li>Conditional detection developed through arbitrary statistical analysis or deep
learning techniques.</li>
            <li>Any combination of the above.</li>
          </ul>
          <t>When automated conditional mitigation requests are enabled, violations of any of
the above conditions, or any additional operator-defined conditions, will
trigger a mitigation request from the DOTS client to the DOTS server. The
interfaces between the application detecting the condition violation and the
DOTS client are implementation specific.</t>
        </section>
        <section anchor="auto-mit-signal-loss" numbered="true" toc="default">
          <name>Automated Mitigation on Loss of Signal</name>
          <t>To maintain a DOTS signal channel session, the DOTS client and the DOTS server
exchange regular but infrequent messages across the signal channel. In the
absence of an attack, the probability of message loss in the signaling channel
should be extremely low. Under attack conditions, however, some signal loss may
be anticipated as attack traffic congests the link, depending on the attack
type.</t>
          <t>While <xref target="RFC8612" format="default"/> specifies the DOTS protocol be robust when signaling under
attack conditions, there are nevertheless scenarios in which the DOTS signal is
lost in spite of protocol best efforts. To handle such scenarios, a DOTS
operator may request one or more mitigations, which are triggered only when the
DOTS server ceases receiving DOTS client heartbeats beyond the miss count or
interval permitted by the protocol.</t>
          <t>The impact of mitigating due to loss of signal in either direction must be
considered carefully before enabling it. Attack traffic congesting links is not 
the only reason why signal could be lost, and as such, mitigation requests triggered
by signal channel degradation in either direction may incur unnecessary costs due to scrubbing traffic,
adversely impact network performance and operational expense alike.</t>
        </section>
      </section>
    </section>
    <section anchor="iana-considerations" numbered="true" toc="default">
      <name>IANA Considerations</name>
      <t>This document has no IANA actions.</t>
    </section>
    <section anchor="security-considerations" numbered="true" toc="default">
      <name>Security Considerations</name>
      <t>This section describes identified security considerations for the
      DOTS architecture.</t>
      <t>Security considerations and security requirements discussed in <xref target="RFC8612" format="default"/> need to
be taken into account.</t>
      <t>DOTS is at risk from three primary attack vectors: agent
      impersonation, traffic injection, and signal blocking.  These vectors
      may be exploited individually or in concert by an attacker to confuse,
      disable, take information from, or otherwise inhibit DOTS agents.</t>
      <t>Any attacker with the ability to impersonate a legitimate DOTS client
      or server or, indeed, inject false messages into the stream may
      potentially trigger/withdraw traffic redirection, trigger/cancel
      mitigation activities or subvert drop-/accept-lists.  From an
      architectural standpoint, operators <bcp14>MUST</bcp14> ensure
      conformance to the security requirements defined in <xref
      target="RFC8612" sectionFormat="of" section="2.4"/> to secure data in
      transit. Similarly, as the received data may contain network topology,
      telemetry, and threat and mitigation information that could be considered
      sensitive in certain environments, it <bcp14>SHOULD</bcp14> be protected
      at rest per required local policy. </t>
      <t>DOTS agents <bcp14>MUST</bcp14> perform mutual authentication to
      ensure authenticity of each other, and DOTS servers <bcp14>MUST</bcp14>
      verify that the requesting DOTS client is authorized to request
      mitigation for specific target resources (see <xref target="dots-server"
      format="default"/>).</t>
      <t>A man-in-the-middle (MITM) attacker can intercept and drop packets,
      preventing the DOTS peers from receiving some or all of the DOTS
      messages; automated mitigation on loss of signal can be used as a
      countermeasure but with risks discussed in <xref
      target="auto-mit-signal-loss" format="default"/>.</t>
      <t>An attacker with control of a DOTS client may negatively influence
      network traffic by requesting and withdrawing requests for mitigation
      for particular prefixes, leading to route or DNS flapping. DOTS
      operators should carefully monitor and audit DOTS clients to detect
      misbehavior and deter misuse.
</t>
      <t>Any attack targeting the availability of DOTS servers may disrupt the
      ability of the system to receive and process DOTS signals resulting in
      failure to fulfill a mitigation request.  DOTS servers
      <bcp14>MUST</bcp14> be given adequate protections in accordance with
      best current practices for network and host security.</t>
    </section>


  </middle>
  <back>

<displayreference target="I-D.ietf-dots-use-cases" to="DOTS-USE-CASES"/>
<displayreference target="I-D.ietf-tls-dtls13" to="DTLS-PROTOCOL"/>


    <references>
      <name>References</name>
      <references>
        <name>Normative References</name>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.2119.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8174.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8612.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.4786.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.6887.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.4033.xml"/>
      </references>
      <references>
        <name>Informative References</name>

        <xi:include href="https://xml2rfc.tools.ietf.org/public/rfc/bibxml3/reference.I-D.ietf-dots-use-cases.xml"/>

        <xi:include href="https://xml2rfc.tools.ietf.org/public/rfc/bibxml3/reference.I-D.ietf-tls-dtls13.xml"/>

        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8782.xml"/>

        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8783.xml"/>

        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8738.xml"/>

        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8489.xml"/>

        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.7350.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8555.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.0768.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.0793.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.1035.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.2782.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.3235.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.3261.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.4271.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.4732.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.5128.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.5246.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.5780.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.6347.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.6763.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.7092.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.7094.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8085.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8446.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8512.xml"/>
        <xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.7658.xml"/>
      </references>
    </references>

    <section anchor="acknowledgments" numbered="false" toc="default">
      <name>Acknowledgments</name>
      <t>Thanks to <contact fullname="Matt Richardson"/>, <contact
      fullname="Roman Danyliw"/>, <contact fullname="Frank Xialiang"/>,
      <contact fullname="Roland Dobbins"/>, <contact fullname="Wei Pan"/>,
      <contact fullname="Kaname Nishizuka"/>, <contact fullname="Jon Shallow"/>,
      <contact fullname="Paul Kyzivat"/>, <contact fullname="Warren Kumari"/>,
      <contact fullname="Benjamin Kaduk"/>, and <contact fullname="Mohamed Boucadair"/> for
      their comments and suggestions.</t>
      <t>Special thanks to <contact fullname="Roman Danyliw"/> for the AD review. </t>
    </section>

    <section anchor="contributors" numbered="false" toc="default">
      <name>Contributors</name>

<ul empty="true"  spacing="compact">
<li ><t><contact fullname="Mohamed Boucadair"/></t>
</li>
<li>
<ul empty="true"  spacing="compact">
<li>Orange
</li>
<li>mohamed.boucadair@orange.com
</li>
</ul>
</li>
</ul>


<ul empty="true"  spacing="compact">
<li><t><contact fullname="Cristopher Gray"/></t>
</li>
<li>
<ul empty="true" spacing="compact">

<li>Christopher_Gray3@cable.comcast.com  
</li>
</ul>

</li>
</ul>



    </section>
  </back>

</rfc>
