Subject: [midcom] Interim rev. of the famework draft

From: Pyda Srisuresh <[email-masked]>
Date: Sun, 5 Aug 2001 03:58:07 -0700 (PDT)

Folks,

Please find attached the interim rev. framework draft.
You may use this as reference during the editorial meeting. 
Thanks.

regards,
suresh

__________________________________________________
Do You Yahoo!?
Make international calls for as low as $.04/minute with Yahoo! Messenger
http://phonecard.yahoo.com/

Network Working Group                                       P. Srisuresh
INTERNET-DRAFT                              	         Kuokoa Networks
Expires as of February 9, 2002                                 J. Kuthan
                                                               GMD Fokus
                                                            J. Rosenberg
                                                             Dynamicsoft
                                                              A. Molitor
                                                     Aravox Technologies
                                                               A. Rayhan
                                                              Consultant
                                                            August, 2001

          Middlebox Communication Architecture and framework
                <draft-ietf-midcom-framework-04-interim.txt>

Status of this Memo

   This document is an Internet-Draft and is in full conformance with
   all provisions of Section 10 of RFC2026.

   Internet-Drafts are working documents of the Internet Engineering
   Task Force (IETF), its areas, and its working groups.  Note that
   other groups may also distribute working documents as Internet-
   Drafts.

   Internet-Drafts are draft documents valid for a maximum of six 
   months and may be updated, replaced, or obsoleted by other documents 
   at any time.  It is inappropriate to use Internet- Drafts as 
   reference material or to cite them other than as "work in progress."

   The list of current Internet-Drafts can be accessed at
   http://www.ietf.org/ietf/1id-abstracts.txt

   The list of Internet-Draft Shadow Directories can be accessed at
   http://www.ietf.org/shadow.html.

Abstract

   There are a variety of intermediate devices in the Internet today
   that require application intelligence for their operation. 
   Datagrams pertaining to real-time streaming applications such
   as SIP and H.323 and peer-to-peer applications such as Napster 
   and NetMeeting cannot be identified by merely examining packet
   headers. Middleboxes implementing Firewall and Network Address 
   Translator services typically embed application intelligence 

Srisuresh et al.                                                [Page 1]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   within the device for their operation. The document specifies an 
   architecture and framework in which trusted third parties can 
   be delegated to assist the middleboxes to perform their operation
   without resorting to embedding application intelligence. Doing 
   this will allow a middlebox to continue to provide the services,
   while keeping the middlebox application agnostic. A principal 
   objective of this document is to decribe the underlying framework
   of middlebox communication to enable complex applications 
   through the middleboxes seamlessly using a trusted third party.

1. Introduction

   Intermediate devices requiring application intelligence are the
   subject of this document. These devices are referred as 
   middleboxes throughout the document. Many of these devices enforce
   application specific policy based functions such as packet 
   filtering, VPN (Virtual Private Network) tunneling, Intrusion
   detection, security and so forth. Network Address Translator
   service, on the other hand, provides routing transparency across
   address realms (within IPv4 routing network or across V4 and V6
   routing realms), independent of applications. Application Level
   Gateways (ALGs) are used in conjunction with NAT to examine and
   optionally modify application payload so the end-to-end application
   behaviour remains unchanged for many of the applications traversing
   NAT middleboxes. There may be other types of services requiring
   embedding application intelligence in middleboxes for their
   operation. The discussion scope of this document is however limited
   to Firewall and NAT services. Nonetheless, the middlebox framework
   is designed to be extensible to support the deployment of new
   services.

   Tight coupling of application intelligence with middleboxes makes 
   maintenance of middleboxes hard with the advent of new applications.
   Built-in application awareness typically requires updates of 
   operating systems with new applications or newer versions of 
   existing applications. Operators requiring support for newer 
   applications will not be able to use third party software/hardware
   specific to the application and are at the mercy of their
   middlebox vendor to make the necessary upgrade. Further, embedding
   intelligence for a large number of application protocols within 
   the same middlebox increases complexity of the middlebox and is
   likely to be error prone and degrade in performance.

   This document describes a framework in which application 
   intelligence can be moved from middleboxes into external MIDCOM
   agents. The premise of the framework is to devise a MIDCOM
   protocol that is application independent, so the middleboxes 

Srisuresh et al.                                                [Page 2]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   can stay focused on services such as firewall, NAT and other 
   functions, as required. MIDCOM agents with application intelligence
   can, in turn, assist the middleboxes through the MIDCOM protocol in
   permitting applications such as FTP, SIP and H.323. The
   communication between a MIDCOM agent and a middlebox will not be
   noticeable to the end-hosts that take part in the application,
   unless one of the end-hosts assumes the role of a MIDCOM agent.
   Discovery of middleboxes or MIDCOM agents in the path of an
   application instance is outside the scope of this document. Further,
   any communication amongst middleboxes is also outside the scope of
   this document.
  
   This document describes the framework in which middlebox 
   communication takes place and the various elements that constitute
   the framework. Section 2 describes the terms used in the document.
   Section 3 defines the architectural framework of a middlebox for
   communication with MIDCOM agents. The remaining sections cover the
   components of the framework, illustration using sample flows and
   operational considerations with the MIDCOM architecture. Section 4
   describes the nature of MIDCOM protocol. Section 5 identifies
   entities that could potentially host the MIDCOM agent function. 
   Section 6 considers the role of Policy server and its function
   with regard to communicating MIDCOM agent authorization policies.
   Sections 7 is an illustration of SIP flows using MIDCOM framework
   in which the MIDCOM agent is co-resident on a SIP proxy server. 
   Section 8 addresses operational considerations in deploying a 
   protocol adhering to the framework described here. Section 9 is
   an applicability statement, scoping the location of middleboxes. 
   Section 11 outlines security considerations for the middlebox
   in view of the MIDCOM framework. 

2. Terminology
   
   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALLNOT",
   "SHOULD", "SHOULD NOT", "RECOMMENDED",  "MAY", and "OPTIONAL" in
   this document are to be interpreted as described in RFC 2119.
   Below are the definitions for the terms used throughout the 
   document.
   
2.1. MiddleBox function/service

   A middlebox function or a middlebox service is an operation or
   method performed by a network intermediary that may require
   application specific intelligence for its operation. Policy based
   packet filtering (a.k.a. firewall), Network address translation
   (NAT), Intrusion detection, Load balancing, Policy based tunneling
   and IPsec security are all examples of a middlebox function (or 

Srisuresh et al.                                                [Page 3]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   service).
     
2.2. MiddleBox 

   Middlebox is a network intermediate device that implements one or
   more of the middlebox services. A NAT middlebox is a middlebox 
   implementing NAT service. A firewall middlebox is a middlebox
   implementing firewall service.
     
2.3. Firewall
     
   Firewall is a policy based packet filtering Middlebox function, 
   typically used for restricting access to/from specific devices and 
   applications. The policies are often termed Access Control 
   Lists (ACLs).
     
2.4. NAT

   Network Address Translation is a method by which IP addresses are
   mapped from one address realm to another, providing transparent
   routing to end-hosts. Transparent routing here refers to modifying
   end-node addresses en-route and maintaining state for these updates
   so that when a datagram leaves one realm and enters another,
   datagrams pertaining to a session are forwarded to the right 
   end-host in either realm. Refer [NAT-TERM] for the definition of
   Transparent routing, various NAT types and the associated terms
   in use. Two types of NAT are most common. Basic-NAT, where only an
   IP address (and the related IP, TCP/UDP checksums) of packets is
   altered and NAPT (Network Address Port Translation), where both an
   IP address and a transport layer identifier such as a TCP/UDP port 
   (and the related IP, TCP/UDP checksums) are  altered. 
   
   The term NAT in this document is very similar to the IPv4 NAT
   described in [NAT-TERM], but is extended beyond IPv4 networks
   to include the IPv4-v6 NAT-PT described in [NAT-PT]. While the
   IPv4 NAT [NAT-TERM] translates one IPv4 address into another IPv4 
   address to  provide routing between private V4 and external V4 
   address realms, IPv4-v6 NAT-PT [NAT-PT] translates an IPv4 address 
   into an IPv6 address and vice versa to provide routing between a 
   V6 address realm and an external V4 address realm.

   Unless specified otherwise, NAT in this document is a middlebox 
   function referring to both IPv4 NAT as well as IPv4-v6 NAT-PT.

2.5. Proxy

   A proxy is an intermediate relay agent between clients and servers 
   of an application, relaying application messages between the two. 

Srisuresh et al.                                                [Page 4]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   Proxies use special protocol mechanisms to communicate with proxy 
   clients and relay client data to servers and vice versa. A Proxy 
   terminates sessions with both the client and the server, acting as
   server to the end-host client and as client to the end-host server. 

   Applications such as FTP, SIP and RTSP use a control connection to
   establish data sessions. These control and data sessions can take
   divergent paths. While a proxy can intercept both the control and
   data connections, it might intercept only the control connection.
   This is often the case with real-time streaming applications such
   as SIP and RTSP. 

2.6. ALG

   Application Level Gateways (ALGs) are agents that possess the 
   application specific intelligence and knowledge of an associated
   middlebox function. An ALG examines application traffic in transit 
   and assists middlebox in carrying out its function.
 
   An ALG may be co-resident with a middlebox or reside externally, 
   communicating through a middlebox communication protocol. It 
   interacts with a middlebox to set up state, access control 
   filters, use middlebox state information, modify application 
   specific payload or perform whatever else is necessary to enable
   the application to run through the middlebox.

   ALGs are different from proxies. ALGs are not visible to 
   end-hosts, unlike the proxies which are relay agents terminating
   sessions with both end-hosts. ALGs do not terminate session with
   either end-host. Instead, ALGs examine and optionally modify
   application payload content to facilitate the flow of application
   traffic through a middlebox. ALGs are middlebox centric, in that
   they assist the middleboxes in carrying out their function. 
   Whereas, the proxies act as focal point for application servers, 
   relaying traffic between application clients and servers.

   ALGs are similar to Proxies, in that, both ALGs and proxies 
   facilitate Application specific communication between clients
   and servers. 

2.7. End-Hosts

   End-hosts are entities that are party to a networked application
   instance. End-hosts referred in this document are specifically 
   those terminating Real-time streaming Voice-over-IP 
   applications such as SIP and H.323 and peer-to-peer applications 
   such as Napster and NetMeeting. 

Srisuresh et al.                                                [Page 5]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

2.8. MIDCOM Agents

   MIDCOM agents are entities performing ALG function, logically 
   external to a middlebox. MIDCOM agents possess a combination of 
   application awareness and knowledge of the middlebox function.
   A MIDCOM agent may communicate with one or more middleboxes.
   
   Only the MIDCOM agents, located in-Path of an application 
   instance will be considered in this document. These are also
   refered as "In-Path MIDCOM agents". In-Path Midcom agents are 
   entities in which the MIDCOM agent function is co-resident on
   devices that are naturally within the message path of the
   application they are associated with. This may be an application
   proxy, gateway, or in the extreme case, one of the end-hosts, 
   that is party to the application. 

   Agents not resident on entities that are natively in the path of
   application flows, refered as Out-of-Path (OOP) agents, will be 
   considered out of scope for this document. As such, there will
   be no further discussion on OOP agents in the reminder of this 
   document.

2.9. Policy Server

   Policy Server is a management entity that acts in advisory
   capacity and interfaces with a middlebox to communicate policies
   concerning authorization of MIDCOM agents gaining access to
   middlebox resources. A MIDCOM agent may be pre-configured on a
   middlebox. In case a MIDCOM agent is not pre-configured, the
   middlebox will consult the Policy Server and obtain the agent
   profile to validate connection setup and authorization of the
   agent to gain access to middlebox resources. A middlebox and
   a policy server may communicate further if the policy server's
   policy  changes or if a middlebox needs further information.
   The policy server may at anytime notify the middlebox to
   terminate authorization for an agent.

   The protocol facilitating the communication between a middlebox
   and Policy Server need not be part of MIDCOM protocol. Section 6
   in the document addresses the Policy server interface and protocol
   framework independent of the MIDCOM framework.

   Application specific policy data and policy interface between an
   agent or application endpoint and a policy server is out of bounds
   for this document. The Policy server issues addressed in the
   document are focused at an aggregate domain level as befitting
   the middlebox. For example, a SIP midcom agent may choose to query
   a policy server for the administrative (or corporate) domain to

Srisuresh et al.                                                [Page 6]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   find whether a certain user is allowed to make an outgoing call.
   This type of application specific policy data, as befitting an end
   user is out of bounds for the Policy server considered in this
   document. It is within bounds however for the middlebox policy
   server to specify the specific end-user applications (or tuples)
   for which an agent is permitted to be an ALG.

2.10. Middlebox Communication (MIDCOM) protocol

   The protocol between a MIDCOM agent and a middlebox that allows
   the MIDCOM agent to gain access to middlebox resources and
   allows the middlebox to delegate application specific processing
   to MIDCOM agent. The MIDCOM protocol allows the middlebox to
   perform its operation with the aid of MIDCOM agents, without 
   resorting to embedding application intelligence. The principal 
   motivation behind architecting this protocol is to enable complex
   applications through middleboxes seamlessly using a trusted third
   party, i.e., a MIDCOM agent.

   This is a protocol yet to be devised. 

3.0 Architectural framework for Middleboxes

   A middlebox may implement one or more of the middlebox functions   
   selectively on multiple interfaces of the device. There can be a 
   variety of MIDCOM agents interfacing with the middlebox to
   communicate with one or more of the middlebox functions on an 
   interface. As such, the Middlebox communication protocol MUST 
   allow for selective communication between a specific MIDCOM agent
   and one or more middlebox functions on the interface. The following 
   diagram identifies a possible layering of the service supported
   by a middlebox and a list of MIDCOM agents that might interact
   with it. 

Srisuresh et al.                                                [Page 7]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

             +---------------+  +--------------+  
             | MIDCOM agent  |  | MIDCOM agent | 
             | co-resident on|  | co-resident  |  
             | Proxy Server  |  | on Appl. GW  | 
             +---------------+  +--------------+  
                        ^           ^             
                        |           |                     +--------+
               MIDCOM   |           |                     | Policy |
               Protocol |           |                   +-| Server |
                        |           |                  /  +--------+
   +-------------+      |           |                 /  
   | MIDCOM agent|      |           |                /    
   | co-resident |      |           |               /  
   | on End-hosts|<-+   |           |              / 
   +-------------+  |   |           |              |  
                    v   v           v              v 
              +-------------------------------------------+
              |  Middlebox Communication      |Policy     |
              |  Protocol (MIDCOM) Interface  |Interface  |
              +----------+--------+-----------+-----------+
   Middlebox  |          |        |           |           |
   Functions  | Firewall |  NAT   |   VPN     | Intrusion |
              |          |        | tunneling | Detection |
              +----------+--------+-----------+-----------+
   Middlebox  | Firewall ACLs, Session-descriptors,       |
   Managed    | NAT-BINDs, NAT Address-Maps and other     | 
   Resources  | Middlebox function specific attributes    |
              +-------------------------------------------+

     Figure 1: MIDCOM agents interfacing with a middlebox       

   Firewall ACLs, NAT-BINDs, NAT address-maps and Session-state
   are a few of the middlebox managed resources. A session may
   be uniquely described by the tuple of (SessionDirection,
   SourceAddress, DestinationAddress, Protocol, SourcePort,
   DestinationPort). All parameters of the tuple, including
   SessionDirection, are with reference to an interface on the
   middlebox. An aggregated Session-state may have one or
   more of the tuple elements denoted by a regular expression
   (ex: Any source port). A session state will include attributes
   specific to the individual middlebox function, in addition to 
   the session identifying tuple. The service specific attributes
   include a variety of timers, NAT translation parameters and 
   so forth. As Session-state may be shared across middlebox
   functions, a Session-state may be created by a function, and
   terminated by a different function. For example, a
   session-state may be created by the firewall function, but

Srisuresh et al.                                                [Page 8]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   terminated by the NAT function, when a session timer expires. 
      
   A middlebox may also have function specific resources such as 
   Address maps and Address binds to enforce NAT function and 
   application based policies to enforce firewall function.
   Application specific MIDCOM agents (co-resident on the middlebox
   or external to the middlebox) would examine the IP datagrams and
   help identify the application the datagram belongs to and assist
   the middlebox in performing functions unique to the application
   and the middlebox service. For example, a MIDCOM agent assisting
   a NAT middlebox might perform payload translations; whereas a 
   MIDCOM agent assisting a firewall middlebox might request the
   firewall to permit access to application specific dynamically
   generated session traffic. 

4. MIDCOM Protocol

   The MIDCOM protocol between a MIDCOM agent and a middlebox allows
   the MIDCOM agent to gain access to middlebox resources and
   allows the middlebox to delegate application specific processing
   to MIDCOM agent. The protocol will allow MIDCOM agents to signal
   the middleboxes to let complex applications using dynamic port 
   based sessions through them (i.e., middleboxes) seamlessly. 
   
   It is important to note that an agent and a middlebox can be on
   the same physical device. In such a case, they may communicate
   using a MIDCOM protocol message formats, but using a non-IP based
   transport such as IPC messaging (or) they may communicate using a 
   well-defined API/DLL (or) the application intelligence is fully
   embedded into the middlebox service (as it is done today in many
   stateful inspection firewall devices and NAT devices). 

   The MIDCOM protocol will consist of a connection setup phase, 
   run-time connection phase and a connection termination phase. 

   Connection setup must be preceded by registration of the
   MIDCOM agent with either the middlebox or the Policy Server.
   The MIDCOM agent access and authorization profile may either
   be pre-configured on the middlebox (or) listed on a Policy
   Server the middlebox is configured to consult. MIDCOM is a
   peer-to-peer protocol. As such, either the agent or the
   middlebox may choose to initiate the connection.  

   A MIDCOM session may be terminated by either of the parties.
   A MIDCOM session termination may also be triggered by one of 
   (a) the middlebox or the agent going out of service and not
   being available for further MIDCOM operations, or (b) policy

Srisuresh et al.                                                [Page 9]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   server notifying the middlebox that a particular MIDCOM agent
   is no longer authorized.

   The MIDCOM protocol data exchanged during run-time is governed 
   principally by the middlebox services the protocol supports.
   Firewall and NAT middlebox services are considered in this
   document. Nonetheless, the MIDCOM framework is designed to
   be extensible to support deployment of other services as well.

5.0. MIDCOM Agents

   MIDCOM agents are logical entities which may reside physically
   on nodes external to a middlebox, possessing a combination of 
   application awareness and knowledge of middlebox function. A 
   MIDCOM agent may communicate with one or more middleboxes. The
   issues of middleboxes discovering agents or vice versa are
   outside the scope of this document. The focus of the document
   is the framework in which a MIDCOM agent communicates with a
   middlebox using MIDCOM protocol, which is yet to be devised.
   Specifically, the focus is restricted to just the In-Path agents.

   In-Path MIDCOM agents are MIDCOM agents that are located naturally
   within the message path of the application(s) they are associated
   with. Bundled session applications such as H.323, SIP and RTSP
   which have separate control and data sessions may have their 
   sessions take divergent paths. In those scenarios, In-Path MIDCOM
   agents are those that find themselves in the control path. 
   In majority of cases, a middlebox will likely require the 
   assistance of a single agent for an application in the control 
   path alone. However, it is possible that a middlebox function
   or a specific application traversing the middlebox might require
   the intervention of more than a single MIDCOM agent for the same
   application, one for each sub-session of the application.

   Application Proxies and gateways are a good choice for In-Path 
   MIDCOM agents, as these entities, by definition, are in the path
   of an application between a client and server. In addition to
   hosting the MIDCOM agent function, these natively in-path 
   application specific entities may also enforce 
   application-specific choices locally, such as dropping messages
   infected with known viruses, or lacking user authentication.
   These entities can be interjecting both the control and data
   connections. For example, FTP control and Data sessions are
   interjected by an FTP proxy server. However, proxies may also be
   interjecting just the control connection and not the data
   connections, as is the case with real-time streaming applications
   such as SIP and RTSP. Note, applications may not always traverse

Srisuresh et al.                                               [Page 10]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   a proxy and some applications may not have a proxy server
   available. 

   SIP proxies and H.323 gatekeepers may be used to host MIDCOM
   agent function to control middleboxes implementing firewall and
   NAT functions. The advantage of using in-path entities as opposed
   to creating an entirely new agent is that the in-path entities
   already possess application intelligence. You will need to merely
   enable the use of MIDCOM protocol to be an effective MIDCOM
   agent. Figure 2 below illustrates a scenario where the in-path 
   MIDCOM agents interface with the middlebox. Let us say, the 
   policy Server has pre-configured the in-path proxies as trusted
   MIDCOM agents on the middlebox and the packet filter 
   implements 'default-deny' packet filtering policy. Proxies use 
   their application-awareness knowledge to control the firewall 
   function and selectively permit a certain number of voice stream
   sessions dynamically using MIDCOM protocol. 

   In the illustration below, the proxies and the policy server are
   shown inside a private domain. The intent however is not to imply
   that they be inside the private boundary alone. The proxies may
   also reside external to the domain. The only requirement is that
   there be a trust relationship with the middlebox.

Srisuresh et al.                                               [Page 11]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

                           +-----------+
                           | Middlebox |
                           | Policy    |
                           | Server    |~~~~~~~~~~~~~|
                           +-----------+              \
                                                       \
                    +--------+                          \        
                    | SIP    |___                        \    
            ________| Proxy  |   \            Middlebox   \
           /        +--------+..  |        +--------------------+
          |                    :  | MIDCOM |           |        |
          |  RTSP +---------+  :..|........| MIDCOM    | POLICY |
      SIP |   ____|  RTSP   |.....|........| PROTOCOL  | INTER- |
          |  /    |  Proxy  |___  |        | INTERFACE | FACE   |
          | |     +---------+   \  \       |--------------------|
          | |                     \  \-----|                    |
          | |                      \-------|                    |
          | |                           ---|     FIREWALL       |-->--
         +-----------+                 /---|                    |--<--
        +-----------+|  Data streams  //   +--------------------+
       +-----------+||---------->----//            |
       |end-hosts  ||-----------<-----             .
       +-----------+   (RTP, RTSP data, etc.)      |  
                                                   .  Outside the
              Within a private domain              |  private domain
                                                   
       Legend: ---- Application data path datagrams
               ____ Application control path datagrams
               .... Middlebox Communication Protocol (MIDCOM)
               ~~~~ MIDCOM Policy Server Interface
                 |
                 .  private domain Boundary
                 |

       Figure 2: In-Path MIDCOM Agents for Middlebox Communication

5.1. End-hosts as In-Path MIDCOM agents

   End-hosts are another variation of In-Path MIDCOM agents. Unlike 
   Proxies, End-hosts are direct party to the application and 
   possess all the end-to-end application intelligence there is to
   it. End-hosts presumably terminate both the control and data
   paths of an application. Unlike other entities hosting MIDCOM
   agents, end-host is able to process secure datagrams. However,
   the problem would be one of manageability - upgrading all the

Srisuresh et al.                                               [Page 12]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   end-hosts running a specific application.

6.0. Policy Server functions

   The functional decomposition of the MIDCOM architecture assumes
   the existence of a logical entity known as Policy Server, 
   responsible for performing authorization and related provisioning
   services for the middlebox as depicted in figure 1. The Policy
   server is a logical entity which may reside physically on a
   middlebox or on a node external to the middlebox. The protocol
   employed for communication between the middlebox and the policy
   server is unrelated to the MIDCOM protocol.

   Agents are registered with a Policy Server for authorization to
   gain access to a middlebox. The policy server maintains a list of
   agents that are authorized to connect to each of the middleboxes the
   policy server supports. The Policy server is not intended to assist
   middlebox in the implementation of the services it provides or
   with resource authorization on the middlebox.

   The policy server acts in an advisory capacity to a middlebox to
   authorize or terminate authorization for an agent to gain 
   connectivity to the middlebox. The primary objective of a policy
   server is to communicate agent authorization information so as to
   ensure that the security and integrity of a middlebox is not
   jeopardized. Specifically, the policy server should associate a
   trust level with each agent attempting to connect to a middlebox
   and provide a security profile. The policy server should be capable
   of addressing cases when end-hosts are agents to the middlebox.

6.1. Authentication, Integrity and Confidentiality

   Host authenticity and individual message security are two distinct
   types of security considerations. Host authentication refers to
   credentials required of a MIDCOM agent to authenticate itself to
   the middlebox and vice versa. When authentication fails, the
   middlebox MUST not process signaling requests received from the
   agent that failed authentication. Two-way authentication should be
   supported. In some cases, the 2-way authentication may be tightly
   linked to the establishment of keys to protect subsequent traffic. 
   Two-way authentication is often required to prevent various active
   attacks on the MIDCOM protocol and secure establishment of keying
   material.

   Security services such as authentication, data integrity,
   confidentiality and replay protection may be adapted to secure
   MIDCOM messages in an untrusted domain. Message authentication is

Srisuresh et al.                                               [Page 13]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   same as data origin authentication and is an affirmation that the
   sender of the message is who it claims to be. Data integrity
   refers to the ability to ensure that a message has not been
   accidentally, maliciously or otherwise altered or destroyed.
   Confidentiality is encryption of message with a key so that only
   those in possession of the key can decipher the message content.
   Lastly, replay protection is a form of sequence integrity so when
   an intruder plays back a previously recorded sequence of messages,
   the receiver of the replay messages will simply drop the replay
   messages into bit-bucket. Certain applications of the MIDCOM
   protocol might require support for non-repudiation as an option of
   the data integrity service. Typically, support for non-repudiation
   is required for billing, service level agreements, payment orders,
   and receipts for delivery of service. 
   
   IPsec AH ([IPSEC-AH]) offers data-origin authentication, data 
   integrity and protection from message replay. IPsec ESP 
   ([IPSEC-ESP]) provides data-origin authentication to a lesser
   degree (same as IPsec AH if the MIDCOM transport protocol turns out
   to be TCP or UDP), message confidentiality, data integrity and
   protection from replay. Besides the IPsec based protocols, there
   are other security options as well. TLS based transport layer
   security is one option. There are also many application-layer 
   security mechanisms available. Simple Source-address based
   security is a minimal form of security and should be relied on only
   in the most trusted environments where those hosts will not be
   spoofed.

   MIDCOM message security shall use existing standards, whenever the
   existing standards satisfy the requirements. Security shall be
   specified to minimize the impact on connections that do not use the
   security option. Security should be designed to avoid introducing
   and to minimize the impact of denial of service attacks. Some
   security mechanisms and algorithms require substantial processing
   or storage, in which case the security protocols should protect
   themselves as well as against possible flooding attacks that
   overwhelm the endpoint (i.e., the middlebox or the agent) with
   such processing. For connection oriented protocols (such as TCP)
   using security services, the security protocol should detect
   premature closure or truncation attacks.

6.2. Registration and deregistration of MIDCOM agents

   Prior to giving MIDCOM agents access to the middlebox resources,
   a registration process MUST take place. Registration is a
   different process than establishing a transport connection.
   The former requires exchanging agent profile information with

Srisuresh et al.                                               [Page 14]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   the middlebox or a policy server(s). Agent registration is often
   a manual operation performed by an opertor rather than the agent
   itself. The latter refers to establishing a MIDCOM transport
   connection and exchanging security credentials between an agent
   and a middlebox. The latter uses the information from the former
   for connection establishment.

   Profile of a MIDCOM agent includes agent authorization policy (i.e, 
   session tuples for which the agent is authorized to act as ALG),
   agent-hosting-entity (e.g., Proxy, Gateway or end-host which hosts
   the agent), agent accessibility profile (including any host level
   authentication information) and security profile (i.e., security
   requirements for messages exchanged between the middlebox and the
   agent). 

   MIDCOM agent profile may be pre-configured on the middlebox while
   provisioning the middlebox function. Either the agent or the
   middlebox can choose to initiate a connection prior to any data
   traffic. Alternately, either party (middlebox or the MIDCOM agent)
   may choose to initiate a connection only upon noticing the
   application specific traffic. 

   Coupling MIDCOM agents with the middlebox resources requires
   a means of reflecting that into the resource description table
   of the middlebox. In the case of a firewall, for example, the 
   ACL tuple may be altered to reflect the optional ALG presence.
   The revised ACL may look something like the following.   

   (<Session-Direction>, <Source-Address>, <Destination-Address>, 
   <IP-Protocol>, <Source-Port>, <Destination-Port>, <ALG>)
    
   The reader should note that this is an illustrative example and
   not necessarily the actual definition of an ACL tuple. The formal
   description of the ACL is yet to be devised. Agent accessibility
   information should also be provisioned. For a  MIDCOM agent,
   accessibility information includes the IP address, trust level,
   host authentication parameters and message authentication
   parameters. Once a connection is established between a middlebox
   and a MIDCOM agent, that connection should be usable with multiple
   instances of the application(s), as appropriate. Note, all of this
   could be captured in an agent profile for ease of management.

   The technique described above is necessary for the pre-registration
   of MIDCOM agents with the middlebox. However, it is possible to
   retain the provisioning on middlebox unchanged, by requiring MIDCOM
   agents to initiate the connection to middlebox. In such a case, the
   agent should initiate the connection prior to the start of the
   application.  If the agent connection is delayed until after the

Srisuresh et al.                                               [Page 15]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   application has started, the agent might be unable to process the
   control stream to permit the data connections. When Middlebox notices
   an incoming MIDCOM connection, and the middlebox has no prior profile
   of the MIDCOM agent, the middlebox will consult its Policy Server for
   authenticity, authorization and trust guidelines for the connection.
  
   At the end of the MIDCOM session, it should be possible for either
   the middlebox or the agent to disconnect. MIDCOM session 
   disconnection may be prompted by a successful termination or 
   failure of some sort.
 
   It should be possible for the agent to disconnect itself from the 
   middlebox, which means that the agent is going out of service and 
   will not be available for further MIDCOM operations. Alternately,
   a policy server may notify a middlebox that a particular MIDCOM 
   agent is no longer authorized for a particular set of sessions 
   any longer. Note, Policy Server notifying the middlebox is one of 
   many ways by which a middlebox could disconnect an agent.

7.0. MIDCOM Framework Illustration using an In-Path agent

   In figure 3 below, we consider SIP application (Refer [SIP]) to 
   illustrate the operation of MIDCOM protocol. Specifically, the 
   application assumes a caller, external to a private domain,
   initiates the call. Middlebox is assumed to be located at the 
   edge of the private domain. A SIP phone (SIP User Agent 
   Client/Server) inside the private domain is capable of receiving
   calls from external SIP phones. The caller uses a SIP Proxy
   node, located external to the private domain, as its outbound 
   proxy. No interior proxy is assumed for the callee. Lastly, the 
   external SIP proxy node is designated to host the MIDCOM agent 
   function. 

   Arrows 1 and 4 in the figure below refer to SIP call setup
   exchange between the external SIP phone and the SIP proxy.
   Arrows 6 and 7 refer to SIP call setup exchange between the SIP
   proxy and the interior SIP phone and are assumed to be 
   traversing the middlebox. Arrows 2 and 3 below between the SIP
   proxy and the middlebox refer to MIDCOM communication. Na and Nb
   represent RTP/RTCP media traffic (Refer [RTP]) path in the
   external network. Nc and Nd represent media traffic inside the
   private domain. 

Srisuresh et al.                                               [Page 16]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

                          _________
                     --->|   SIP   |<-----\
                    /    |  Proxy  |       \
                   |     |_________|       |
                  1|       |     |        6|
                   |       |     |         |
                   |4      |2    |3        |7
   ______________  |       |     |         |    _____________
   |            |<-/      _v_____^___       \->|            |
   | External   |    Na   |           |   Nc   | SIP Phone  |
   | SIP phone  |>------->| MiddleBox |>------>| within     |
   |            |<-------<|___________|<------<| Pvt. domain|
   |____________|    Nb                   Nd   |____________|

   Figure 3: MIDCOM framework illustration with In-Path SIP Proxy

   As for the SIP application, we make the assumption that the 
   middlebox is pre-configured to accept SIP calls into the 
   private SIP phone. Specifically, this would imply that the 
   middlebox implementing firewall service is pre-configured to 
   permit SIP calls (destination TCP or UDP port number set to 
   5060) into the private phone. Likewise, middlebox implementing
   NAPT service would have been pre-configured to provide a port
   binding to permit incoming SIP calls to be redirected to the 
   specific private SIP phone. I.e., the INVITE from the external
   caller is not made to the private IP address, but to the NAPT 
   external address. 

   The objective of the MIDCOM agent in the following illustration
   is to merely permit the RTP/RTCP media stream (Refer [RTP])
   through the middlebox, when using the MIDCOM protocol architecture
   outlined in the document. RTP/RTCP media stream, When used in
   conjunction with SIP will typically result in two independent
   media sessions - one from the callee to the caller and another
   from the caller to the callee. These media sessions are UDP based
   and will use dynamic ports. The dynamic ports used for the media
   stream are specified in the SDP section (Refer [SDP]) of SIP
   payload message. The MIDCOM agent will parse the SDP section and
   use the MIDCOM protocol to (a) open pinholes (i.e., permit RTP/RTCP
   session tuples) in a middlebox implementing firewall service, or 
   (b) create PORT bindings and appropriately modify the SDP content to
   permit the RTP/RTCP streams through a middlebox implementing NAT 
   service. The MIDCOM protocol should be sufficiently rich and 
   expressive to support the operations described under the timelines.
   The examples do not show the timers maintained by the agent to 
   keep the firewall pinholes and NAT session descriptors and BINDs
   from timing out.

Srisuresh et al.                                               [Page 17]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   Midcom agent Registration and connectivity between the Midcom
   agent and the middlebox are not shown in the interest of
   restricting the focus of the MIDCOM transactions to enabling the
   middlebox to let the media stream through. Policy server is also
   not shown in the diagram below or on the timelines for the same
   reason. 

   The following subsections illustrate a typical timeline sequence
   of operations that transpire with the various elements involved
   in a SIP telephony application path. Each subsection is devoted
   to a specific instantiation of a middlebox service - NAPT 
   (refer [NAT-TERM], [NAT-TRAD]), firewall and a combination of 
   both NAPT and firewall are considered. 

7.1. Timeline flow - Middlebox implementing firewall service

   In the following example, we will assume a middlebox implementing
   a firewall service. We further assume that the middlebox is
   pre-configured to permit SIP calls (destination TCP or UDP port
   number set to 5060) into the private phone. The following timeline
   illustrates the operations performed by the MIDCOM agent to permit
   RTP/RTCP media stream through the middlebox. 

   The INVITE from the caller (external) is assumed to include the
   SDP payload. You will note that the In-Path agent requests
   the middlebox to permit the Private-to-external RTP/RTCP flows
   before the INVITE is relayed to the callee. This is because,
   in SIP, the calling party must be ready to receive the media when
   it sends the INVITE with a session description. If the called
   party (private phone) assumes this and sends "early media" before
   sending the 200 OK response, the firewall will have blocked these
   packets without this initial MIDCOM signaling from the agent.

   SIP Phone      SIP Proxy              Middlebox      SIP Phone
   (External)     (In-Path               (FIREWALL      (private)
                  MIDCOM agent)          Service)          |     
   |                 |                      |              |
   |----INVITE------>|                      |              |
   |                 |                      |              |
   |              Identify end-2-end        |              |
   |              parameters (from Caller's |              |
   |              SDP) for the pri-to-Ext   |              |
   |              RTP & RTCP sessions.      |              |
   |              (RTP1, RTCP1)             |              |
   |                 |                      |              |
   |                 |+Permit RTP1, RTCP1 +>|              |

Srisuresh et al.                                               [Page 18]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   |                 |<+RTP1, RTCP1 OKed++++|              |
   |                 |                      |              |
   |                 |--------INVITE---------------------->|
   |<---100Trying----|                      |              |
   |                 |                      |              |
   |                 |<-----180 Ringing--------------------|
   |<--180Ringing----|                      |              |
   |                 |<-------200 OK-----------------------|
   |                 |                      |              |
   |              Identify end-2-end        |              |
   |              parameters (from callee's  |              |
   |              SDP) for the Ext-to-Pri   |              |
   |              RTP and RTCP sessions.    |              |
   |              (RTP2, RTCP2)             |              |
   |                 |                      |              |
   |                 |+Permit RTP2, RTCP2 +>|              |
   |                 |<+RTP2, RTCP2 OKed++++|              |
   |                 |                      |              |
   |<---200 OK ------|                      |              |
   |-------ACK------>|                      |              |
   |                 |-----------ACK---------------------->|
   |                 |                      |              |
   |<===================RTP/RTCP==========================>|
   |                 |                      |              |
   |-------BYE------>|                      |              |
   |                 |--------------------------BYE------->|
   |                 |                      |              |
   |                 |<----------200 OK--------------------|
   |                 |                      |              |
   |                 |++Cancel permits to   |              |
   |                 |  RTP1, RTCP1, RTP2,  |              |
   |                 |  and RTCP2 +++++++++>|              |
   |                 |<+RTP1, RTP2, RTCP1 & |              |
   |                 |  RTCP2 cancelled ++++|              |
   |                 |                      |              |
   |<---200 OK-------|                      |              |
   |                 |                      |              |

      Legend:      ++++    MIDCOM control traffic
                   ----    SIP control traffic
                   ====    RTP/RTCP media traffic

7.2. Timeline flow - Middlebox implementing NAPT service

   In the following example, we will assume a middlebox implementing
   NAPT service. We make the assumption that the middlebox is
   pre-configured to redirect SIP calls to the specific private SIP

Srisuresh et al.                                               [Page 19]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   phone application. I.e., the INVITE from the external caller is
   not made to the private IP address, but to the NAPT external
   address. Let us say, the external phone's IP address is Ea, NAPT
   middlebox external Address is Ma and the internal SIP phone's
   private address is Pa. SIP calls to the private SIP phone will
   arrive as TCP/UDP sessions with destination address and port set
   to Ma and 5060 respectively. The middlebox will redirect these
   datagrams to the internal SIP phone. The following  timeline
   will illustrate the operations necessary to be performed by the
   MIDCOM agent to permit the RTP/RTCP media stream through the
   middlebox. 

   As with the previous example (section 7.1), INVITE from the
   caller (external) is assumed to include the SDP payload.
   You will note that the In-Path agent requests middlebox to create
   NAT session descriptors for the private-to-external RTP/RTCP flows
   before the INVITE is relayed to the private SIP phone (for the
   same reasons as described in section 7.1). If the called party
   (private phone) sends "early media" before sending the 200 OK
   response, the NAPT middlebox will have blocked these packets
   without the initial MIDCOM signaling from the agent. Also, note
   that after the 200 OK is received by the proxy from the private
   phone, the agent requests the middlebox to allocate NAT session
   descriptors for the external-to-private RTP2 and RTCP2 flows, such
   that the ports assigned on the Ma for RTP2 and RTCP2 are
   contiguous. RTCP stream does not happen with a non-contiguous
   port. Lastly, you will note that even though each media stream
   (RTP1, RTCP1, RTP2 and RTCP2) is independent, they are all tied to
   the single SIP control session while theit NAT session descriptors
   were being created. Finally, when the agent issues a terminate
   session bundle command for the SIP session, the middlebox is
   assumed to delete all associated media stream sessions
   automagically. 

Srisuresh et al.                                               [Page 20]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   SIP Phone      SIP Proxy              Middlebox     SIP Phone
   (External)     (In-Path               (NAPT         (Private)
   IP Addr:Ea     MIDCOM agent)          Service)      IP addr:Pa
   |                 |                   IP addr:Ma        |
   |                 |                      |              |
   |----INVITE------>|                      |              |
   |                 |++ Query Port-BIND    |              |
   |                 |   for (Ma, 5060) +++>|              |
   |                 |<+ Port-BIND reply    |              |
   |                 |   for (Ma, 5060) ++++|              |
   |                 |                      |              |
   |                 |++ Query NAT Session  |              |
   |                 |   Descriptor for     |              |
   |                 |   Ea-to-Pa SIP flow+>|              |
   |                 |<+ Ea-to-Pa SIP flow  |              |
   |                 |   Session Descriptor+|              |
   |                 |                      |              |
   |              Determine the Internal    |              |
   |              IP address (Pa)           |              |
   |              of the callee.            |              |
   |                 |                      |              |
   |              Identify UDP port numbers |              |
   |              on Ea (Eport1, Eport1+1)  |              |
   |              for pri-to-ext RTP & RTCP |              |
   |              sessions (RTP1, RTCP1)    |              |
   |                 |                      |              |
   |                 |++Create NAT Session  |              |
   |                 |  descriptors for     |              |
   |                 |  RTP1, RTCP1; Set    |              |
   |                 |  parent session to   |              |
   |                 |  SIP-ctrl session ++>|              |
   |                 |<+RTP1, RTCP1 session |              |
   |                 |  descriptors created+|              |
   |                 |                      |              |
   |                 |                      |..redirected..|
   |                 |--------INVITE--------|------------->|
   |<---100Trying----|                      |              |
   |                 |                      |              |
   |                 |<-----180Ringing---------------------|
   |                 |                      |              |
   |<--180Ringing----|                      |              |
   |                 |<-------200 OK-----------------------|
   |                 |                      |              |
   |              Identify UDP port numbers |              |
   |              on Pa (Pport2, Pport2+1)  |              |
   |              for ext-to-pri RTP & RTCP |              |
   |              sessions (RTP2, RTCP2)    |              |
   |                 |                      |              |

Srisuresh et al.                                               [Page 21]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   |                 |++Create consecutive  |              |
   |                 |  port BINDs on Ma    |              |
   |                 |  for (Pa, Pport2),   |              |
   |                 |  (Pa, Pport2+1) ++++>|              |
   |                 |<+Port BINDs created++|              |
   |                 |                      |              |
   |                 |++Create NAT Session  |              |
   |                 |  descriptors for     |              |
   |                 |  RTP2, RTCP2; Set    |              |
   |                 |  parent session to   |              |
   |                 |  SIP-ctrl session ++>|              |
   |                 |<+RTP2, RTCP2 session |              |
   |                 |  descriptors created+|              |
   |                 |                      |              |
   |              Modify the SDP            |              |
   |              parameters in "200 OK"    |              |
   |              with NAPT PORT-BIND       |              |
   |              for the RTP2 port on Ma.  |              |
   |                 |                      |              |
   |<---200 OK ------|                      |              |
   |                 |                      |              |
   |-------ACK------>|                      |              |
   |                 |                      |              |
   |              Modify IP addresses       |              |
   |              appropriately in the SIP  |              |
   |              header (e.g., To, from,   |              |
   |              Via, contact fields)      |              |
   |                 |                      |..redirected..|
   |                 |-----------ACK--------|------------->|
   |                 |                      |              |
   |                 |                      |              |
   |<===================RTP/RTCP============|=============>|
   |                 |                      |              |
   |-------BYE------>|                      |              |
   |                 |                      |              |
   |              Modify IP addresses       |              |
   |              appropriately in the      |              |
   |              SIP header.               |              |
   |                 |                      |              |
   |                 |----------------------|-----BYE----->|
   |                 |                      |              |
   |                 |<----------200 OK--------------------|
   |                 |                      |              |
   |                 |+++Terminate the SIP  |              |
   |                 |   Session bundle +++>|              |
   |                 |<++SIP Session bundle |              |
   |                 |   terminated ++++++++|              |
   |                 |                      |              |

Srisuresh et al.                                               [Page 22]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   |              Modify SDP                |              |
   |              parameters in "200 OK"    |              |
   |                 |                      |              |
   |<---200 OK-------|                      |              |
   |                 |                      |              |

      Legend:      ++++    MIDCOM control traffic
                   ----    SIP control traffic
                   ====    RTP/RTCP media traffic

7.3. Timeline flow - Middlebox implementing NAPT and firewall

   In the following example, we will assume a middlebox 
   implementing a combination of a firewall and a stateful NAPT
   service. We make the assumption that the NAPT function is
   configured to translate the IP and TCP headers of the initial
   SIP session into the private SIP phone and the firewall 
   function is configured to permit the initial SIP session. 

   In the following time line, it may be noted that the firewall
   description is based on packet fields on the wire (ex: as seen
   on the external interface of the middlebox).  In order to 
   ensure correct behavior of the individual services, you will 
   notice that NAT specific MIDCOM operations precede firewall 
   specific operations on the MIDCOM agent. This is noticeable in
   the time line below when the MIDCOM agent processes the 
   "200 OK" from the private SIP phone. The MIDCOM agent initially
   requests the NAT service on the middlebox to set up port-BIND
   and session-descriptors for the media stream in both directions.
   Subsequent to that, the MIDCOM agent determines the session 
   parameters (i.e, the dynamic UDP ports) for the media stream, 
   as viewed by the external interface and requests the firewall
   service on the middlebox to permit those sessions through.

   SIP Phone      SIP Proxy              Middlebox     SIP Phone
   (External)     (In-Path               (NAPT &       (Private)
   IP Addr:Ea     MIDCOM agent)          firewall      IP addr:Pa
   |                 |                   Services)         |
   |                 |                   IP addr:Ma        |
   |                 |                      |              |
   |----INVITE------>|                      |              |
   |                 |++ Query Port-BIND    |              |
   |                 |   for (Ma, 5060) +++>|              |

Srisuresh et al.                                               [Page 23]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   |                 |<+ Port-BIND reply    |              |
   |                 |   for (Ma, 5060) ++++|              |
   |                 |                      |              |
   |                 |++ Query NAT Session  |              |
   |                 |   Descriptor for     |              |
   |                 |   Ea-to-Pa SIP flow+>|              |
   |                 |<+ Ea-to-Pa SIP flow  |              |
   |                 |   Session Descriptor+|              |
   |                 |                      |              |
   |              Determine the Internal    |              |
   |              IP address (Pa)           |              |
   |              of the callee.            |              |
   |                 |                      |              |
   |              Identify UDP port numbers |              |
   |              on Ea (Eport1, Eport1+1)  |              |
   |              for pri-to-ext RTP & RTCP |              |
   |              sessions (RTP1, RTCP1)    |              |
   |                 |                      |              |
   |                 |++Create NAT Session  |              |
   |                 |  descriptors for     |              |
   |                 |  RTP1, RTCP1; Set the|              |
   |                 |  parent session to   |              |
   |                 |  point to SIP flow++>|              |
   |                 |<+RTP1, RTCP1 session |              |
   |                 |  descriptors created+|              |
   |                 |                      |              |
   |                 |++Permit RTP1 & RTCP1 |              |
   |                 |  sessions External to|              |
   |                 |  middlebox, namely   |              |
   |                 |  Ma to Ea:Eport1,    |              |
   |                 |  Ma to Ea:Eport1+1   |              |
   |                 |  sessions ++++++++++>|              |
   |                 |<+Ma to Ea:Eport1,    |              |
   |                 |  Ma to Ea:Eport1+1   |              |
   |                 |  sessions OKed ++++++|              |
   |                 |                      |              |
   |                 |                      |..redirected..|
   |                 |--------INVITE--------|------------->|
   |<---100Trying----|                      |              |
   |                 |                      |              |
   |                 |<-----180Ringing---------------------|
   |                 |                      |              |
   |                 |                      |              |
   |<--180Ringing----|                      |              |
   |                 |<-------200 OK-----------------------|
   |                 |                      |              |
   |              Identify UDP port numbers |              |
   |              on Pa (Pport2, Pport2+1)  |              |

Srisuresh et al.                                               [Page 24]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   |              for ext-to-pri RTP & RTCP |              |
   |              sessions (RTP2, RTCP2)    |              |
   |                 |                      |              |
   |                 |++Create consecutive  |              |
   |                 |  port BINDs on Ma    |              |
   |                 |  for (Pa, Pport2),   |              |
   |                 |  (Pa, Pport2+1) ++++>|              |
   |                 |<+Port BINDs created  |              |
   |                 |  on Ma as (Mport2,   |              |
   |                 |  Mport2+1) ++++++++++|              |
   |                 |                      |              |
   |                 |++Create NAT Session  |              |
   |                 |  descriptors for     |              |
   |                 |  RTP2, RTCP2; Set the|              |
   |                 |  parent session to   |              |
   |                 |  point to SIP flow++>|              |
   |                 |<+RTP2, RTCP2 session |              |
   |                 |  descriptors created+|              |
   |                 |                      |              |
   |              Modify the SDP            |              |
   |              parameters in "200 OK"    |              |
   |              with NAPT PORT-BIND       |              |
   |              for RTP2 port on Ma.      |              |
   |                 |                      |              |
   |                 |++Permit RTP2 & RTCP2 |              |
   |                 |  sessions External   |              |
   |                 |  middlebox, namely   |              |
   |                 |  Ea to Ma:Mport2,    |              |
   |                 |  Ea to Ma:Mport2+1   |              |
   |                 |  sessions ++++++++++>|              |
   |                 |<+Ea to Ma:Mport2,    |              |
   |                 |  Ea to Ma:Mport2     |              |
   |                 |  sessions OKed ++++++|              |
   |                 |                      |              |
   |<---200 OK ------|                      |              |
   |                 |                      |              |
   |-------ACK------>|                      |              |
   |                 |                      |..redirected..|
   |                 |-----------ACK--------|------------->|
   |                 |                      |              |
   |                 |                      |              |
   |<===================RTP/RTCP============|=============>|
   |                 |                      |              |
   |-------BYE------>|                      |              |
   |                 |                      |              |
   |              Modify SDP payload        |              |
   |              parameters in BYE         |              |
   |                 |                      |              |

Srisuresh et al.                                               [Page 25]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   |                 |----------------------|-----BYE----->|
   |                 |                      |              |
   |                 |<----------200 OK--------------------|
   |                 |                      |              |
   |                 |+++Terminate the SIP  |              |
   |                 |   Session bundle +++>|              |
   |                 |<++SIP Session bundle |              |
   |                 |   terminated ++++++++|              |
   |                 |                      |              |
   |                 |++Cancel permits to   |              |
   |                 |  sessions External   |              |
   |                 |  middlebox, namely   |              |
   |                 |  Ma to Ea:Eport1,    |              |
   |                 |  Ma to Ea:Eport1+1   |              |
   |                 |  Ea to Ma:Mport2,    |              |
   |                 |  Ea to Ma:Mport2+1   |              |
   |                 |  sessions ++++++++++>|              |
   |                 |<+Removed permits to  |              |
   |                 |  sessions listed ++++|              |
   |                 |                      |              |
   |              Modify SDP                |              |
   |              parameters in "200 OK"    |              |
   |                 |                      |              |
   |<---200 OK-------|                      |              |
   |                 |                      |              |

      Legend:      ++++    MIDCOM control traffic
                   ----    SIP control traffic
                   ====    RTP/RTCP media traffic

8.0. Operational considerations 
   
8.1. Multiple MIDCOM connections between agents and middlebox 

   A middlebox cannot be assumed to be a simple device
   implementing just one middlebox function and no more than a 
   couple of interfaces. Middleboxes often combine multiple 
   intermediate functions into the same device and have the 
   ability to provision individual interfaces of the same device
   with different sets of functions and varied provisioning for
   the same function across the interfaces. 

   As such, a MIDCOM agent ought to be able to have a single 
   MIDCOM connection with a middlebox and use the MIDCOM
   interface on the middlebox to interface with different
   services on the same middlebox interface.

Srisuresh et al.                                               [Page 26]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

8.2. Asynchronous notification to MIDCOM agents

   Asynchronous notification by the middlebox to a MIDCOM agent
   can be useful for events such as Session creation, Session 
   termination, MIDCOM protocol failure, Middlebox function 
   failure or any other significant event. Independently, ICMP
   error codes can also be useful to notify transport layer
   failures to the agents. 

   In addition, periodic notification of various forms of data 
   such as statistics update would also be a useful function
   that would be beneficial to certain types of agents.

8.3. Timers on Middlebox considered useful

   When supporting MIDCOM protocol, the middlebox is required to 
   allocate dynamic resources such as pin-holes, upon request from
   agents. Explicit release of dynamically allocated resources
   happens when the application session is ended or when a Midcom
   agent requests the middlebox to release the resource. 

   However, the middlebox should be able to recover the dynamically
   allocated resources even as the agent that was responsible for
   the allocation is not alive. Associating a lifetime for these
   dynamic resources and using a timer to track the lifetime can
   be a good way to accomplish this.

8.4. Middleboxes supporting multiple services

   A middlebox could be implementing a variety of services (e.g. NAT
   and firewall) in the same box. Some of these services might have
   inter-dependency on shared resources and sequence of operation.
   Others may be independent of each other. Generally speaking,
   the sequence in which these function operations may be performed
   on datagrams is not within the scope of this document.

   In the case of a middlebox implementing NAT and firewall
   services, it is safe to state that the NAT operation on an
   interface will precede firewall on the egress and will follow
   firewall on the ingress.  Further, firewall access control
   lists used by a firewall are assumed to be based on session
   parameters as seen on the interface supporting firewall service. 

8.5. Signaling and Data traffic

   The class of applications the MIDCOM architecture is addressing
   focus around applications that have a combination of one or more
   signaling and data traffic sessions. The signaling may be done

Srisuresh et al.                                               [Page 27]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   out-of-band using a dedicated stand-alone session or may be done
   in-band within data session. Alternately, signaling may also be
   done as a combination of both stand-alone and in-band sessions. 

   SIP is an example of an application based on distinct signaling
   and data sessions. SIP signaling session is used for call setup
   between a caller and a callee. MIDCOM agent may be required to 
   examine/modify SIP payload content to administer the middlebox
   so as to let the media streams (RTP/RTCP based) through. MIDCOM
   agent is not required to intervene in the data traffic.

   Signaling and context specific Header information is sent in-band
   within the same data stream for applications such as HTTP embedded 
   applications, sun-RPC (embedding a variety of NFS apps), Oracle 
   transactions (embedding oracle SQL+, MS ODBC, Peoplesoft) etc. 
   
   H.323 is an example of application that sends signaling in both
   dedicated stand-alone session as well as in conjunction with data.
   Q.931 traffic traverses middleboxes by virtue of static policy, 
   no MIDCOM control needed. Q.931 also negotiates ports for an 
   H.245 TCP stream. A MIDCOM agent is required to examine/modify 
   the contents of the H.245 so that H.245 can traverse it.

   H.245 traverses the middlebox and also carries Open Logical 
   Channel information for media data. So the MIDCOM agent is once 
   again required to examine/modify the payload content needs to
   let the media traffic flow.

   The MIDCOM architecture takes into consideration, supporting 
   applications with independent signaling and data sessions as 
   well as applications that have signaling and data communicated
   over the same session. 

   In the cases where signaling is done on a single stand-alone 
   session, it is desirable to have a MIDCOM agent interpret the 
   signaling stream and program the middlebox (that transits the
   data stream) so as to let the data traffic through uninterrupted.

9. Applicability Statement

   Middleboxes may be stationed in a number of topologies. However, the
   signaling framework outlined in this document may be limited to only
   those middleboxes that are located in a DMZ (De-Militarized Zone) at 
   the edge of a private domain, connecting to the Internet. 
   Specifically, the assumption is that you have a single middlebox 
   (running NAT or firewall) along the application route. Discovery of
   middlebox along application route is outside the scope of this 

Srisuresh et al.                                               [Page 28]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   document. It is conceivable to have middleboxes located between
   departments within the same domain or inside service provider's
   domain and so forth. However, care must be taken to review each
   individual scenario and determine the applicability on a
   case-by-case basis.

   The applicability may also be illustrated as follows. Real-time and 
   streaming applications such as Voice-Over-IP and peer-to-peer
   applications such as Napster and Netmeeting require administering
   firewall and NAT middleboxes to let their media streams reach hosts
   inside a private domain. The requirements are in the form of
   establishing a "pin-hole" to permit a TCP/UDP session (the port
   parameters of which are dynamically determined) through a firewall
   or retain an address/port bind in the NAT device to permit
   connections to a port. These requirements are met by current
   generation middleboxes using adhoc methods, such as embedding
   application intelligence within a middlebox to identify the dynamic
   session parameters and administering the middlebox internally as
   appropriate. The objective of the MIDCOM architecture is to create
   a unified, standard way to exercise this functionality, currently
   existing in an ad-hoc fashion in some of the middleboxes.

   By adopting MIDCOM architecture, middleboxes will be able to
   support newer applications they have not been able to support thus
   far. MIDCOM architecture does not and MUST not, in anyway, change
   the fundamental characteristic of the services supported on the
   middlebox.
 
   Typically, organizations shield a majority of their corporate 
   resources (such as end-hosts) from visibility to the external
   network by the use of a De-Militarized Zone (DMZ) at the domain
   edge. Only a portion of these hosts are allowed to be accessed by
   the external world. The remaining hosts and their names are unique
   to the private domain. Hosts visible to the external world and the 
   authoritative name server that maps their names to network 
   addresses are often configured within a DMZ (De-Militarized Zone) 
   in front of a firewall. Hosts and middleboxes within DMZ are 
   referred to as DMZ nodes.

   Figure 4 below illustrates configuration of a private domain with
   a DMZ at its edge. Actual configurations may vary. Internal hosts
   are accessed only by users inside the domain. Middleboxes, 
   located in the DMZ may be accessed by agents inside or outside 
   the domain.

Srisuresh et al.                                               [Page 29]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

                                   \ | /
                           +-----------------------+
                           |Service Provider Router|
                           +-----------------------+
                            WAN  |
               Stub A .........|\|....
                               |
                     +---------------+
                     | NAT Middlebox |
                     +---------------+
                         |
                         |   DMZ - Network
   ------------------------------------------------------------
      |         |              |            |             |
     +--+      +--+           +--+         +--+      +-----------+
     |__|      |__|           |__|         |__|      | Firewall  |
    /____\    /____\         /____\       /____\     | Middlebox |
   DMZ-Host1  DMZ-Host2 ...  DMZ-Name     DMZ-Web    +-----------+
                             Server       Server etc.   |
                                                        |
     Internal Hosts (inside the private domain)         |
   ------------------------------------------------------------
       |             |                 |           |
      +--+         +--+               +--+       +--+
      |__|         |__|               |__|       |__|
     /____\       /____\             /____\     /____\
    Int-Host1    Int-Host2  .....   Int-Hostn   Int-Name Server

    Figure 4: DMZ network configuration of a private domain.

10. Acknowledgements

   The authors wish to thank Christian Huitema, Joon Maeng, Jon 
   Peterson, Mike Fisk, Matt Holdrege, Melinda Shore, Paul Sijben,
   Philip Mart, Scott Brim and Richard Swale for their valuable
   critique, advice and input on an earlier rough version of this
   document. The authors owe special thanks to Eliot Lear for
   kick-starting the e-mail discussion on use-case scenarios with a
   SIP application flow diagram through a middlebox. Much thanks to
   Bob Penfield, Cedric Aoun, Christopher Martin, Eric Fleischman,
   George Michaelson, Wanqun Bao and others in the MIDCOM work group
   for their very detailed feedback on a variety of topics and
   adding clarity to the discussion. Last, but not the least, the
   authors owe much thanks to Melinda Shore for her continued
   support, critique and feedback throughout in bringing out fine
   subtleties and helping to make the document a better read. 

Srisuresh et al.                                               [Page 30]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

11. Security Considerations

   Discussed below are security consideration in accessing a
   middlebox. Without MIDCOM protocol support, the premise of a 
   middlebox operation fundamentally requires the data to be in the
   clear as the middlebox needs the ability to inspect and/or modify
   packet headers and payload. This compromises the confidentiality
   requirement in some environments. Further, Updating transport
   headers and rewriting application payload data in some cases by
   NAT prevents the use of integrity protection on some data streams
   traversing NAT middleboxes. Clearly, this can pose a significant
   security threat to the application in an untrusted transport
   domain.

   However, the MIDCOM protocol removes the need for a middlebox
   to inspect or manipulate data. This in turn allows applications
   to better protect themselves end-to-end with the aid of a trusted
   MIDCOM agent. This is especially the case when the agent is
   resident on the end-host. When an agent has the same end-to-end
   ability as the end-host to interpret encrypted and integrity
   protected data, data transiting a middlebox can be encrypted and
   integrity protected. The MIDCOM agent will still be able to
   interpret the data and simply notify the middlebox to open holes,
   install NAT table entries, etc.

   Security between a MIDCOM agent and a middlebox has a number of
   components. Authorization, authentication, integrity and
   confidentiality. Authorization refers to whether a particular
   agent is authorized to signal middlebox with requests for one or
   more applications adhering to a certain policy profile. Failing the
   authorization process might indicate resource theft attempt or
   failure due to administrative and/or credential deficiencies. In
   either case, the middlebox should take the proper measures to
   audit/log such attempts and consult its designated policy server
   for the required action if the middlebox is configured with one.
   Alternatively, the middlebox may resort to a default service deny
   policy when a midcom agent fails to prompt the required
   credentials. Section 6 discusses the middlebox-policy server
   interactions in view of policy decisions.

   Authentication refers to confirming the identity of originator 
   for all datagrams received from the originator. Lack of strong
   credentials for authentication of MIDCOM messages between an agent
   and a middlebox can seriously jeopardize the fundamental service
   rendered by the middlebox. A consequence of not authenticating an
   agent would be that an attacker could spoof the identity of a 

Srisuresh et al.                                               [Page 31]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   "legitimate" agent and open holes in the firewall.  Another would
   be that it could otherwise manipulate state on a middlebox,
   creating a denial-of-service attack by closing needed pinholes or
   filling up a NAT table.  A consequence of not authenticating the
   middlebox to an agent is that an attacker could pose as a
   middlebox and respond to NAT requests in a manner that would divert
   data to the attacker. Failing to submit the required/valid 
   credentials once challenged may indicate a replay attack and in 
   which case a proper action is required by the middlebox such as 
   auditing, logging, consulting its designated policy server to
   reflect such failure. A consequence of not protecting the 
   middlebox against replay attacks would be that a specific 
   pinhole may be reopened or closed by an attacker at will, thereby
   bombarding end hosts with unwarranted data or causing denial of 
   service.  

   Integrity is required to ensure that a MIDCOM message has not been
   accidentally or maliciously altered or destroyed. Result of a lack
   of data integrity enforcement in an untrusted environment could be
   that an imposter will alter the messages sent by an agent and
   bring the middlebox to a halt or cause a denial of service for the
   application the agent is attempting to enable.

   Confidentiality of MIDCOM messages ensure that the signaling data 
   is accessible only to the authorized entities. When a middlebox
   agent is deployed in an untrusted environment, lack of 
   confidentiality will allow an intruder to perform traffic flow
   analysis and snoop the middlebox resources. The intruder could
   cannibalize a lesser secure MIDCOM connection and destroy or 
   compromise the middlebox resources he uncovered on other 
   connections. Needless to say, the least secure MIDCOM connection
   will become the achilles heel and make the middlebox vulnerable
   to security attacks. 

   Lastly, there can be security vulnerability to the applications
   traversing a middlebox when a resource on a middlebox is controlled
   by multiple external agents.  A middlebox service may be disrupted
   due to conflicting directives from multiple agents associated with
   different middlebox functions but applied to the same application
   session. Care must be taken in the protocol design to ensure that
   agents for one function do not abruptly step over resources impacting
   a different function. Alternately, the severity of such
   manifestations could be lessened when a single MIDCOM agent is
   responsible for supporting all the middlebox services for an
   application due to the reduced complexity and synchronization effort
   in managing the middlebox resources.

Srisuresh et al.                                               [Page 32]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

REFERENCES

   [IETF-STD] Bradner, S., " The Internet Standards Process -- 
              Revision 3", RFC 1602, IETF, October 1996.

   [SIP]      Handley, M., H. Schulzrinne, E. Schooler, and 
              J. Rosenberg, "SIP: Session Initiation Protocol", 
              RFC 2543, IETF, March 1999. 

   [SDP]      Handley, M., and Jacobson, V., "SDP: session 
              description protocol", RFC 2327, IETF, April 1998.

   [H.323]    ITU-T Recommendation H.323. "Packet-based Multimedia
              Communications Systems," 1998.

   [RTP]      Schulzrinne, H., S. Casner, R. Frederick, and V. Jacobson,
              "RTP: A Transport Protocol for Real-Time Applications",
              RFC 1889, IETF, January 1996. 

   [RTSP]     Schulzrinne, H., A. Rao, R. Lanphier: "Real Time 
              Streaming Protocol", RFC 2326, IETF, April 1998.

   [FTP]      J. Postel, J. Reynolds, "FILE TRANSFER PROTOCOL (FTP)",  
              RFC 959

   [NAT-TERM] Srisuresh, P. and M. Holdrege, "IP Network Address 
              Translator (NAT) Terminology and Considerations", 
              RFC 2663, August 1999.

   [NAT-TRAD] Srisuresh, P. and Egevang, K., "Traditional IP Network
              Address Translator (Traditional NAT)", RFC 3022, 
              January 2001.

   [NAT-COMP] Holdrege, M. and Srisuresh, P., "Protocol Complications
              with the IP Network Address Translator", RFC 3027, 
              January 2001.

   [NAT-PT]   Tsirtsis, G. and Srisuresh, P., "Network Address 
              Translation - Protocol Translation (NAT-PT)", 
              RFC 2766, February 2000.

   [APPL-ID]  Bernet, Y. and Pabbati, R., "Application and Sub 
              Application Identity Policy Element for Use with
              RSVP", RFC 2872, June 2000.

   [RFC 1918] Rekhter, Y., Moskowitz, B., Karrenberg, D., 
              de Groot, G. and E. Lear, "Address Allocation for 
              Private Internets", BCP 5, RFC 1918, February 1996.

Srisuresh et al.                                               [Page 33]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   [RFC 1700] J. Reynolds and J. Postel, "Assigned Numbers", 
              RFC 1700

   [IPsec-AH] Kent, S., and R. Atkinson, "IP Authentication 
              Header", RFC 2402, November 1998.

   [IPsec-ESP] Kent, S., and R. Atkinson, "IP Encapsulating 
              Security Payload (ESP)", RFC 2406, November 1998.

   [TLS]      Dierks, T., and Allen, C., "The TLS Protocol
              Version 1.0", RFC 2246, January 1999.

Authors' Addresses

   Pyda Srisuresh
   Kuokoa Networks, Inc.
   2901 Tasman Dr., Suite 202
   Santa Clara, CA 95054
   U.S.A.
   EMail: [email-masked]

   Jiri Kuthan
   GMD Fokus
   Kaiserin-Augusta-Allee 31
   D-10589 Berlin, Germany
   E-mail: [email-masked]

   Jonathan Rosenberg
   dynamicsoft
   200 Executive Drive
   Suite 120
   West Orange, NJ 07052
   U.S.A.
   email: [email-masked]

   Andrew Molitor
   Aravox technologies
   4201 Lexington Avenue North, Suite 1105
   Arden Hills, MN 55126
   U.S.A.
   voice: (651) 256-2700
   email: [email-masked]

Srisuresh et al.                                               [Page 34]

Internet-Draft      MIDCOM Architecture  & Framework         August 2001

   Abdallah Rayhan
   P.O. Box 3511 Stn C
   Ottawa, ON, Canada K1Y 4H7
   eMail: [email-masked]

Srisuresh et al.                                               [Page 35]

---

From: Scott Brim <[email-masked]>
Date: Mon, 6 Aug 2001 14:49:38 +0100

There's only one change I don't understand.  "Deregister" is now
"disconnect".  Why?  

Thanks ... Scott

_______________________________________________
midcom mailing list
[email-masked]
http://www.ietf.org/mailman/listinfo/midcom