Description Language for Security Policy and Topology

Overview

Rules

Network objects and service definitions are used in rules to describe network traffic which can or must not pass packet from source to destination.

Policies

Network Objects

Service Definitions

Groups

Service Groups

Detailed description of network objects

The topology is built from networks and routers. A router and a network are connected by an interface. Networks may have any number of hosts, which are located inside the network.

Routers may be managed or unmanaged. For a managed router, NetSPoC generates access control lists which control what traffic can pass this router and what traffic is blocked. The whole topology is partitioned into different security domains by managed routers.

Special network objects called 'any' objects and 'every' objects may be defined which denote all network objects in a security domain.

General syntax

All network objects and groups have a typed name like <type>:<name>.

<name> is build from one ore more alphanumerical and underscore characters. The current locale settings are used, i.e. accented characters are allowed for european locale settings.

<ip-adr> denotes an IP address. Currently NetSPoC handles IP v4 addresses n.n.n.n with 0 <= n <= 255

<interface_name> may contain any characters, even interspersed whitespace. Currently characters from [;,=] are not allowed, since we use them as delimiters.

<int> is an integer

Meta symbols in syntax definitions below:

Network Definition

Syntax

  network:<name> = {
     {{
         [ route_hint; ]
	 [ subnet_of = network:<name>; ]
         ip = <ip-adr>; mask = <ip-adr>; 
         <host definition> *
     |
         unnumbered
     }}
  }

Host definition

Syntax

  <host definition> ::=
  {{
        host:<name> = { ip = <ip-adr>, ...; }
  |
        host:<name> = { range = <ip-adr> - <ip-adr>; }
  }}

Router definition

Syntax

  <router definition> ::=
  router:<name> = {
     {{
        managed [ = {{ full | secondary }} ] ;
        model = <name>;
        static_manual;
	<complete interface definition> *
     |
        [ model = <name>; ]
        {{ <interface definition> | <short interface definition> }} *
     }}
  }

Interface definition

Syntax

 <complete interface definition> ::=
 interface:<name> = {
         {{ ip = <ip-adr>, ...; | unnumbered; }}
         hardware = <interface_name>;
	 [ routing = OSPF; ]
         [ disabled ; ]
 }

 <interface definition> ::= 
 interface:<name> = {
         {{ ip = <ip-adr>, ...; | unnumbered; }}
         [ hardware = <interface_name>; ]
	 [ routing = OSPF; ]
         [ disabled ; ]
 }

 <short interface definition> ::=
 interface:<name>;

'Every' object definition

Syntax

 every:<name> = { link = {{ network:<name>; | router:<name>; }} }

'Any' object definition

Syntax

 any:<name> = { link = {{ network:<name>; |  router:<name>; }} }

Referencing network objects

Syntax

 <network object> ::=
 {{
   host:<name> 
 | network:<name> 
 | router:<name> 
 | interface:<name>.<name> 
 | any:<name> 
 | every:<name>
 | group:<name> 
 }}

Groups of network objects

Syntax

 group:<name> = <network object list>;

with

 <network object list> :== <network object>, ...

Services

Syntax

 service:<name> = 
 {{
   ip 
 | tcp [<range> ->] <range>
 | udp [<range> ->] <range>
 | icmp [<int_1>[/<int_2>]] 
 | proto <int> 
 }} ;

with

<range> ::= [<int_1>[-<int_2>]]

tcp, udp

icmp

protocol

Groups of services

Syntax

  servicegroup:<name> = <service list>;

with

  <service list> ::= <service>, ...
  <service> ::= {{ service:<name> | servicegroup:<name> }}

Rules

Syntax

  <rule> ::=
  {{ permit | deny }}
        src = <network object list>;
        dst = <network objec listt>;
        srv = <service list>;

Policies

Syntax

  <policy> ::= {
        user = <network object list>;
	<policy_rule> * 
  }

with

  <policy_rule> ::=
  {{ permit | deny }}
        src = <policy_object>;
        dst = <policy_object>;
        srv = <service list>;
  <policy_object> ::= {{ user | <network object list> }}

Secondary packet filters

In a given topology we may have chains of managed packet filters on the path from src to dst. Each packet filter is a "full" packet filter by default, which does full filtering for each rule again and again.
A secondary packet filter has simpler rules for permitted traffic which gets further filtering by a full packet filter. In this case it allows any IP packets from the src network to the dst network. This simple filterung assures that the traffic comes from the rigth src and goes to the rigth dst.
A secondary packet filter is declared by the attribute "managed = secondary". This may be usefull if a router has not enough memory for storing a complete set of filter rules and most of the packets get fully filtered already by some other managed device.

Routing

Static and dynamic routing

From its knowledge about the topology, NetSPoC generates static routing entries for each managed device. If an interface of a device has an attribute "routing=<routing protocol>", no static routing entries are generated for networks behind that interface.

Routing entries are only generated for network objects, which are used in some rule. I.e. no routing entries are generated for unsused parts of the topology. Even for network objects which are only used as source of a rule, routing entries are generated, since stateful packet filters implicitly allow answer packets back to the source. If an 'any' object is used in a rule, routing entries for all networks part of this 'any' object are generated.

Default route

A default route may be defined for a topology by placing a network with IP address and mask equal 0.0.0.0. Such a network must have an attribute "route_hint".

Alternativly, NetSPoC can automatically define a default route for each managed device as a means to reduce the number of static routing entries. At each managed device, a default route is automtically inserted such that it replaces the maximum number of routing entries. This behaviour may be switched on or off by option $auto_default_route. This option must be off, if a user defined default route is given.

Optimization

Multiple routing entries for networks which are in a subnet relation, are replaced by a single routing entry.

Disabling part of the topology

An interface may be explicitly marked as disabled. This implicitly marks all network objects as disabled, that are directly or indirectly connected to this interface. All occurrences of disabled network objects in groups and rules are silently discarded.

Handling of 'any' objects

The meaning of 'any' is different in a NetSPoC rule from that in an ACL. For NetSPoC, any:X means "any network object of the security domain where any:X is located". For an ACL which filters incoming traffic of an interface, any (i.e. 0.0.0.0/0.0.0.0) means "any network object beyond the interface where the ACL is applied to".

as source:
any data object connected directly or indirectly with this interface.
as destination:
any data object lying behind the router where the interface belongs to.

PIX security levels

PIX firewalls have a security level associated with each interface. We don't want to expand our syntax to state them explicitly, but instead we try to derive the level from the interface name:

It is not necessary the find the exact level; what we need to know is the relation of the security levels to each other.

Automatic deletion of redundant rules

Fully implemented, but documentation has to be done ...

Generated Code

Supported devices

Copyright (c) 2003, Heinz Knutzen heinzknutzen@users.berlios.de