Setup a Connector

import base64
import json
import settings
from jwt.algorithms import RSAAlgorithm

# List of supported headers, and if they're required or not.
SUPPORTED_HEADERS = {
    'X-Pot-Signature': {
        'required': True
    },
    'X-App-Token': {
        'required': True
    },
    'X-User-Token': {
        'required': False
    }
}

# Get the request headers from the request object.
headers = dict()
# Get the body from the request json body.
body = dict()

# Keep the Platform of Trust public key e.g. in the settings.
public_pem = settings.POT_PUBLIC_KEY

# Loop through the request headers and validate them.
for header, rules in SUPPORTED_HEADERS.items():
    header = header.lower()
    if rules['required'] and header not in headers:
        raise Exception(
            f'Missing required header "{header}"'
        )

# Convert the request body to a string, sorting the keys, without 
# indentation and using separators comma (,) and colon (:)
payload_string = json.dumps(
    body,
    sort_keys=True,
    indent=None,
    separators=(',', ': ')
).strip()

alg_obj = RSAAlgorithm(RSAAlgorithm.SHA256)  # RSA SHA256 signature
key = alg_obj.prepare_key(public_pem)
# Verify the payload and signature against the Platform of Trust public 
# key
is_valid = alg_obj.verify(
    payload_string.encode('utf-8'), 
    key, 
    base64.b64decode(headers['X-Pot-Signature'].encode('utf-8'))
)
if not is_valid:
    raise Exception('Signature validation failed')

{
  "@context": "https://standards.oftrust.net/v2/Context/DataProductParameters/Sensor/?v=2.0",
  "timestamp": "2020-02-10T14:36:25+00:00",
  "productCode": "unique-product-code",
  "parameters": {
    "ids": [
      {"id": "apartament1"}
    ],
    "dataTypes": ["MeasureAirTemperatureCelsiusDegree"]
  }
}

{
    "@context": "https://standards.oftrust.net/v2/Context/DataProductOutput/Sensor/?v=2.0",
    "data": {
        "sensors": [
            {
                "id": {"id": "apartament1"},
                "measurements": [
                    {
                        "@type": "MeasureAirTemperatureCelsiusDegree",
                        "timestamp": "2020-02-10T13:29:03+00:00",
                        "value": 26.0,
                    },
                    {
                        "@type": "MeasureAirTemperatureCelsiusDegree",
                        "timestamp": "2020-02-10T13:59:38+00:00",
                        "value": 25.0,
                    },
                    {
                        "@type": "MeasureAirTemperatureCelsiusDegree",
                        "timestamp": "2020-02-10T14:30:11+00:00",
                        "value": 26.0,
                    },
                ],
            },
        ]
    },
    "signature": {
        "created": "2020-02-10T14:36:40+00:00",
        "creator": "https://example.com/public-key",
        "signatureValue": "eyXDfjefphhfwe...gwrg+wgr0==",
        "type": "RsaSignature2018",
    },
}

import base64
import json
import settings
from copy import copy
from datetime import datetime, timezone
from jwt.algorithms import RSAAlgorithm

# This is the private key matching the `creator` public key.
private_pem = settings.PRIVATE_KEY

# Get the created_at timestamp in RFC3339 format
created_at = str(datetime.now(timezone.utc).isoformat(timespec='seconds'))

# The data contains the actual data to return to the application.
data = {
    "@context": "https://standards.oftrust.net/v2/Context/Identity/Space/Apartment/",
    "apartmentId": 123456,
    "name": "A 18",
    "rooms": "4",
    "balcony": True
}

# Make a copy of the data, and add the __signed__ key to it
sign_data = copy(data)
sign_data['__signed__'] = created_at

# Create a string of the data, sort the keys, without indentation and 
# separators comma (,) and colon (:)
payload_hash = json.dumps(
    sign_data,
    sort_keys=True,
    indent=None,
    separators=(',', ': ')
).strip()

alg_obj = RSAAlgorithm(RSAAlgorithm.SHA256)  # RSA SHA256 signature
key = alg_obj.prepare_key(private_pem)
signature = alg_obj.sign(payload_hash.encode('utf-8'), key)

# Base64 encode the signature value and use it in the response
# `signatureValue`
signature_value = base64.b64encode(signature).decode("utf-8")