TOS R19-1 Developer's Guide
TOS R19-1 Developer's Guide
Version R19-1
For additional technical information, please see our support website, at:
[Link]
Tufin Orchestration Suite (TOS) Developer's Guide
Contents
Domains ....................................................................................................................... 16
General ......................................................................................................................... 27
Performance ................................................................................................................. 29
The TOS Developers Guide Getting Started with the TOS API
Chapter 1
For more about the APIs included in this guide, contact your sales representative or Tufin
Support ([Link]
Tufin Orchestration Suite (TOS) REST API Getting Started with the TOS API
Chapter 2
• You access a resource by sending an HTTP request to the TOS server. The server
replies with a response that either contains the data you requested, an HTTP status
indicator, or both.
• TOS APIs are organized by resources, as recommended by REST best practices. API
resources are located at:
SecureTrack [Link]
SecureChange [Link]
urechange/
SecureApp [Link]
app/
• You request a particular resource by appending a particular path to this base URL that
specifies the resource.
• You must authenticate to the TOS server using HTTP basic access authentication with
a valid username and password. The permissions for the account you use for
authentication apply to your API request.
Tufin Orchestration Suite (TOS) REST API Getting Started with the TOS API
SecureChange and SecureApp - The user can be any user that has permissions for
the action that is done by the API call.
• API Pagination is supported for many REST API calls that return large amounts of data,
making it easier for you to manage the results. If the API has the optional parameters
start and count, then pagination is supported for that API call.
For example, if you wish to retrieve elements 51-60 in your results, set start = 50,
and count = 10.
The DTO for the results will contain a count and total field. Use these returned
values to determine how many paginated calls you will need to make to retrieve all the
desired results.
count (DTO results field) - lists the actual number of elements included in the
returned results
total (DTO results field) - lists the total number of elements available to be
included in the returned results
For example, if you set the start parameter to 120 and the total number of elements
from the search is 128, then the DTO results fields will be set as: total = 128 and
count = 8, because the returned results contain the last 8 elements of the total of
128 possible results.
• Access to TOS functionality via the REST API is determined by the specific
permissions granted to the username used for authentication, unless otherwise noted
explicitly otherwise for a specific API. For example if you run get_devices, the API
call will return only the devices you have permission to access. Additional information
about user permissions can be found at:
Tufin Orchestration Suite (TOS) REST API Getting Started with the TOS API
• For security reasons, the OPTION http method is not supported. Supported REST API
methods will include: GET, POST, PUT, PATCH and DELETE.
Response Formats
For each resource, you can get the response in these formats:
For R18-2 and above, TOS has started migrating APIs to use a new JSON marshaller. For
the APIs listed below, when returning a JSON list with a single element, the API passes the
element inside an array rather than as a single element. Source code will no longer have to
handle returned results differently depending on whether it is a single element or an array of
element. Strings like id of a device, that were previously returned as integers will now be
returned as a string containing the number surrounded with double quotes. Empty lists that
were previously omitted will now be included as empty arrays. The order in which the
properties appear in the returned JSON might be different from previous TOS versions.
(This change does not apply to returned XML data.) The change to the JSON returned data
applies to the following APIs:
Tufin Orchestration Suite (TOS) REST API SecureTrack REST API Resources
[Link]
2/securetrack/apidoc/#!/Security_Rules/findRulesOnDevices
[Link]
2/securetrack/apidoc/#!/Security_Rules/findRules
Additional Resources
The following additional REST API resources are available:
For example, to get only 10 revisions that start from revision 21, use:
[Link]
t=10
Tufin Orchestration Suite (TOS) REST API SecureTrack REST API Resources
Some resources are associated with a revision. This reflects SecureTrack’s ability to track
policy changes and store them as revisions. To retrieve a resource from a specific revision
you must provide the revision ID, which is available via the /devices/<device-
id>/revisions API.
supported vendors
The following values can be returned in the vendor field of the SecureTrack \devices
REST API.
• Amazon
• BlueCoat
• CheckPoint
• Cisco
• F5
• NewF5
• Stonesoft
• Fortinet
• Netscreen
• Azure
• Linux
• OpenStack
• PaloAltoNetworks
• VMware
• McAfee
Tufin Knowledge Center: [Link]/support/kc 9
Tufin™ Orchestration Suite (TOS) Developer's Guide
Tufin Orchestration Suite (TOS) REST API SecureTrack REST API Resources
supported models
The following values can be returned in the modelfield of the SecureTrack \devices REST
API.
CheckPoint:
• cp_clm - Check Point CLM
Cisco:
• router - Cisco Router IOS
Tufin Orchestration Suite (TOS) REST API SecureTrack REST API Resources
Juniper:
• netscreen - Juniper Netscreen
Palo Alto:
• Panorama_ng - Palo Alto Panorama in advanced mode
Tufin Orchestration Suite (TOS) REST API SecureTrack REST API Resources
Fortinet:
• fortimanager - Fortinet FortiManager in advanced mode (with ADOM)
Stonesoft:
• stonesoft_smc - Stonesoft Managament
Tufin Orchestration Suite (TOS) REST API SecureTrack REST API Resources
McAfee:
• mcafeeFW - McAfee Firewall
F5:
• bigip - F5 BigIP Top plugin
NewF5:
• new_bigip - F5 BigIP
BlueCoat:
• proxysg - BlueCoat ProxySG
Linux:
• iptables - Linux IPtables top plugin
VMware:
• nsx_manager - NSX manager
Amazon:
• aws_manager - AWS Account
Openstack:
• openStack_manager
• openStack_region
Tufin Orchestration Suite (TOS) REST API SecureTrack REST API Resources
Azure:
• azure_rm_manager
• azure_rm_vnet
virtual type
The virtual_type field is returned in the DetailedDeviceDTO when the device is part of a
hierarchy. For example, all management devices are part of a hierarchy, where the
management device is the parent of the child firewall devices it manages.
If the device being returned via the GET API call is not part of a hierarchy, the
virtual_type field will be empty. If the device being returned via the GET API call is part of
a hierarchy, the virtual_type field will contain one of the following:
Tufin Orchestration Suite (TOS) REST API SecureTrack REST API Resources
Tufin Orchestration Suite (TOS) REST API SecureTrack REST API Resources
• Cisco rules, also known as access control entries (ACEs), are attached to the firewall
itself or to a CSM through access lists (ACLs)
• Palo Alto, Fortinet, Juniper and Forcepoint (formerly McAfee) rules are attached to the
firewall itself (if monitored directly) or to a manager (such as Panorama, FortiManager,
NSM, SMC) through zone based policies
• AWS, Azure and OpenStack rules are attached to their platforms through Security
Groups
The collections of rules which are attached to devices are generally referred to as Bindings.
Rule resources will also have a bindings section, which describes how the rule is attached to
its management server or firewall.
Object IDs
REST resources are identified by their IDs. For example, /devices/<device-id>
identifies a specific device.
The ID of resources that are managed by TOS are persistent. For example, a device ID or a
ticket ID will not change once it has been created.
The ID of resources that are managed by the monitored devices (such as firewalls, routers, or
cloud platforms ) are not persistent, and may change each revision. For example, rule IDs
and network_object IDs are not persistent across revisions.
Domains
In some APIs, you can use the domain context parameter (context=2) to limit the results to
a specified SecureTrack domain.
For example, to get only the devices that are in domain 2, use:
[Link]
To find the domain ID, you can use the domains API to get a list of the domains.
Tufin Knowledge Center: [Link]/support/kc 16
Tufin™ Orchestration Suite (TOS) Developer's Guide
Tufin Orchestration Suite (TOS) REST API SecureTrack REST API Resources
This API is currently only supported for Palo Alto Networks firewalls and Fortinet devices
managed by FortiManager.
Application IDs
Retrieve information about Application Identities in Next-Generation firewalls. (For Palo Alto
Networks devices only.)
Change Authorization
Identify changes that were not authorized by a SecureChange ticket.
Domains
Manage SecureTrack domains. This is only relevant if multi-domain mode is enabled.
Tufin Orchestration Suite (TOS) REST API SecureTrack REST API Resources
IPsec VPN
Retrieve information about VPN settings for supported device types. (For Check Point and
Cisco devices only.)
Internet Objects
Manage the Internet object on devices that define this object.
Monitored Devices
Manage the devices that are monitored in SecureTrack.
NAT Policies
Retrieve NAT objects and rules for supported devices. Supported devices are Check Point,
Cisco, Juniper, Fortinet, Stonesoft.
Tufin Orchestration Suite (TOS) REST API SecureTrack REST API Resources
Network Objects
Retrieve network object data from devices.
Network Topology
Retrieve network topology data from devices.
Tufin Orchestration Suite (TOS) REST API SecureTrack REST API Resources
Policy Analysis
Identify rules that correspond to traffic flows.
Policy Optimization
Retrieve information about risky and sub-optimal policy configurations that can be cleaned
up.
Revisions
Retrieve the historical policy revisions from a specific device.
Rule Documentation
Manage the rule metadata associated with a policy revision.
Rule Usage
Retrieve information about last hit per rule, based on rule usage tracking that is monitored by
SecureTrack.
Tufin Orchestration Suite (TOS) REST API SecureTrack REST API Resources
Retrieve information about last hit per user and application inside For Palo Alto Networks
rules.
Security Rules
Retrieve security rules from both hardware devices and cloud platforms.
Time Objects
Retrieve the time object definition from supported devices.
Tufin Orchestration Suite (TOS) REST API SecureTrack REST API Resources
For complete details see Unified Security Policy - Access Request Violations
([Link]
1/securetrack/apidoc/#!/Unified_Security_Policy_Access_Request_Violations).
For complete details see Unified Security Policy - Cloud Tag Policy
([Link]
_Cloud_Tag_Policy).
For complete details see Unified Security Policy - Security Zone Matrix
([Link]
Tufin Orchestration Suite (TOS) REST API SecureChange and SecureApp REST API Resources
Access Portal
Manage requests for application access from the SecureApp application access portal.
Application Connections
Manage application connections in SecureApp.
Application Identities
Retrieve list of Next Generation application identities that can be used in SecureApp
application connections and SecureChange access requests.
Application Interfaces
Manage interfaces to SecureApp applications.
Tufin Orchestration Suite (TOS) REST API SecureChange and SecureApp REST API Resources
Application Migration
Copy (migrate) the application definitions to a new or existing application.
Application Packs
Manage SecureApp application packs.
Tufin Orchestration Suite (TOS) REST API SecureChange and SecureApp REST API Resources
Application Users
Manage application users in SecureApp.
Applications
Manage SecureApp applications.
Cloud Console
Manage the SecureApp Cloud Console. The Cloud Console lets you view AWS instances
and associate them with SecureApp applications.
Customers
Manage SecureApp customers. Customers are mapped to SecureApp domains.
Domains
Retrieve a listing of SecureTrack domains, which can be mapped to SecureApp domains.
Tufin Orchestration Suite (TOS) REST API SecureChange and SecureApp REST API Resources
Load Balancers
Retrieve a listing of F5 server pools that can be used in SecureApp connections.
SecureChange Devices
Manage which devices will be used in SecureChange access requests.
Server Decommissioning
Run and view the results of the automations tools available for server decommissioning.
System Configuration
Configure the SecureTrack server and account used by SecureChange and SecureApp.
System Users
Retrieve a listing of SecureChange and SecureApp users and user details.
Ticket Lifecycle
Reassign tickets, redo ticket steps, and retrieve ticket history.
Tickets
Manage SecureChange tickets.
General
To ensure forward compatibility of your integration with Tufin Orchestration Suite we
recommend that you:
• Do not directly access the internal PostgreSQL databases, for either retrieving or
modifying data
Group Members
When you retrieve a single network_object element or a single services element of the type
group, the API response includes all the group members. This also occurs when you retrieve
a list of network_objects or services and restrict the returned type to group.
To make more efficient API calls, set the optional show_members = false: The call will
return only the names and IDs of the members.
To maintain full backwards compatibility, the default value of the show_members parameter
is true.
Content Negotiation
Starting from R18-2, TOS is compliant with the REST API standard (JAX_RS) 2.1, which is
compliant with Java EE8
([Link] Compliance with the
updated standards requires supporting more strongly typed content negotiation in our REST
API. To prevent receiving HTTP error 415 (Unsupported Media Type) from the
server, the REST client must specify the correct Content-Type and the Java client must
provide the correct [Link].
Performance
SecureTrack APIs that are used often that return large amounts of data include:
• Get Rules
• Get USP violations - in devices with large amount of rules see Get Unified Security
Policy Violations
SecureChange APIs that are used often that return large amounts of data include:
• Get Tickets
If you are making many API calls serially that are data- or resource-intensive, we recommend
that you insert a 5-10 second sleep between the API calls.
• If you use pagination, you can make up to 10 concurrent API calls on a single data
retrieval
• If you are calling an API that returns a small amount of data (for example retrieving the
most recent policy revision on a device) you can make up to 10 concurrent API calls,
and retrieve the latest policy revision for 10 devices simultaneously
Response Time
REST API response time can be affected by many factors, including system characteristics
such number of cores and memory, as well as the amount of data in the TOS database and
the amount of data returned by an API call.
Indexed Data
For faster searching, TOS indexes commonly accessed data. The following APIs access
indexed data, and will therefore generally have a faster response time.
• Rule Usage
• Rule Search
Device Data
Device data (for example, security rules or network objects) is included in revisions that are
retrieved by TOS from the device. To make this data available, these revisions must be
parsed and added to the Policy Model Cache in the TOS database. Data that is stored in the
Policy Model Cache is readily available for fast retrieval by the APIs. All other data is stored
unparsed and must be parsed prior to becoming available from the Policy Model Cache. This
data will have a lengthier retrieval time.
Data regarding the latest policy revision for every monitored device is stored in the Policy
Model Cache. Therefore, API calls to the retrieve the latest revisions or device data will
generally have a faster response time. If a historical revision is accessed via the APIs, the
data for that policy will remain in the Policy Model Cache for a period of time.
The first API call to retrieve historical data about a device will parse and store all the data in
the Policy Model Cache, and will have a slower response time. Subsequent API calls to
retrieve other data for the same revision will have a faster response time.
• Security Rules
• NAT Policies
• Network Objects
• Time Objects
• Crypto Maps
• Application IDs
• Additional Parameters
We recommend that API calls to retrieve historical data should be made in the background,
or alert the user with a message (for example “Processing in progress. Please wait”) and
changing the cursor icon.
The APIs that trigger topology and policy analysis calculations are:
• Path finder
• Change Authorization
For example, to measure the actual amount of time it takes to retrieve all the rules for a single
device:
...
real 0m6.905s
user 0m0.030s
sys 0m0.050s
The results displayed in real 0m6.905s is the time it actually took for the server to return
the results. Repeat this ten times, and use the results to calculate the average response time.
Average response time can vary between API calls, so calculate the average response time
for each API you plan on using.
You can estimate response time for any commands that are relevant for your programming
requirements. For example, to determine the average response time to retrieve access
request violations, use the average response time from ten Access Request Violations API
calls. To determine the average response time to retrieve rules from a device, use the
average response time from ten Get Rules API calls. We recommend that you use devices
that contains many rules, so that your results will better model your environment.
Chapter 3
The APG uses configurable criteria to consolidate logs into rules. You can configure:
• When and how the APG generalizes multiple connections into whole networks or into
'Any' rules.
• Exclusions for rules that you do not want to include in the analysis.
After generating a policy, you should review it to make sure it isn't reflecting illegitimate traffic.
For example, a slow port scan or a generic botnet may have been active in the organization
and generating logs. In this case, configure the APG to ignore this traffic and generate a new
policy.
Because a rulebase generated by APG closely reflects actual traffic in an organization, this
rulebase is also useful for visualizing network traffic as a rulebase, even for purposes other
than actually replacing the firewall rulebase. For example, if you want to see all the traffic to
and from a specific subnet, you can configure a filter to analyze only logs to this subnet and
logs from this subnet, and automatically produce a rulebase that can be read as a list of
source-destination-service sets describing the traffic to and from the specified subnet.
Tufin Knowledge Center: [Link]/support/kc 34
Tufin™ Orchestration Suite (TOS) Developer's Guide
Hints: To get familiar with the APG CLI, we recommend that you:
• Start with a simple case, such as a permissive rule you want to review.
• Run APG several times changing one configuration parameter at a time to see the
impact in the results.
Set the min-net-size to 28, and run the APG CLI first with min-net-coverage of
90 and then with min-net-coverage of 10.
Consolidating Rules
The Automatic Policy Generator (APG) consolidates logs according to:
• Ports to Any: Logs with ports matching ports specified in the <ports_to_any> tag of
the APG configuration file will define rules with 'Any' destination. This is useful for
services with which users need to be able to access the entire internet.
For example, with the following values configured, network consolidation will be to the
largest possible network of which the logged traffic is at least 50%, as long as this
network's prefix length is not more than 24 bits (3 octets).
min_net_coverage 50
min_net_size 24
• Any Consolidation: Multiple sources or destination are generalized to 'Any', where the
values of the other field (destination or source) and of the service field are identical,
and the number of different sources or destinations is at least the configurable
any_threshold value. This value can be defined in the APG configuration file or in
the APG command.
Tufin Knowledge Center: [Link]/support/kc 35
Tufin™ Orchestration Suite (TOS) Developer's Guide
• The Check Point log collector (see "Getting Check Point Logs for Upload" below)
(st_apg_collect) to collect and filter Check Point logs so that you can limit Check
Point log collection by rule UID or action (drop/accept), and/or by policy package and/or
by gateway.
• The standard log file format (see "Getting Log Files for Upload" on page 39) that you
can prepare from any firewall log file.
If you create an APG job in SecureTrack, you can configure the job to collect logs directly
from the device so that you can analyze future traffic.
SecureTrack offers a simpler alternative method, using our st_apg_collect tool for
automatically collecting, standardizing, and filtering Check Point logs. The st_apg_collect
utility is included in the TOS installation and is typically run in the command line of your
SecureTrack machine. When using this tool, SecureTrack takes the logs for the specified
time frame from any relevant log files, filters and standardizes them, and generates an output
file in the required format for the APG.
You can limit log collection by rule UID or action (drop/accept), and/or by policy package
and/or by gateway. This can be useful for forensic purposes as well.
When using the output for an APG job in SecureTrack, if you want to filter the logs by rule
you must do that manually in the output before you send it to the APG. When using the
output for the APG CLI ([Link] you can filter the
output by rule and traffic pattern in the APG configuration.
Procedure
To collect and prepare Check Point logs for the APG:
1. Get the SecureTrack device ID for the monitored Check Point management server.
Click on the device in the SecureTrack device tree in Compare > Compare
Revisions, and type the letter t
2. Before collecting the logs, you can view a list of available log files, by running the
st_apg_collect utility on your SecureTrack machine:
where <mgmt_id> is the SecureTrack device ID for the monitored Check Point
management server or for the CLM that is associated with the monitored CMA..
File name: If the default naming has been used, the current file is named [Link], and
all other files are named according to the date and time they were closed.
File time: The date and time of the first log in the file.
where:
<output_file> is the path and filename for the generated log file.
<from_date> is the date (and optionally, time) from which to collect logs. This
value must be included in quote marks, and its format is:
yyyy-mm-dd [hh:mm:ss]
<to_date> is the date (and optionally, time) until which to collect logs. This value
must be included in quote marks, and its format is:
yyyy-mm-dd [hh:mm:ss]
--append indicates that the generated log file should be added to an existing log
file, if found, rather than overwrite it.
<log_file> is the name of a log file. The --log-file flag is used to limit log
collection to this log file.
<uid> is a rule UID, to limit log collection to logs generated by this rule.
--action=drop limits log collection to drop and reject actions. When this flag is
not used, log collection is limited to accept, authenticate, and encrypt actions
(unless the --rule-uid flag is used, in which case the logs for that rule are
collected, regardless of action).
<IP> is the primary IP address of a gateway. The --module-ip flag is used to limit
log collection to logs from traffic handled by this gateway.
--long-mode exports verbose data for each log record. This is needed for
historical rule usage.
1. Collecting the log files from the firewall for the desired time frame.
5. Identify and extract the relevant fields (source; destination; port; IP-protocol) in the logs.
6. Convert the field values to the standard format: source destination port IP-
protocol
For example:
[Link] [Link] 22 6
[Link] [Link] 53 17
st_apg_gen <parameters>
where <parameters> is a list of any of the below parameters, each parameter name
followed by =<value> . For example:
Input/output parameters:
• --input :A prepared log file (see "Collecting Log Files" on page 36).
• --output : A prefix for the output filename. The APG output phase (default: 5) and an
extension will be appended to the filename.
• --output-format : The format for the generated firewall policy. The value must be
one of the following:
txt
xml
html
• --min-net-size : An integer between 1 and 32, indicating the minimal subnet length
(in CIDR notation) that is allowed to be created by network consolidation.
• --any-threshold : An integer indicating the minimum number of traffic logs for Any
consolidation.
• Customize when and how the APG consolidates (see "Consolidating Rules" on page
35) multiple connections into whole networks or into 'Any' rules
• Specify the input file, and the output file and file format
You can define all of these options in the XML configuration file and specify that the APG
command use this configuration file. If you define any of these options directly as arguments
in the APG command, the CLI parameters override the definitions from the configuration file.
<conf>
<!--ports_to_any>
<port>80/6</port>
<port>443/6</port>
<port>21/6</port>
</ports_to_any-->
<log_filter>
<!--rule>
<source>
<subnet>[Link]/16</subnet>
<negate>0</negate>
</source>
<destination>
</destination>
<!--service>
<port>80/6</port>
<port>443/6</port>
</service>
</rule-->
</log_filter>
<network_consolidation>
<min_net_coverage>50</min_net_coverage>
<min_net_size>24</min_net_size>
<include_broadcast>1</include_broadcast>
<any_threshold>500</any_threshold>
</network_consolidation>
<io>
<input>[Link]</input>
<output>policy</output>
<output_format>html</output_format>
<out_phases>final</out_phases>
</io>
</conf>
Note: Some sections of the default configuration file are commented out. To enable these
features, remove the !-- and -- from the tags.
The APG configuration file is delimited by the <conf> tag, and contains these optional
sections:
• <ports_to_any> : Ports defined in this section, when found in logs, define output
rules with 'Any' destination. This is useful for services with which users need to be able
to access the entire internet. Each <port> tag should contain a value in the format:
Port#/IP-protocol# .
• <log_filter> : Each <rule> contains a traffic pattern, that when matched by a log,
causes that log to be analyzed by the APG. When no traffic patterns are defined, all
logs are analyzed.
<input> : A prepared log file (see "Collecting Log Files" on page 36).
<output> : A prefix for the output filename. The APG output phase (default: 5) and
an extension will be appended to the filename.
<output_format> : The format for the generated firewall policy. The value must
be one of the following:
• txt
• xml
• html
<out_phases> : This tag is for setting the level of analysis. 1 shows the rules with
hit counts on the flows, and 5 or final shows all of the APG analysis.
Chapter 4
Introduction to TOP
Tufin Open Platform (TOP) provides an API that lets SecureTrack monitor and track
configuration changes for devices that are not natively supported. With TOP, SecureTrack
can monitor any device's configuration that can be retrieved as a text file, including:
TOP monitoring requires a customized plugin, specific to the monitored device model. You
install the plugin in SecureTrack and SecureTrack uses the TOP plugin to retrieve
configuration text files from the device. The plugin defines how SecureTrack retrieves and
handles the configuration. The TOP plugin for each device type is a single .tgz file, which is
easily installed by a SecureTrack Administrator in the SecureTrack.
TOP plugins are created by Tufin and by other members of the TOP alliance, including
device members and Tufin customers. TOP plugins for Blue Coat ProxySG, F5 BIG-IP LTM,
and Linux iptables are preinstalled in SecureTrack. You can download other plugins from the
TOP plugins page of the Tufin website ([Link]
alliance/).
Note: Tufin does not provide support for plugins that are developed by members of the
TOP alliance.
For assistance in developing the TOP plugin, please feel free to contact Tufin support
(support@[Link]).
• Data Retrieval executable (see "Creating the Data Retrieval Executable" on page 51):
Contains code for connecting to the monitored device, retrieving the configuration, and
sending it to standard output in the required format.
• Graphic icon file (optional): SecureTrack displays the monitored device with this icon,
in Compare view, Devices page, and Status page. This graphic must be a 16x16 GIF,
and is recommended to be transparent.
• top_manifest.xml (see "Creating the top_manifest.xml File" on page 46): The primary
plugin file used directly by SecureTrack. It defines values for SecureTrack, such as the
Data Retrieval executable, plugin metadata, error messages, and the icon file, and
defines parameters to be used by the Data Retrieval executable.
• Runtime Files: Any files required by the Data Retrieval executable at runtime, such as
shared libraries for C/C++. SecureTrack comes with JVM 1.6 (for Java), so this does
not need to be included in the plugin.
• Additional files (optional): The main Data Retrieval executable can call these files.
• Readme file (see "Creating the Readme File" on page 52) (optional): A text file with
information important to the plugin end-user.
1. Create the top_manifest.xml file (see "Creating the top_manifest.xml File" on page 46).
2. Create the Data Retrieval executable (see "Creating the Data Retrieval Executable" on
page 51), and any additional files called by the main Data Retrieval file.
3. In addition to the above files, obtain any files required by the Data Retrieval executable
(see "Creating the Data Retrieval Executable" on page 51), and (optional) a 16x16 GIF
graphic icon file for SecureTrack to display for the monitored device.
4. Create the Readme text file (see "Creating the Readme File" on page 52) (optional).
5. Package all of the above files (see "Packaging the TOP Plugin" on page 52).
6. Test the plugin (see "Testing the TOP Plugin" on page 53).
The plugin can now be installed by SecureTrack administrators (see "Installing a TOP Plugin"
on page 53), after which they can monitor devices of the relevant type.
The above example can be copied from here to be used as a template file. The XML Schema
is documented in the [Link] file included in the TOP Developer's Package.
The top_manifest.xml file must consist of valid XML, and must contain the following sections,
under the root <plugin> tag:
• Plugin information: The following four mandatory tags. SecureTrack displays these
tags' values in the list of installed plugins:
<name>: A name for the plugin, which must be unique when installed in
SecureTrack. Tufin recommends the following naming convention:
<name>[Link].device_vendor.device_model</name>
<version>: A version number for the plugin, which should be incremented upon
changes to the plugin. The version number must be in the form [Link] .
For example:
<version>1.0</version>
<vendor>: The device vendor, such as Blue Coat or F5, with no spaces in the
name. This name appears in the device tree in Compare view and in the Devices
page.
For example:
<vendor>Blue_Coat</vendor>
<model>: The device type. This text will also appear in the SecureTrack device tree
in Compare view and in the Devices page.
For example:
<model>ProxySG</model>
<command>exe/configuration_retriever</command>
<protocols> (mandatory): A <protocol> tag for each protocol that can be used
for connecting to the device. SSH and Telnet are currently supported.
If more than one <protocol> tag are included, then when adding a device to
SecureTrack, the user will select which to use for the specific device.
For example:
<protocols>
<protocol>ssh</protocol>
<protocol>telnet</protocol>
</protocols>
There are six available optional parameters, each of which can be passed via
command line or via standard input. It is recommended for sensitive information
(such as password, enable password) to be passed via standard input rather than
command line.
Each parameter is delimited by the <param> tag, and contains a <value> tag,
which contains a variable prefixed with the $ sign. The <value> tag may be
preceded by a <key> tag, to pass a relevant flag to the executable, as required by
the executable. For example:
<param>
<key>-t<key>
<value>$timeout</value>
</param>
• Connection protocol: Where the protocol is selected per device when adding the
device in SecureTrack, define this parameter, as follows:
<param>
<value>$protocol</value>
</param>
• Device IP address: Use the $ip-address variable, which will be resolved to the
IP address configured in SecureTrack per device:
<param>
<value>$ip-address</value>
</param>
• Username for SecureTrack to log into the device: Use the $username variable:
<param>
<value>$username</value>
</param>
• Timeout: How long SecureTrack will wait for a response from device before
continuing, as configured in SecureTrack's Timing page. Use the $timeout
variable:
<param>
<value>$timeout</value>
</param>
<param>
<value>$password</value>
</param>
<param>
<value>$enable-password</value>
</param>
This section is delimited by the <error_codes> tag (note the plural: codes), and
contains an <error_code> (note the singular: code) tag for each error code that can
be returned by the Data Retrieval executable.
Error code 0 is reserved for success, and should not be defined here. It is also
recommended not to use error code 1, which is a default error code in many script
shells.
A <code> tag, containing an error code that can be generated by the Data Retrieval
executable, and
For example:
<error_codes>
<error_code>
<code>2</code>
</error_code>
<error_code>
<code>3</code>
<description>Connection Timeout</description>
</error_code>
...
</error_codes>
• <representation>: Contains the <icon> tag, which defines an icon graphic file.
SecureTrack displays the monitored device with this icon, in Compare view, Devices
page, and Status page. This graphic must be a 16x16 GIF, and is recommended to be
transparent. If no icon file is supplied, SecureTrack uses a default TOP icon.
For example:
<representation>
<icon>[Link]</icon>
Tufin Knowledge Center: [Link]/support/kc 50
Tufin™ Orchestration Suite (TOS) Developer's Guide
</representation>
The runtime environment for the Data Retrieval executable is Linux (Red Hat Enterprise
Linux, CentOS, or TufinOS). The executable must be compatible with this environment. If
necessary, required files should be included in the plugin.
For an Expect Data Retrieval executable, no additional runtime files are required.
• C/C++ executables should be developed with GCC 3.2.3, which all Tufin platforms
support. GCC 3.2.3 exists in Red Hat Enterprise Linux version 3.
• Other programming and scripting languages can be used, such as BASH and Python.
The executable file is defined by the top_manifest.xml file, in the command tag.
The executable should retrieve the configuration of the monitored device, and if necessary
convert it to text format.
The executable should add the following marker, followed by a line break, immediately
before the text to be read by SecureTrack:
=====config begin=====
The executable should add the following marker, followed by a line break, immediately after
the text to be read by SecureTrack:
=====config end=====
...
The executable should send the retrieved text, along with the Begin and End markers, to
standard output.
The executable should send an exit code 0 when successful. For other error codes, make
sure to define error messages in top_manifest.xml (see "Creating the top_manifest.xml File"
on page 46).
where
<plugin_name> is the desired name for the file being created, and
<filenames> is the list of files to be included, separated by spaces (do not include the
containing directory).
st_top_validator <plugin_filename>
The validation tool will examine the plugin and report the results.
The plugin is installed. You can now add devices of the relevant type, from the Devices
page.
Chapter 5
When you add a script, you select a workflow and a group of triggers that cause the script to
run. When a selected trigger happens, SecureChange attempts to run the script
asynchronously, up to a maximum of five times. If SecureChange does not succeed in
starting the script, a message is added to Settings > Message Board.
3. Copy the script to the SecureChange server, for example in: /usr/sbin
4. Verify that has execute permission for the tomcat user: chmod +x <script name>
If the script writes output, make sure that the tomcat user also has permission to write
to the /usr/sbin directory.
c. Enter a display name for the script and the full path to the script (for example,
/usr/bin/sc_send_mail).
d. Enter a display name for the trigger group, select the workflow that you want the
script to run on, and select the action that triggers the script (for example, close).
e. Click Save.
Now, the script runs every time a ticket is closed on that workflow.
#!/bin/bash
function parseXML() {
elemList=( $(echo $xmlFile | tr '\n' ' ' | XMLLINT_INDENT="" xmllint --format - |
/bin/grep -e "</.*>$" | while read line; do \
echo $line | sed -e 's/^.*<\///' | cut -d '>' -f 1; \
done) )
totalNoOfTags=${#elemList[@]}; ((totalNoOfTags--))
suffix=$(echo ${elemList[$totalNoOfTags]} | tr -d '</>')
suffix="${suffix}_"
parseXML
<head>
<meta http-equiv='Content-Type' content='text/html;
charset=UTF-8' />
</head>
<body>
<h2><u>Ticked Information</u></h2>
Ticket Subject: $ticket_info_subject <br/>
TicketID: $ticket_info_id <br/>
Ticket Requestor: $ticket_info_login <br/>
Priority: $ticket_info_name <br/>
</body>
</html>" > /tmp/t_$ticket_info_id.log
export MAIL_FROM="st@[Link]"
export MAIL_TO="guy@[Link]"
export MAIL_SUBJECT="Ticket Closed Notification"
export MAIL_CONTENT_LENGTH=1024
export REDIRECT_STATUS=1
export HTTP_HOST="[Link]"
export HTTP_HELO="SecureTrack"
export MAIL_PORT=25
export MAIL_EMBED=0
export MAIL_MHT=0
export MAIL_PDF=0
<name>Normal</name>
</priority>
<createDate>1301392380958</createDate>
<updateDate>1301586217732</updateDate>
<requester>
<id>3</id>
<login>1</login>
<display_name>1</display_name>
</requester>
<current_stage>
<id>9</id>
<name>Open Request</name>
<ticket_task>
<id>11</id>
<name>Default</name>
<handler>
<id>3</id>
<login>1</login>
<display_name>1</display_name>
</handler>
<ticket_field>
<name>text</name>
<TextAreaValue>
<id>143</id>
<value>1</value>
</TextAreaValue>
</ticket_field>
</ticket_task>
</current_stage>
<open_request_stage>
<id>9</id>
<name>Open Request</name>
<ticket_task>
<id>11</id>
<name>Default</name>
<handler>
<id>3</id>
<login>1</login>
<display_name>1</display_name>
</handler>
<ticket_field>
<name>text</name>
<TextAreaValue>
<id>143</id>
<value>1</value>
</TextAreaValue>
</ticket_field>
</ticket_task>
</open_request_stage>
<comment xsi:type="RedoCommentType"
xmlns:xsi="[Link]
<content>asdasdas</content>
<user>
<id>3</id>
<login>1</login>
<display_name>1</display_name>
</user>
</comment>
<comment xsi:type="RedoCommentType"
xmlns:xsi="[Link]
<content>aaaaaaa</content>
<user>
<id>3</id>
<login>1</login>
<display_name>1</display_name>
</user>
</comment>
<comment xsi:type="RedoCommentType"
xmlns:xsi="[Link]
<content>asdasd</content>
<user>
<id>3</id>
<login>1</login>
<display_name>1</display_name>
</user>
</comment>
</ticket_info>
Chapter 6
To do this, you associate each mailbox with a workflow. When SecureChange receives an
email in a mailbox, it opens the request in the associated workflow and moves the request to
the next step in the workflow.
1. Create an email account on your mail server where the requests will be sent.
2. Add an inbound mailbox in SecureChange that receives mail that is sent to the email
account.
When an email is received by the inbound mailbox, a ticket is opened in the selected
workflow and the email fields are copied to the ticket details:
Sender Requester
Body Description
Importance Priority
Date Sent Date Opened
Each workflow for which you let users open requests by mail must have its own email
account in the mail server. SecureChange connects to the mail server and gets mail from
these email accounts.
1. Make sure your mail server is configured in Settings > Mail, and click Test to make
sure the connection is successful.
2. Create a new email account in your mail server to receive requests by mail.
Note: If the active workflow is deleted or deactivated (in Workflows), the original
workflow will still be shown as the active workflow, but emails to the inbound
mailbox will not open requests.
9. Save.
SecureChange is ready to receive mail that is sent to the email account that you entered.
1. Create an email account on your mail server where the requests will be sent, for
example:
Username: need_access@[Link]
Password: password
• Username: Enter the username of the email account on your mail server, for
example: need_access@[Link]
• Password: Enter the password of the email account on your mail server, for
example: password
c. Click Test.
If the test fails, make sure that the details of your mail server are correct in Settings
> Mail, and that the username and password of the email account are correct.
d. Click Save.
opened in SecureChange and the date the email was sent is the Date Opened for the
request.
Appendix I
PATENTS
See (see [Link] - [Link] .
TRADEMARKS
Tufin, SecureChange, SecureTrack, Automatic Policy Generator, and the Tufin logo are trademarks of Tufin
Software Technologies Ltd.
All other product names mentioned herein are trademarks or registered trademarks of their respective owners.
Some TOP plugins include software developed by Terrapin Communications, Inc. and its contributors for
RANCID.
Design considerations for creating a Data Retrieval executable for a TOP Plugin include defining a clear protocol for connecting to devices, implementing robust error handling, specifying communication protocols like SSH or Telnet, and ensuring data output is correctly formatted with defined markers for SecureTrack processing. Additionally, incorporating runtime dependencies and creating efficient network communication sequences are critical .
The top_manifest.xml file is central in a TOP plugin architecture as it defines the parameters, commands, metadata, error messages, and other configuration necessities needed for SecureTrack to manage a specific device. This file's structure ensures that SecureTrack can correctly interact with the device using the plugin, making it a crucial component for extending device compatibility and functionality .
Rule resources in network management systems have a bindings section which describes their attachment to management servers or firewalls. This linkage ensures rules are correctly applied in managing network security configurations. Objects IDs that refer to these resources are persistent, meaning once created, they maintain their ID consistently, facilitating their tracking and management throughout their lifecycle .
In API queries, domain contexts (e.g., context=2) can restrict the scope of results to a specific domain, enhancing management of resources and security in multi-domain environments. This allows for precise querying and management of devices and configurations within the specified domain, minimizing resource overlaps and improving security posture .
NAT policies in Tufin Orchestration Suite support multi-vendor environments by being applicable to multiple device types, such as Check Point, Cisco, Juniper, Fortinet, and Stonesoft. This interoperability enables consistent NAT rule management and policy execution across different platforms and devices, ensuring unified security enforcement in diverse network infrastructures .
Testing and validating TOP plugins before deployment are crucial for ensuring plugin reliability and compatibility with SecureTrack. Using the TOP validation tool helps identify format errors, potential integration issues, and functionality limitations, reducing potential system disruptions and ensuring that network configurations are accurately monitored and managed .
The Unified Security Policy (USP) in Tufin Orchestration Suite plays a critical role in managing cloud environments by defining policies for AWS cloud tags, highlighting access request violations, and setting security zones. These features enable consistent policy enforcement across hybrid cloud environments, ensuring security standards are maintained regardless of the platform .
Application IDs in next-generation firewalls, especially in Palo Alto Networks, are pivotal for identifying and managing applications that traverse the network. They provide granular control over traffic by identifying applications irrespective of port, protocol, or encryption, enhancing security policies' effectiveness and specificity .
SecureTrack uses TOP plugins to extend its monitoring capabilities to devices not natively supported by integrating a custom plugin architecture. The plugins facilitate the retrieval and analysis of configuration data, allowing SecureTrack to monitor, compare, and report on network devices' configurations through a standardized process .
Non-persistent resource IDs, such as rule and network object IDs that change with each revision, can challenge tracking and auditing over time. Mitigation strategies include implementing intermediate systems that log changes or maintaining a change log of ID updates to ensure continuous reference integrity across revisions .