-
Notifications
You must be signed in to change notification settings - Fork 1
The Trust Policy Authoring Process
This page is part of the TPAT User Guide.
The Trust Policy Authoring Tool (TPAT) is an open source software tool for developing, publishing, and managing information sharing trust policy requirements using the trustmark framework. If you are the author of an information sharing trust policy, the TPAT can handle the tedious task of turning your trust policy content into trustmark definitions (TDs) and trust interoperability profiles (TIPs) that conform to the Trustmark Framework Technical Specification (TFTS). This page provides a high-level overview of the process that you will follow when authoring an information sharing trust policy.
Before we discuss the process of authoring a trust policy, let's discuss the roles that the TPAT plays in the process using some simple analogies to concepts that you already know.
You can think of the TPAT as playing two roles in the trust policy authoring process: it is a compiler and a web server for information sharing trust policies.
When you develop a software application, you write source code. When your code is ready to be compiled, the compiler will process it, checking it for syntax errors and other problems. If no errors are found, the compiler will generate an executable program that you can run on your computer. In many cases, the compiler will also link your program to existing libraries that perform various functions. The executable object is machine-readable, i.e., it conforms to a data standard that allows it to be processed and interpreted reliably on a specific computer archiecture or within a specific runtime environment.
A software developer typically compiles the source code of an application many times during the development process, testing and improving the quality of the code in an iterative fashion. A compiler plays a critical role in the software development process, but there are many things that a compiler cannot do for a software developer. For example, a compiler cannot tell the developer how an application should behave, or what features it should have. A compiler also cannot detect many types of semantic errors in an application. These creative tasks are beyond the scope of a compiler. They constitute the art of software development.
When you develop an information sharing trust policy, the TPAT plays a role similar to that of a compiler. You can express your policy using a "source code" format that the TPAT understands. The TPAT can check your policy for syntax errors, and if no errors are found, it can generate artifacts that represent your policy in a standard machine-readable format. But it cannot design or develop the policy for you. That's your job! 🙂
After your trust policy has been compiled into the trustmark framework's standard format, you will need to make it available online so that people and software tools can see it, read it, download it, and use it. The TPAT makes this easy to do by giving you the ability to "publish" your policy quickly and easily using its built-in web server. As long as your TPAT is deployed at a public-facing URL, others will be able to access it and view your policy.
Now that you have a better idea of how the TPAT fits into the trust policy authoring process, let's discuss this process.
If you want to develop an information sharing trust policy and publish it using the trustmark framework, you need to follow these basic steps.
What information sharing use cases must your trust policy cover? For example, in the public safety community, you may need to support use cases such as the following:
- Access to Criminal Justice Records on
Named Systemby a Sworn Law Enforcement Officer from an Agency inNamed State - Access to
Named Chat ChannelonNamed Chat Applicationby a First Responder - Access to Real-Time Police Vehicle Location Data on
Named Mapping Application
TIP: When identifying information sharing use cases for your organization, consider two basic use case categories:
- Use cases in which your systems or personnel will access systems and information provided by a partner
- Use cases in which a partner's systems or personnel will access systems and information provided by you
For each information sharing use case that you identified in the previous step, determine what policy requirements are applicable to it. As a general rule, you should consider requirements in the following areas:
- Organizational Legitimacy and Purpose: type of agency, location of agency, etc.
- Cybersecurity Controls: confidentiality, integrity, availability, etc.
- Identity Assurance: user vetting, credential issuance, credential strength, etc.
- Data Privacy: notice, consent, etc.
- Technical Interoperability: required protocols, data standards, etc.
- Access Control Rules: fine-grained access rules based on attributes asserted about an individual
As you build the list of policy requirements for each use case, it is important that you keep track of the policy source for each requirement. For example:
- U.S. government agencies typically must implement security controls based on NIST Special Publication 800-53.
- Organizations in the U.S. that maintain or share criminal justice information (CJI) must comply with the FBI Criminal Justice Information Services (CJIS) Security Policy.
- Organizations in the U.S. that deal with personal health information (PHI) are subject to the HIPAA Security Rule and the HIPAA Privacy Rule.
One of the cornerstone characteristics of the trustmark framework is that it promotes the reusability of trust policy fragments. Your trust policy can incorporate parts of other trust policies that were previously published by your organization, or by some other publisher. And as you will discover later in this user guide, building your trust policy from pre-existing components is easy to do.
For now, you should become familiar with existing trustmark framework trust policy content that you may be able to reuse in your trust policy. There are several resources online where you can find this content, including the following:
- Trustmark Initiative Policy Content Library – This is the most comprehensive library of trustmark framework trust policy content available today. It contains thousands of TDs and TIPs, and it includes requirements from a large number of well-known trust policy sources. For a complete list of policy sources that are represented in this library, please see this page.
- SAFECOM/NCSWIC Library of Public Safety ICAM Policy Artifacts – This library contains TDs and TIPs developed jointly by the SAFECOM and NCSWIC communities for the benefit of the public safety community. It contains recommended trust policy profiles for various public safety information sharing use cases.
If you have completed all of the prior steps on this page, then you are ready to begin writing your policy in the "source code" format that the TPAT can understand and process. That topic is covered on the next page of this user guide. Use the link below when you are ready to go there.
Previous: Deploying a TPAT | Next: Authoring Trust Policy Content with a TPAT Authoring Template
This content was developed by the Georgia Tech Research Institute under the Trustmark Initiative.