Fraser Scott
VP of Product
February 22, 2022

Introduction to the Open Threat Model standard

Introduction to the Open Threat Model standard

The Open Threat Model (OTM) standard is a generic and tool agnostic way of describing a threat model in a simple to use and understand format. It has been designed to allow greater connectivity and interoperability between threat modeling and other parts of the Software Development Lifecycle (SDLC) and cybersecurity ecosystem. Released under Create Commons, anyone can contribute or use the standard.

Threat modeling as a practice is evolving, and so must the technology that surrounds the practice. If you look at what happened with DevOps, the key to scaling the creation and management of infrastructure was a combination of culture changes as well as the commoditisation of infrastructure such as through cloud and Infrastructure as Code (IaC). Threat modeling will inevitably go through a similar shift, and this standard has been to facilitate that evolution. By leveraging existing design artefacts such as IaC, we can automate the threat modeling process, increasing the scalability and maturity of threat modeling as a result.

Key use cases for an open threat modeling standard include:

  • Easily supporting new sources of application and system design. Anyone can write and share parsers or other tools that take source formats such as CloudFormation, Visio, or Docker Compose files.
  • Exchange threat model data within the SDLC and cyber security ecosystem. Having threat models represented in a common format means being able to use that data through integrations.
  • Exchange between organisations. It would be a great outcome if open source projects or even commercial vendors were sharing threat models of their systems in a way that could be ingested and used by organisations adopting those systems.

In this article we’re going to take a close look at the specification and how IriusRisk implements and uses it to automatically create threat models from CloudFormation templates. For the full specification see the Open Threat Model project repository. To learn how to create a simple parser that generates OTM see How to create an OTM parser.

An overview of the OTM specification

It makes sense to start by looking at some key elements and features of the specification. The specification is written as YAML (or JSON) and is broken up into a number of high level objects:

  • otmVersion - The version of the specification used in the file
  • Project metadata - Name, identifier, description, owner of the thing you’re threat modeling
  • Representations - E.g. diagram, code, JIRA story, user interface
  • Assets - Things you care about, sensitive information. E.g. PCI or PII data
  • Components - Bits that make up the representation such as an EC2 instance or an API
  • Trustzones - The differing levels of security and trust. Internet vs Web vs App vs Data tier
  • Dataflows - How information and assets move around between components
  • Threats - The bad stuff, the things that can go wrong
  • Mitigations - The good stuff, probably requires you to do some work

There are few other interesting things to note about the specification:

  • Objects can have arbitrary “attributes”, use them however you like. E.g. custom IDs
  • It provides basic properties to capture essential risk information (CIA triad, trustzone ratings, CWEs, likelihood and impact)
  • Tags to help you classify or group different components etc.
  • X and Y positions can be provided for diagrammatic representations
  • Components and Trustzones can be arbitrarily nested


The project object contains metadata about the thing being threat modelled. The name and id fields are required, but other useful fields include a description, owner, and owner contact. You can use the attributes field to link your project to documentation hosted elsewhere or to the relevant asset in something like a CMDB.

 name: Test project
 id: test-project
 description: This is a test project for the OTM development
 owner: John Doe
   documentation: “http://mydocs/my-app-123”
   cmdbId: MyApp123


Any given system can be threat modeled in a number of different ways, and from a number of different perspectives. For example, you can threat model as system based on the cloud infrastructure, or you can threat model the functional elements of the application itself such as login, shopping cart, user comments etc. The OTM specification refers to these different perspectives as representations, and an OTM file can include one or more representations. An architecture diagram representation may have diagrammatic elements such as width and height, where as a code-based representation may have a source code repository and file line numbers.

Here we can see an example of an architecture diagram representation.

 - name: Architecture Diagram
   id: architecture-diagram
   description: This is a diagram of the project's architecture
   type: diagram
     width: 1000
     height: 1000
     platform: drawio
     unit: pixel

This is what a code representation might look like.

 - name: Application Code
   id: application-code
   type: code
     language: java
     platform: github
     vcs: git

Because an OTM file can include multiple representations, that means you can include the full threat model of a given application or system, from each of the different perspectives.

Trustzones are a core part of any threat model. They provide key context about how components within a threat model are expected to behave and where threats are going to have the biggest impact. If you’ve got a completely untrusted zone such as the Internet connected directly to a highly trusted zone such as a data tier, you may find that a simple configuration error could easily expose the sensitive data to the world. The OTM specification uses a trustRating property to describe the expected level of trust and security of the trustzones.

 - name: Internet
   id: internet
   description: This is the internet trust zone
     trustRating: 20
     representation: architecture-diagram
     id: internet-box-shape


Components are the building blocks of a threat model. They can include the architectural elements within system such as web servers, data bases, and firewalls. They can also include the functional elements with in a system such as the login page, a shopping cart, or an email sender.

Each component has a human readable name field, but also a type field. This type field helps to describe what type of object it is. For example, in a threat model you could have two different web services Web1 and Web2, both of the same web-service type. While they are different entities in the threat model itself, because they are the same type, we can expect similar threats and controls to apply to them.

Components also have a parent field. Typically this will be a trustzone, but a component can also be nested inside another component. For example, you may have a Rest API component inside an AWS EC2 instance component.

Tags are especially useful for components because they allow you to provide additional values that further describe the components in an arbitrary way. This can be useful for group or filtering.

 - name: Web Service
   id: web-service
   type: web-service
   description: Runs our web application
     trustZone: private
     - tomcat

Finally we’ll look at dataflows. These are the literal flows of data between components within a threat model. They can be network-level flows such as HTTP or DNS, or they can be higher level flows such as “user login” or “product search”. Of course, a data flow needs a source and a destination component. It can be unidirectional or bidirectional. And similar to components, tags can be used to provide additional context useful for grouping and filtering.dataflows:
 - name: Dataflow between webservice and mongo
   id: cc-store-in-db
   description: Credit card information being exchanged in between the web app and the database
   bidirectional: true
   source: web-service
   destination: customer-database
     - http
     - https

Using OTM with IriusRisk

IriusRisk has released an OTM API in version 4.1 of the product. This API allows you to provide an OTM file and IriusRisk will automatically build a full threat model using the rules engine an extensive library of components and risk patterns. The first release of the API supports trustzones, components, and dataflows. Threats and mitigations are already in the specification, and support for them in IriusRisk will be coming soon.

The rest of this article will focus on building a threat model in IriusRisk using OTM. We’ll start off with a simple HelloWorld OTM file created by hand in an IDE, and then we’ll build one from a CloudFormation template using the open source Startleft tool. For both of these examples, we’ll need to set a couple of environment variables used to connect with the API:

$ env | grep IRIUS


Here’s a very simple OTM file created by hand in an IDE. Yes, it’s that easy.

otmVersion: 0.1.0
 id: helloworld
 name: Hello World

 - name: Public
   id: 6376d53e-6461-412b-8e04-7b3fe2b397de
     trustRating: 10
 - name: Private Secured
   id: 2ab4effa-40b7-4cd2-ba81-8247d29a6f2d
     trustRating: 90

 - name: Client
   id: client
   type: generic-client
     trustZone: 6376d53e-6461-412b-8e04-7b3fe2b397de
 - name: REST Service
   id: rest-service
   type: rest-full-web-service
     trustZone: 2ab4effa-40b7-4cd2-ba81-8247d29a6f2d

 - name: Client to REST service
   id: client-to-rest
   source: client
   destination: rest-service
     - HTTPS

It has two trustzones, two components, and a dataflow. This file can be sent straight to the IriusRisk OTM API using a simple curl command:

curl -XPOST -H "api-token: $IRIUS_API_TOKEN" -F 'otmFile=@helloworld.otm' ''
{ "ref":"helloworld",
 "name":"Hello World",

Here is the threat model created by IriusRisk:


As you can see, because the rules engine has executed, it has automatically pulled in threats and countermeasures that would apply to this threat model:



Now let’s build a more complete threat model from a CloudFormation template. We will use the open source Startleft tool to parse the CloudFormation template into an OTM file, then we’ll upload that OTM file to the IriusRisk API. Finally we’ll look at the threat model created by IriusRisk as a result.

This code snippet shows a section of the CloudFormation template we’ll be using.  As you can see, the file uses Amazon's Elastic Container Service as well as a number of other resources such as CloudWatch alarms.

   Type: 'AWS::ECS::Service'
   DependsOn: ALBListener
       Ref: ECSCluster
     DesiredCount: '1'
           - Ref: PrivateSubnet
           - Ref: EcsSecurityGroup
       - ContainerName: simple-app
         ContainerPort: '80'
           Ref: ECSTG
       Ref: ECSServiceRole
       Ref: taskdefinition

Using the Startleft project we can parse it into OTM with a single command.

$ startleft parse --type CloudFormation --map default-cloudformation-mapping.yaml --name "ECS Example" --id ecs-example --otm ecs-otm.yaml ecs.yaml
Writing threat model to 'ecs-otm.yaml'

The mapping file provided describes how to find resources in a CloudFormation Template, and how to map them into an OTM threat model. This gives us an OTM file which look something like:

 "otmVersion": "0.1.0",
 "project": {
   "name": "ECS Example",
   "id": "ecs-example"
 "components": [  
     "id": "1926dedc-c0e8-4539-b304-4fa359d9eeb9",
     "name": "service",
     "type": "elastic-container-service",
     "parent": {
       "component": "36f7c768-b05d-48b8-880f-da9bdaf41258"
     "tags": [
     "id": "4ec0399f-8594-4bb3-9ee8-965153c07d33",
     "name": "taskdefinition",
     "type": "docker-container",
     "parent": {
       "component": "1926dedc-c0e8-4539-b304-4fa359d9eeb9"
     "tags": [

We can now upload this OTM to IriusRisk using Startleft.

$ startleft threatmodel ecs-otm.yaml
Uploading OTM files and generating the IriusRisk threat model
Validating OTM file
OTM file is valid
OTM file has consistent IDs

Logging in to IriusRisk we can see it has built a full threat model. This isn’t just a visualisation of all of the resources in a CloudFormation template. What we can see here is an architectural view of the cloud infrastructure.



The Open Threat Model standard gives us a flexible way to describe threat models which can be used throughout the SDLC and cybersecurity ecosystem. It’s simple enough to be able to create threat models by hand, and powerful enough to represent full threat models generated from Infrastructure as Code.