Skip to content

One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.

9.4 KB
Raw Blame
"""Experimental committed SAS pairing; see docs/spec-easy-pair-1.6.md before release."""

from __future__ import annotations

import hashlib
import hmac
import json
import secrets
import time

from nacl.bindings import crypto_scalarmult_base

from . import pairing as p

PAIR_MODES = ["cpace_v3", "sas_v1"]
EASY_TYPES = frozenset(("easy_commit", "easy_reveal", "easy_proof", "easy_approve"))
DOMAIN = b"beamer-sas-v1/"
WINDOW_SECONDS = 60.0


def canonical(value):
    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("ascii")


def window_ok(value):
    return isinstance(value, str) and len(value) == 32 and all(c in "0123456789abcdef" for c in value)


def eligible(machine):
    return (machine.get("pair_modes") == PAIR_MODES and window_ok(machine.get("nearby"))
            and p._id_text_ok(machine.get("id")) and p._name_ok(machine.get("name"))
            and p._platform_ok(machine.get("platform")) and p._port_ok(machine.get("port"))
            and machine.get("port") != 0)


class EasyPairWindow:
    def __init__(self, name, identity, platform, port, *, clock=time.monotonic, entropy=secrets.token_bytes):
        p._check_own(identity, platform, port)
        self.clock = clock
        self.deadline = clock() + WINDOW_SECONDS
        self.window = entropy(16).hex()
        self._scalar = entropy(32)
        self._nonce = entropy(32)
        self._own = {"nearby": self.window, "id": p._b64(identity), "name": name[:p.MAX_NAME_CHARS],
                     "platform": platform, "port": port, "pair_modes": PAIR_MODES.copy()}
        self.peer = None
        self.reveal = None
        self.remote_commit = None
        self.remote_reveal = None
        self._commit = None
        self._digest = None
        self._proof_key = self._approval_key = None
        self._state = "searching"
        self._sas = self.token = None
        self.local_approved = self.remote_approved = self.remote_proved = False

    @property
    def state(self):
        if self.clock() >= self.deadline:
            if self._state not in ("paired", "refused", "inactive", "not_saved", "expired"):
                self.cancel("expired")
            elif self._state == "paired":
                self._forget()
        return self._state

    @property
    def seconds_left(self):
        return max(0, int(self.deadline - self.clock() + 0.999))

    @property
    def active(self):
        return self.state in ("searching", "exchanging", "confirm", "waiting")

    @property
    def sas(self):
        return self._sas if self.state in ("confirm", "waiting") else None

    @property
    def attempt(self):
        return ":".join(sorted((self.window, self.peer["nearby"]))) if self.peer else None

    @property
    def ready(self):
        return self.active and self.remote_proved and self.local_approved and self.remote_approved

    def offer(self, address, reply_port):
        return {**self._own, "address": address, "reply_port": reply_port, "pairing": p.PAIRING_V3}

    def select(self, machine):
        if self.state != "searching" or not eligible(machine):
            raise p.PairingError(p.ERROR_VERSION if not eligible(machine) else p.ERROR_REFUSED)
        if machine["nearby"] == self.window or machine["id"] == self._own["id"]:
            raise p.PairingError(p.ERROR_REFUSED)
        self.peer = {key: machine[key] for key in (*self._own, "address", "reply_port")}
        self.reveal = {**self._own, "to": self.peer["nearby"], "share": p._b64(crypto_scalarmult_base(self._scalar)),
                       "nonce": p._b64(self._nonce)}
        self._commit = hashlib.sha512(DOMAIN + b"commit\0" + canonical(self.reveal)).digest()
        self._state = "exchanging"

    def _message(self, kind, **fields):
        return {"type": kind, "from": self.window, "to": self.peer["nearby"], **fields}

    def messages(self):
        state = self.state
        if self.peer is None or state in ("inactive", "refused", "expired", "not_saved") or self.clock() >= self.deadline:
            return []
        messages = [self._message("easy_commit", commit=p._b64(self._commit))]
        if self.remote_commit is not None:
            messages.append(self._message("easy_reveal", reveal=self.reveal))
        if self._digest is not None:
            messages.append(self._message("easy_proof", tag=p._b64(self._tag("proof", self.window))))
        if self.local_approved:
            messages.append(self._message("easy_approve", tag=p._b64(self._tag("approved", self.window))))
        return messages

    def _tag(self, label, sender):
        key = self._proof_key if label == "proof" else self._approval_key
        return hmac.new(key, DOMAIN + label.encode("ascii") + b"\0" + sender.encode("ascii") + self._digest,
                        hashlib.sha512).digest()

    def receive(self, message, address):
        if not self.active or self.peer is None or address != self.peer["address"]:
            return
        if message.get("from") != self.peer["nearby"] or message.get("to") != self.window:
            return
        kind = message.get("type")
        field = {"easy_commit": "commit", "easy_reveal": "reveal", "easy_proof": "tag", "easy_approve": "tag"}.get(kind)
        if field is None:
            return
        if set(message) - {"beamy"} != {"type", "from", "to", field}:
            self.cancel("refused")
            return
        try:
            if kind == "easy_commit":
                commit = p._unb64(message["commit"])
                if len(commit) != 64 or (self.remote_commit is not None and not hmac.compare_digest(commit, self.remote_commit)):
                    raise p.PairingError(p.ERROR_REFUSED)
                self.remote_commit = commit
            elif kind == "easy_reveal":
                if self.remote_commit is None:
                    return
                reveal = message["reveal"]
                if not isinstance(reveal, dict) or set(reveal) != set(self.reveal):
                    raise p.PairingError(p.ERROR_REFUSED)
                if not hmac.compare_digest(hashlib.sha512(DOMAIN + b"commit\0" + canonical(reveal)).digest(), self.remote_commit):
                    raise p.PairingError(p.ERROR_REFUSED)
                if self.remote_reveal is not None:
                    if reveal != self.remote_reveal:
                        raise p.PairingError(p.ERROR_REFUSED)
                    return
                expected = {key: self.peer[key] for key in self._own}
                if any(reveal[key] != value or type(reveal[key]) is not type(value) for key, value in expected.items()) or reveal["to"] != self.window:
                    raise p.PairingError(p.ERROR_REFUSED)
                share, nonce = p._unb64(reveal["share"]), p._unb64(reveal["nonce"])
                if len(share) != 32 or len(nonce) != 32 or not p._machine_id_ok(p._unb64(reveal["id"])):
                    raise p.PairingError(p.ERROR_REFUSED)
                shared = p._x25519(self._scalar, share)
                transcript = sorted((self.reveal, reveal), key=lambda item: item["nearby"])
                self._digest = hashlib.sha512(DOMAIN + b"transcript\0" + canonical(transcript)).digest()
                key = hmac.new(self._digest, shared, hashlib.sha512).digest()
                derive = lambda label: hmac.new(key, DOMAIN + label + b"\0" + self._digest, hashlib.sha512).digest()
                self.token = p._b64(derive(b"token")[:32])
                self._proof_key, self._approval_key = derive(b"proof-key"), derive(b"approval-key")
                sas_key = derive(b"sas-key")
                counter = 0
                while True:
                    value = int.from_bytes(hmac.new(sas_key, DOMAIN + b"digits\0" + counter.to_bytes(4, "big"), hashlib.sha512).digest()[:4], "big")
                    if value < 4294000000:
                        self._sas = f"{value % 1000000:06d}"
                        break
                    counter += 1
                self.remote_reveal = reveal.copy()
            elif self._digest is not None:
                tag = p._unb64(message["tag"])
                label = "proof" if kind == "easy_proof" else "approved"
                if not hmac.compare_digest(tag, self._tag(label, self.peer["nearby"])):
                    raise p.PairingError(p.ERROR_REFUSED)
                if kind == "easy_proof":
                    self.remote_proved = True
                    self._state = "waiting" if self.local_approved else "confirm"
                elif self.remote_proved:
                    self.remote_approved = True
        except (p.PairingError, ValueError, TypeError, KeyError, UnicodeError):
            self.cancel("refused")

    def approve(self, sas, attempt):
        if self.state != "confirm" or sas != self.sas or attempt != self.attempt:
            self.cancel("refused")
            raise p.PairingError(p.ERROR_REFUSED)
        self.local_approved = True
        self._state = "waiting"

    def saved(self):
        # Authorisation was checked before store began. A disk write crossing the
        # deadline must still report the entry it actually saved.
        if self._state != "waiting" or not (self.remote_proved and self.local_approved and self.remote_approved):
            raise p.PairingError(p.ERROR_REFUSED)
        self._state = "paired"
        self._scalar = self._nonce = None

    def _forget(self):
        self._scalar = self._nonce = self._proof_key = self._approval_key = self.token = self._sas = None

    def cancel(self, state="inactive"):
        self._state = state
        self._forget()