Authentication

import java.io.*;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.text.SimpleDateFormat;
import java.text.DateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;
import java.util.UUID;
import javax.crypto.Cipher;

public class CreateAccessToken {

    private static final String[] helpLines = {
        "Usage: CreateAccessToken <Certificate file path> <API Key> <Absolute time>",
        "Certificate file path: .cer as downloaded from https://service.pcibooking.net/api",
        "API Key: As generated in your PCI Booking account",
        "Absolute time: local time in format HH:MM:ss (up to 1 hour from now), e.g: 18:20:34"
    };

    public static void main(String[] args) {
        if (args.length != 3) {
            Usage("Invalid number of arguments; expected 3");
        }

        Certificate cert = null;
        try {
            InputStream fis = new FileInputStream(args[0]);
            BufferedInputStream bis = new BufferedInputStream(fis);
            CertificateFactory cf = CertificateFactory.getInstance("X.509");
            cert = cf.generateCertificate(bis);
        } catch (Exception ex) {
            Usage("Cannot load certificate file: " + args[0] + " Error: " + ex);
        }

        Date expectedExpirationLocalTime = null;
        Date date = new Date();
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
        String cDate = formatter.format(date);
        formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            expectedExpirationLocalTime = formatter.parse(cDate + " " + args[2]);
        } catch (Exception ex) {
            Usage("Invalid expected time: " + args[2] + " Error: " + ex);
        }

        Calendar cal = Calendar.getInstance();
        long expiresIn = expectedExpirationLocalTime.getTime() - cal.getTime().getTime();
        if (expiresIn > 3600000 || expiresIn < 0) {
            Usage("Invalid expected time [" + args[2] + "]. Should be up to one hour ahead ");
        }

        formatter.setTimeZone(TimeZone.getTimeZone("UTC"));
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
        df.setTimeZone(TimeZone.getTimeZone("UTC"));
        String asISO8601 = df.format(expectedExpirationLocalTime);

        String guid = UUID.randomUUID().toString().replace("-", "");
        String dataBlock = String.format("%1$s#%2$s#%3$s", args[1], guid, asISO8601);

        byte[] clearBytes = null;
        try {
            clearBytes = dataBlock.getBytes("UTF-8");
        } catch (Exception ex) {
            Usage("Cannot encode to UTF8: Error: " + ex);
        }

        byte[] encryptedBytes = null;
        try {
            final Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, cert.getPublicKey());
            encryptedBytes = cipher.doFinal(clearBytes);
        } catch (Exception ex) {
            Usage("Cannot encrypt: Error: " + ex);
        }

        String accessToken = byteArrayToHex(encryptedBytes);
        System.out.println(accessToken);
    }

    private static void Usage(String message) {
        if (!message.isEmpty()) System.out.println(message);
        for (String line : helpLines) System.out.println(line);
        System.exit(0);
    }

    private static String byteArrayToHex(byte[] a) {
        StringBuilder sb = new StringBuilder(a.length * 2);
        for (byte b : a) sb.append(String.format("%02X", b & 0xff));
        return sb.toString();
    }
}

<?php

require('vendor/autoload.php');

class CreateAccessToken
{
    private $certificate;
    private $apiKey;
    private $expirationTime;

    public function __construct($certificate, $apiKey, DateTime $expirationTime)
    {
        $this->certificate = $certificate;
        $this->apiKey = $apiKey;
        $this->expirationTime = $expirationTime;
    }

    public function createToken()
    {
        $cert = openssl_get_publickey($this->certificate);

        $this->expirationTime->setTimeZone(new DateTimeZone('UTC'));
        $expirationAsISO8601 = $this->expirationTime->format(DateTime::ISO8601);
        $guid = $this->generateUUID();
        $dataBlock = sprintf('%s#%s#%s', $this->apiKey, $guid, $expirationAsISO8601);

        openssl_public_encrypt($dataBlock, $encryptedData, $cert);
        $encryptedDataHex = strtoupper(bin2hex($encryptedData));

        return $encryptedDataHex;
    }

    private function generateUUID()
    {
        return str_replace('-', '', Ramsey\Uuid\Uuid::uuid4());
    }
}

import binascii
import uuid
import pytz

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.x509 import load_pem_x509_certificate


def create_access_token(cert_file, api_key, expiration_time):
    cert = load_pem_x509_certificate(cert_file.read(), default_backend())
    public_key = cert.public_key()

    try:
        expiration_time = pytz.utc.localize(expiration_time)
    except ValueError:
        pass

    expiration_string = expiration_time.isoformat()
    data_block = '{}#{}#{}'.format(api_key, uuid.uuid4(), expiration_string)
    ciphertext = public_key.encrypt(data_block, padding.PKCS1v15())

    return binascii.hexlify(ciphertext)


def main():
    import datetime
    import sys

    if len(sys.argv) != 4:
        print("Usage: {} cert_file api_key expiration_timestamp".format(sys.argv[0]))
        exit(1)

    with open(sys.argv[1], "rb") as cert_file:
        expiration_time = datetime.datetime.fromtimestamp(int(sys.argv[3]))
        print(create_access_token(cert_file, sys.argv[2], expiration_time))


if __name__ == '__main__':
    main()