trellisfw-masklink

Library for performing Trellis Mask & Link operations. See below for an overview.

Basic Usage

import ml from '@trellisfw/masklink'
// You can make a private JWK key with https://github.com/oada/oada-certs
import privateJWK from './private_jwk.json'

let url = 'https://my.trellis.domain/resources/123';
const paths = [ 'organization/location', 'scope/organization/location' ];
const token = 'mydummytoken';
const signer = { name: "Sam I Am", url: "https://domain.com" };

const maskedResourceid = await ml.maskAndSignRemoteResourceAsNewResource({url, privateJWK, signer, token, paths});
console.log('The new masked resourceid at the remote URL is: ', maskedResourceid);


url = `https://my.trellis.domain/${maskedResourceid}` 
const { trusted, unchanged, valid, match, original, details } = await ml.verifyRemoteResource({url, token});
console.log('The remote resource was trusted? ',trusted, ', unchanged? ', unchanged, ', valid? ', valid, ', match? ', match);

Overview

When you have information in a JSON document that you do not want to share with someone, but you need to share the rest of the document, you can replace the sensitive information with a auditable trellis-mask.

In addition to replacing the original information, you can sign the document as an added layer of trust. The signature contains information about which keys were masked, allowing anyone with access to the unmasked original to verify both the signatures and the masks whenever an audit is necessary.

For example, if this is your unmasked document:

{
  phone: "999-999-9999",
  location: { // This location is sensitive information
    street_address: "123 Nowhere Lane",
    city: "Nowhere",
    state: "FL",
    zip: "99999"
  }
}

And you want to mask the location key, the masked version would look like:

{ 
  phone: "999-99-9999",
  location: {

    // See the contents here have been replaced by an object with a hash and a link:
    "trellis-mask": {
      version: "1.0",
      hashinfo: {
        alg: "SHA256",
        hash: "02fjkdofj213oikjwdo0fi2jfpiwjsdc029u3f0923uj23oiesls",
      },
      "url": "https://some.trellis.domain/resources/the_original_resourceid/location",
      "nonceurl": "https://some.trellis.domain/resource/the_original_resourceid/_meta/nonce",
    },
  },

  // A trellisfw-signature can be applied during masking to add another layer of trust
  signatures: [
    "ejfkdo9fk234.k0f2jik2lfjafwe9oifjlwjhqi3fwlakefjaowkefu02ijfklsafjwasdf.dkfj23",
  ],
}

API for Masked Objects (not full documents)

`mask({ original, url, nonce, nonceurl })` synchronous

original: required: the object to be hashed and masked
url: required: the remote URL where this object would be found at a Trellis domain, including the path to this object inside a resource.
nonceurl: required: the URL where the nonce can be retrieved by someone trying to validate this hash later.
nonce: optional: if you don't pass a nonce, one will be created for you. Note you have to save it somewhere... Note this function makes no outside requests, it only creates the mask.

Returns { nonce, nonceurl, mask }

const { nonce, nonceurl, mask } = mask({original, url, nonceurl});
console.log('Mask = ', mask);
// { trellis-mask: { version: "1.0", hashinfo: { alg: "SHA256", hash: "02ijd0fijk2lfwd" }, nonceurl, url } }

`verify({mask, original, nonce})` synchronous

mask: required: the masked object to be verified
original: required: the original unmasked object to hash and compare with the mask
nonce: required: the nonce used to create the original mask Note: this function makes no outside requests, it only validates based on what it is given.

Returns { valid, match, details }

valid: true|false: true if mask, original, and nonce have valid forms, but says nothing about whether they match.
match: true|false: true if hash inside mask matches original w/ nonce.
details: array: array of strings about the matching process to aid in debugging

`async verifyRemote({mask, token, connection})`

Given a mask, retrieve the original at mask.url and the nonce at mask.nonceurl and then pass to verify

mask: required: the original masked object to be validated against it's internal remote URL's
token: optional: the token to use when connecting to the remote URL
connection: optional: a pre-existing oada-cache connection to the remote URL NOTE: you must pass either a connection or a token so the function can make the necessary requests.

Returns { valid, match, original, nonce, details }

valid: true|false: true if mask, original, and nonce have valid forms, but says nothing about whether they match.
match: true|false: true if hash inside mask matches original w/ nonce.
original: the original unmasked object that was retrieved from mask.url
nonce: the nonce that was retrieved from mask.nonceurl
details: array: array of strings about the matching process to aid in debugging

API for Full Documents Containing Masks

`maskResource({ resource, urlToResource, paths, nonce, nonceurl })` synchronous

Given an entire JSON document, use the list of json-pointer paths to mask some of its contents.

resource required: the original resource to be masked
urlToResource required: where this resource was stored, to be used in the mask url's
paths required: array of json-pointer paths to mask within this resource (i.e. [ 'organization/location' ])
nonce optional: nonce to use in hashing. If you don't pass it, one is created.
nonceurl optional: where the nonce will be stored. Assumed <urlToResource>/_meta/nonce if not passed. NOTE: this function is entirely local, it makes no outside requests.

Returns { nonce, resource, nonceurl }

nonce: the nonce used (either passed or created)
resource: the final resource after masking the paths
nonceurl: the nonceurl to store the nonce (either passed or created)

async `signResource({resource, privateJWK, header, signer, paths})`

Creates a mask-type signature on a resource using the trellisfw-signatures.

resource: A resource that has already had masks applied to it that correspond to paths.
privateJWK: A JWK that is the private key used to create the JWT signature
header optional: any additional headers to pass to trellisfw-signatures
signer optional: Object describing who is signing. Looks like { name: "The Signing Company", url: "https://domain.com" }
paths optional: Array of json-pointer paths that were masked in resource corresponding with this signature.

Returns resource (a new copy of the resource with the signature added)

async `maskRemoteResourceAsNewResource({url, paths, token, connection, signatureCallback})`

url required: The URL where the original resource to mask can be found
paths required: List of json-pointer paths into the original resource that should be signed.
token or connection required: Pass either a token or an oada-cache connection to use in getting the original and putting back the mask.
signatureCallback optional: If you want to apply a signature after masking, pass it here and it will be called after masking before creating the new masked resource at the remote URL.

Returns newResourceid (the ID of the new resource on the remote cloud, looks like resources/02ikefj092jlkdss)

async `maskAndSignRemoteResourceAsNewResource({url, privateJWK, signer, token, connection, paths})`

Given a remote URL, make a masked copy, sign it with the given key, and put it back to the remote cloud. Mostly a wrapper for maskRemoteResourceAsNewResource and signResource. Refer to signResource and maskRemoteResourceAsNewResource for an explanation of the parameters.

Returns newResourceid (the ID of the new resource on the remote cloud, looks like resources/02ikefj092jlkdss)

async `verifyRemoteResource({url, token, connection})`

Given a remote URL for a masked resource, get it, reconstruct it from the signatures, and verify every masked object along the way. Note this will verify all signatures present on the document, not just the last one.

url required: URL of the remote masked resource that you want to verify
token or connection required: Pass either a token or an oada-cache connection to use in getting the mask and the original. Note that currently it uses the same for both the mask and original. Future feature add would be to allow those to be different.

Returns { trusted, unchanged, valid, match, original, details }

trusted: true|false: Same as the trusted return value from trellisfw-signatures. Indicates that the signature came from a key that is represented on the trusted list.
unchanged: true|false: true if the reconstruction matches the signatures (i.e. it was unchanged since signing)
valid: true|false: true if all the signtures and all the masks they reference in the document have valid forms. Does not tell you if they are unchanged or if the masks match the original.
match: true|false: true if all masks mentioned in signatures match their originals
original: the full original resource, reconstructed from the signatures and mask originals
details: array of strings with messages about the verification process, useful for debugging.

Exposed Helper Functions

`isMask(obj)` synchronous

Returns true if obj has all the appropriate keys to be a trellis-mask.

`domainForMask(mask)` synchronous

Returns the domain portion of the url found within the mask. Note that it ignores the nonceurl.

`findAllMaskPathsInResource(resource)` synchronous

Returns an array of json-pointer strings, containing every path whose value returns true for isMask() within the passed resource

const paths = findAllMaskPathsInResource(resource);
console.log(paths);
// [ 'organization/location', 'scope/organization/location' ]

trellisfw/trellisfw-masklink

trellisfw-masklink

Basic Usage

Overview

API for Masked Objects (not full documents)

mask({ original, url, nonce, nonceurl }) synchronous

verify({mask, original, nonce}) synchronous

async verifyRemote({mask, token, connection})

API for Full Documents Containing Masks

maskResource({ resource, urlToResource, paths, nonce, nonceurl }) synchronous

async signResource({resource, privateJWK, header, signer, paths})

async maskRemoteResourceAsNewResource({url, paths, token, connection, signatureCallback})

async maskAndSignRemoteResourceAsNewResource({url, privateJWK, signer, token, connection, paths})

async verifyRemoteResource({url, token, connection})