provared 0.3.0__tar.gz → 0.5.0__tar.gz

{provared-0.3.0/src/provared.egg-info → provared-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: provared
-Version: 0.3.0
+Version: 0.5.0
 Summary: Proof of what an AI agent was allowed to do, and what it then did. A passkey-signed permission with limits a machine can check, a signed receipt for each action, and a checker. Evidence, not a verdict.
 Author: Pavel Izmaylov
 License-Expression: Apache-2.0 AND CC-BY-4.0
@@ -19,7 +19,7 @@ License-File: LICENSE-CC-BY-4.0.txt
 Requires-Dist: cryptography>=48
 Dynamic: license-file
 
-# Provared for Python
+# <img src="https://prova.red/favicon.svg" alt="" width="36"> Provared for Python
 
 Proof of what an AI agent was allowed to do, and what it then did.
 
@@ -34,7 +34,7 @@ particular to Python.
 
 ## Status
 
-**Version 0.3.0, a draft**, the same version as the JavaScript library.
+**Version 0.5.0, a draft**, the same version as the JavaScript library.
 Published as it is, by one author in their own time; fixes as time
 allows. It gives the same answer, case for case, as the shared test
 files in [`test-vectors/`](https://github.com/provared/provared/tree/main/test-vectors) show: the same result, the
@@ -46,7 +46,10 @@ needs, `cryptography`, does not yet have SLH-DSA (FIPS 205), the method
 of a seal's third signature. So a seal's third signature is reported as
 "not checked on this device", and never as a pass, as the checking page
 in a browser reports it. Seals are checked in full by the JavaScript
-command-line checker.
+command-line checker. The check before acting, and so the stub writer,
+goes on after a seal whose Ed25519 and ML-DSA-87 signatures were checked
+here, and its answer says what was not checked (`notChecked`); any
+other signature left unchecked still allows nothing.
 
 ## Install
 
@@ -199,6 +202,115 @@ are dicts and lists, with the same member names as in the format.
 `provared.check` holds the checker alone, for anyone who audits the
 checking.
 
+Where the other side will not countersign, a stub can name the
+fingerprint of the other system's own identifier for the call, so that
+someone who holds that system's log can match the two. Document names
+that begin `provared.` are reserved for this (`DOCUMENT_NAMES`; format
+description, section 27), and any other such name is refused.
+`identifier_fingerprint`, `http_request_fingerprint` and
+`http_response_fingerprint` make the fingerprints (a body is bytes, a
+bytearray or a memoryview, after any content coding such as gzip; None
+is no body; a status may be an int, or a float equal to a whole number;
+no header is covered; a trace-id's form is not checked). Only
+`provared.trace-id`, `provared.request-id` and `provared.event-id` may
+be named more than once in a stub. An identifier that the platform gives only
+in its answer goes in through `details_after` (the JavaScript name
+`detailsAfter` is taken too):
+
+```python
+from provared import identifier_fingerprint
+
+result = writer.act(
+    {'action': 'provared.data.change', 'with': 'tickets'},
+    lambda: update_the_ticket(),
+    {'details_after': lambda answer: [{'name': 'provared.event-id', 'sha256': identifier_fingerprint(answer['request_id'])}]},
+)
+result['detailsAfter']   # {'added': 1, 'problem': None}
+```
+
+The stub is checked with the whole book before the action, and signed
+again after it with up to four further documents, in the same call; it
+keeps the time the action began. `details_after` is asked in a thread
+of its own, must be an ordinary function, and is given as long as the
+other side is given to countersign. If it fails, gives no answer in
+time, or gives what cannot go in, the stub is written without the
+further documents and `result['detailsAfter']['problem']` says why. It
+cannot be used with an approval. A matching identifier shows that the
+two records speak of one call, not that the call did what either says;
+a fingerprint of a request, an answer, the arguments or an error shows
+only that the content matches, not that it was the same call.
+`record_tools` and `record_function` still name the arguments
+`arguments` by default.
+
+## Keys held elsewhere: signers
+
+The keys of an agent, a service or an organisation need not sit in the
+memory of the program that writes the records. Wherever a writer takes
+`private_keys` (`open_recorder`, `write_stub`, `countersign`,
+`write_refusal`, `write_terms`, `write_pass`, `write_acknowledgement`,
+`write_vouching` and `write_withdrawal`), each item may be a key of the
+package `cryptography`, as before, or a **signer**: any object with a
+`key` attribute, the public key as a dict in one of the shapes the format
+allows (format description, section 3.8), and a `sign(data)` method that
+gives the signature over exactly those bytes (`bytes`, `bytearray` or
+`memoryview`). `provared.Signer` describes it for type checkers. Keys and
+signers may be mixed. `signer_from_key(alg, private_key, key)` wraps a
+key held in memory as a signer.
+
+```python
+from provared import open_recorder, signer_from_key
+
+class HeldSigner:
+    """The agent's ML-DSA-87 key, held in a key service."""
+    key = agent_keys[1]                      # the public key, as the slip names it
+    def sign(self, data):
+        return key_service.sign('agent-ml-dsa-87', data)   # the bytes themselves, not a fingerprint of them
+
+writer = open_recorder(book_text, slip_fingerprint,
+                       [signer_from_key('Ed25519', ed25519_private_key, agent_keys[0]), HeldSigner()],
+                       issuer_keys=[passkey_thumbprint], sign_within=10000)
+```
+
+A record made through a signer is the same record as one made with the
+key: the same content, labels and Ed25519 signature (an ML-DSA-87
+signature is made afresh each time, either way). A signer is not taken
+on trust. Its two members are read once, and its key must be exactly a
+key of the method of its place, as plain data: a `dict` whose names and
+values are plain `str`, not a kind derived from them. A signer for
+SLH-DSA is refused before any signer is asked, as `cryptography` cannot
+check SLH-DSA, so no seal is written in Python, with keys or with
+signers. Where the writer knows the key the record must be signed with
+(the agent's keys, or a helper's, in the stub writer; the keys `by`
+names in `write_refusal`, `write_terms` and `write_vouching`), a signer
+for another key is refused (`bad-key`) before any signer is asked. The
+stub writer compares when it is opened, with the slip, or the pass it
+acts under, as its book holds it; opened with a pass that its book does
+not yet hold, it compares nothing then, and refuses each action
+(`pass-missing`). `write_stub`, `countersign`, `write_pass`,
+`write_acknowledgement` and `write_withdrawal`, used by themselves,
+cannot know the key: there a signer for another key gives a record that
+fails its own check, as a wrong key always did. Every signature is
+checked against the signer's key before it is used: one of the wrong
+length, one that does not check, something other than bytes, a
+coroutine, or an error raised leaves no record (`signature-invalid`),
+and the error names the place, the method and the key's thumbprint. In
+the stub writer a signer is asked in a thread of its own and given
+`sign_within` milliseconds (30,000 by default) for each signature; after
+that the action is not taken, nothing is written, and a late answer is
+not used. The other writers set no time of their own: give the signer's
+own connection a time limit. Where no record is made, signers earlier in
+the list may already have signed, and a signer that ran out of time may
+still sign later: a key service's own log may hold signatures that match
+no record. A private key of `cryptography` of another method than its
+place's, or anything else that is neither a key nor a signer, is refused
+(`bad-field`).
+
+The library cannot know how a key held elsewhere is kept, or whether
+the service keeps it safe; it checks only that each signature fits the
+key the signer names. A record does not say where a key was kept. Each
+signature costs one more check (under a thousandth of a second for
+Ed25519 and ML-DSA-87 on one computer).
+
 ## Tests
 
 From the `python` folder:

{provared-0.3.0 → provared-0.5.0}/README.md

@@ -1,4 +1,4 @@
-# Provared for Python
+# <img src="https://prova.red/favicon.svg" alt="" width="36"> Provared for Python
 
 Proof of what an AI agent was allowed to do, and what it then did.
 
@@ -13,7 +13,7 @@ particular to Python.
 
 ## Status
 
-**Version 0.3.0, a draft**, the same version as the JavaScript library.
+**Version 0.5.0, a draft**, the same version as the JavaScript library.
 Published as it is, by one author in their own time; fixes as time
 allows. It gives the same answer, case for case, as the shared test
 files in [`test-vectors/`](https://github.com/provared/provared/tree/main/test-vectors) show: the same result, the
@@ -25,7 +25,10 @@ needs, `cryptography`, does not yet have SLH-DSA (FIPS 205), the method
 of a seal's third signature. So a seal's third signature is reported as
 "not checked on this device", and never as a pass, as the checking page
 in a browser reports it. Seals are checked in full by the JavaScript
-command-line checker.
+command-line checker. The check before acting, and so the stub writer,
+goes on after a seal whose Ed25519 and ML-DSA-87 signatures were checked
+here, and its answer says what was not checked (`notChecked`); any
+other signature left unchecked still allows nothing.
 
 ## Install
 
@@ -178,6 +181,115 @@ are dicts and lists, with the same member names as in the format.
 `provared.check` holds the checker alone, for anyone who audits the
 checking.
 
+Where the other side will not countersign, a stub can name the
+fingerprint of the other system's own identifier for the call, so that
+someone who holds that system's log can match the two. Document names
+that begin `provared.` are reserved for this (`DOCUMENT_NAMES`; format
+description, section 27), and any other such name is refused.
+`identifier_fingerprint`, `http_request_fingerprint` and
+`http_response_fingerprint` make the fingerprints (a body is bytes, a
+bytearray or a memoryview, after any content coding such as gzip; None
+is no body; a status may be an int, or a float equal to a whole number;
+no header is covered; a trace-id's form is not checked). Only
+`provared.trace-id`, `provared.request-id` and `provared.event-id` may
+be named more than once in a stub. An identifier that the platform gives only
+in its answer goes in through `details_after` (the JavaScript name
+`detailsAfter` is taken too):
+
+```python
+from provared import identifier_fingerprint
+
+result = writer.act(
+    {'action': 'provared.data.change', 'with': 'tickets'},
+    lambda: update_the_ticket(),
+    {'details_after': lambda answer: [{'name': 'provared.event-id', 'sha256': identifier_fingerprint(answer['request_id'])}]},
+)
+result['detailsAfter']   # {'added': 1, 'problem': None}
+```
+
+The stub is checked with the whole book before the action, and signed
+again after it with up to four further documents, in the same call; it
+keeps the time the action began. `details_after` is asked in a thread
+of its own, must be an ordinary function, and is given as long as the
+other side is given to countersign. If it fails, gives no answer in
+time, or gives what cannot go in, the stub is written without the
+further documents and `result['detailsAfter']['problem']` says why. It
+cannot be used with an approval. A matching identifier shows that the
+two records speak of one call, not that the call did what either says;
+a fingerprint of a request, an answer, the arguments or an error shows
+only that the content matches, not that it was the same call.
+`record_tools` and `record_function` still name the arguments
+`arguments` by default.
+
+## Keys held elsewhere: signers
+
+The keys of an agent, a service or an organisation need not sit in the
+memory of the program that writes the records. Wherever a writer takes
+`private_keys` (`open_recorder`, `write_stub`, `countersign`,
+`write_refusal`, `write_terms`, `write_pass`, `write_acknowledgement`,
+`write_vouching` and `write_withdrawal`), each item may be a key of the
+package `cryptography`, as before, or a **signer**: any object with a
+`key` attribute, the public key as a dict in one of the shapes the format
+allows (format description, section 3.8), and a `sign(data)` method that
+gives the signature over exactly those bytes (`bytes`, `bytearray` or
+`memoryview`). `provared.Signer` describes it for type checkers. Keys and
+signers may be mixed. `signer_from_key(alg, private_key, key)` wraps a
+key held in memory as a signer.
+
+```python
+from provared import open_recorder, signer_from_key
+
+class HeldSigner:
+    """The agent's ML-DSA-87 key, held in a key service."""
+    key = agent_keys[1]                      # the public key, as the slip names it
+    def sign(self, data):
+        return key_service.sign('agent-ml-dsa-87', data)   # the bytes themselves, not a fingerprint of them
+
+writer = open_recorder(book_text, slip_fingerprint,
+                       [signer_from_key('Ed25519', ed25519_private_key, agent_keys[0]), HeldSigner()],
+                       issuer_keys=[passkey_thumbprint], sign_within=10000)
+```
+
+A record made through a signer is the same record as one made with the
+key: the same content, labels and Ed25519 signature (an ML-DSA-87
+signature is made afresh each time, either way). A signer is not taken
+on trust. Its two members are read once, and its key must be exactly a
+key of the method of its place, as plain data: a `dict` whose names and
+values are plain `str`, not a kind derived from them. A signer for
+SLH-DSA is refused before any signer is asked, as `cryptography` cannot
+check SLH-DSA, so no seal is written in Python, with keys or with
+signers. Where the writer knows the key the record must be signed with
+(the agent's keys, or a helper's, in the stub writer; the keys `by`
+names in `write_refusal`, `write_terms` and `write_vouching`), a signer
+for another key is refused (`bad-key`) before any signer is asked. The
+stub writer compares when it is opened, with the slip, or the pass it
+acts under, as its book holds it; opened with a pass that its book does
+not yet hold, it compares nothing then, and refuses each action
+(`pass-missing`). `write_stub`, `countersign`, `write_pass`,
+`write_acknowledgement` and `write_withdrawal`, used by themselves,
+cannot know the key: there a signer for another key gives a record that
+fails its own check, as a wrong key always did. Every signature is
+checked against the signer's key before it is used: one of the wrong
+length, one that does not check, something other than bytes, a
+coroutine, or an error raised leaves no record (`signature-invalid`),
+and the error names the place, the method and the key's thumbprint. In
+the stub writer a signer is asked in a thread of its own and given
+`sign_within` milliseconds (30,000 by default) for each signature; after
+that the action is not taken, nothing is written, and a late answer is
+not used. The other writers set no time of their own: give the signer's
+own connection a time limit. Where no record is made, signers earlier in
+the list may already have signed, and a signer that ran out of time may
+still sign later: a key service's own log may hold signatures that match
+no record. A private key of `cryptography` of another method than its
+place's, or anything else that is neither a key nor a signer, is refused
+(`bad-field`).
+
+The library cannot know how a key held elsewhere is kept, or whether
+the service keeps it safe; it checks only that each signature fits the
+key the signer names. A record does not say where a key was kept. Each
+signature costs one more check (under a thousandth of a second for
+Ed25519 and ML-DSA-87 on one computer).
+
 ## Tests
 
 From the `python` folder:

{provared-0.3.0 → provared-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "provared"
-version = "0.3.0"
+version = "0.5.0"
 description = "Proof of what an AI agent was allowed to do, and what it then did. A passkey-signed permission with limits a machine can check, a signed receipt for each action, and a checker. Evidence, not a verdict."
 keywords = ["ai-agent", "agent", "audit-trail", "permission", "authorization", "receipt", "tamper-evident", "passkey", "webauthn", "jws", "ed25519", "ml-dsa", "post-quantum", "evidence", "langchain"]
 readme = "README.md"

{provared-0.3.0 → provared-0.5.0}/src/provared/__init__.py

@@ -24,23 +24,29 @@
 #            the receipt), record_tools (an agent's tools behind the stub
 #            writer), arguments_fingerprint, NotTaken
 # Keys:      generate_key_set, key_set_from_seeds, key_set_seeds, thumbprint,
-#            key_set_fingerprint
-# Names:     the shared list of actions, the kinds of action, the rules of conduct
+#            key_set_fingerprint, signer_from_key and Signer (wherever
+#            "private_keys" is taken, each item may be a key or a signer, an
+#            object with "key" and "sign", for a key held elsewhere)
+# Names:     the shared list of actions, the kinds of action, the rules of conduct;
+#            the reserved document names (DOCUMENT_NAMES), and the fingerprints
+#            they stand for (http_request_fingerprint, http_response_fingerprint,
+#            identifier_fingerprint)
 
 from .actions import ACTION_KINDS, CONDUCT_RULES, RESERVED_PREFIX, SHARED_ACTIONS, action_kind
 from .approval import assemble_approval, prepare_approval
 from .blockstamp import block_fingerprint, block_stamp_item
 from .book import LIMITS, check_book, check_show, entry_line, make_show, open_checker, write_book
 from .compare import condition_words, limit_words, never_words
+from .documents import DOCUMENT_NAMES, RESERVED_DOCUMENT_PREFIX, http_request_fingerprint, http_response_fingerprint, identifier_fingerprint
 from .encoding import Refusal, fingerprint, format_time, from_base64url, random_id, sha256, to_base64url, utf8
 from .guard import check_before
 from .headers import MIN_BLOCKS_AFTER, blocks_in_chain, check_header_chain
 from .keys import thumbprint
 from .pass_ import write_pass
-from .recorder import COUNTERSIGN_WITHIN_MS, Recorder, open_recorder
+from .recorder import COUNTERSIGN_WITHIN_MS, SIGN_WITHIN_MS, Recorder, open_recorder
 from .seal import key_set_fingerprint
 from .service import REFUSAL_REASONS, write_refusal, write_terms
-from .signatures import generate_key_set, key_set_from_seeds, key_set_seeds, method_available
+from .signatures import Signer, generate_key_set, key_set_from_seeds, key_set_seeds, method_available, signer_from_key
 from .slip import COVERABLE, assemble_slip, check_slip, prepare_slip
 from .standing import VOUCHED_KINDS, assemble_cancellation, prepare_cancellation, write_acknowledgement, write_vouching, write_withdrawal
 from .stub import countersign, write_stub
@@ -49,8 +55,10 @@ from .tools import NotTaken, arguments_fingerprint, record_function, record_tool
 __all__ = [
     'MIN_BLOCKS_AFTER', 'blocks_in_chain', 'check_header_chain',
     'COUNTERSIGN_WITHIN_MS', 'NotTaken', 'Recorder', 'arguments_fingerprint', 'key_set_from_seeds', 'key_set_seeds', 'open_recorder',
+    'SIGN_WITHIN_MS', 'Signer', 'signer_from_key',
     'record_function', 'record_tools',
     'ACTION_KINDS', 'CONDUCT_RULES', 'COVERABLE', 'LIMITS', 'REFUSAL_REASONS', 'RESERVED_PREFIX', 'SHARED_ACTIONS', 'VOUCHED_KINDS',
+    'DOCUMENT_NAMES', 'RESERVED_DOCUMENT_PREFIX', 'http_request_fingerprint', 'http_response_fingerprint', 'identifier_fingerprint',
     'Refusal', 'action_kind', 'assemble_approval', 'assemble_cancellation', 'assemble_slip', 'block_fingerprint', 'block_stamp_item',
     'check_before', 'check_book', 'check_show', 'check_slip', 'condition_words', 'countersign', 'entry_line', 'fingerprint',
     'format_time', 'from_base64url', 'generate_key_set', 'key_set_fingerprint', 'limit_words', 'make_show', 'method_available',

{provared-0.3.0 → provared-0.5.0}/src/provared/dev.py

@@ -126,7 +126,7 @@ def development_recorder(fields=None, more=None, **named):
     """The stub writer, opened under a development slip, in one call: the
     shortest way to a first record. The same as development_slip followed by
     open_recorder; "more" (a dict) is passed to open_recorder: "options",
-    "now", "countersign_within". What it hands back has the writer as
+    "now", "countersign_within", "sign_within". What it hands back has the writer as
     ".writer", beside everything development_slip gives."""
     made = development_slip(fields, **named)
     made.writer = open_recorder(made.book, made.slip_fingerprint, made.agent_private_keys, made.issuer_keys, **(more or {}))

provared-0.5.0/src/provared/documents.py

@@ -0,0 +1,159 @@
+# The reserved names of the documents a stub names (format description,
+# section 27), and the fingerprints they stand for.
+#
+# A stub's "details" names documents by their fingerprints. Most names are
+# labels that whoever wrote the stub chose. Names that begin "provared."
+# are reserved: each one on the list below says exactly which text its
+# fingerprint is made from, so that an investigator who holds that text
+# (the call's arguments, the HTTP request, the identifier a platform's own
+# log shows for the call) can work the fingerprint out again and match
+# the stub to it, without either side's help.
+
+import base64
+import re
+import types
+
+from .encoding import Refusal, _well_formed, fingerprint, sha256, utf8
+
+RESERVED_DOCUMENT_PREFIX = 'provared.'
+"""Every document name that begins with this is reserved for the list below."""
+
+DOCUMENT_NAMES = types.MappingProxyType({
+    'provared.arguments': "The call's arguments, written in the one form of RFC 8785.",
+    'provared.http-request': 'The request, written as the signature base of RFC 9421, section 2.5, over "@method", "@target-uri" and, where there is a body, "content-digest" (RFC 9530, with SHA-256). No header is covered.',
+    'provared.http-response': 'The answer, written as the signature base of RFC 9421, section 2.5, over "@status" and, where there is a body, "content-digest" (RFC 9530, with SHA-256). No header is covered.',
+    'provared.trace-id': 'The trace-id of the W3C Trace Context "traceparent" header that the agent\'s side sent, which that standard writes as 32 lower-case hexadecimal characters. Its form is not checked.',
+    'provared.request-id': "An identifier that the agent's side chose and sent with the call, exactly as sent.",
+    'provared.event-id': 'An identifier that the platform gave for the call, exactly as it gave it.',
+    'provared.error': "The error text that the agent's software was given, exactly as given.",
+})
+"""The reserved document names, and the exact text whose SHA-256 each one gives."""
+
+
+REPEATABLE_DOCUMENT_NAMES = ('provared.trace-id', 'provared.request-id', 'provared.event-id')
+"""The reserved names that may appear more than once in one record: an
+identifier from each of several systems. Every other reserved name may
+appear once at most."""
+
+
+def is_unknown_reserved_document(name):
+    """Whether a document name is reserved and not on the list: such a name is refused."""
+    return isinstance(name, str) and name.startswith(RESERVED_DOCUMENT_PREFIX) and name not in DOCUMENT_NAMES
+
+
+# A method is a token of RFC 9110, section 5.6.2: one or more of these.
+_TOKEN = re.compile(r"[!#$%&'*+\-.^_`|~0-9A-Za-z]+")
+# An address is taken exactly as it was sent, never rewritten: so it must
+# already be in the form a request carries, an absolute http or https
+# address of visible ASCII characters, with no fragment (which is never
+# sent).
+_ADDRESS = re.compile(r'https?://[\x21\x22\x24-\x7e]+')
+
+_ABSENT = object()
+
+
+def _member(r, name):
+    if isinstance(r, dict):
+        return r.get(name, _ABSENT)
+    return getattr(r, name, _ABSENT)
+
+
+def _body(value, path):
+    if value is _ABSENT or value is None:
+        return _ABSENT
+    if not isinstance(value, (bytes, bytearray, memoryview)):
+        raise Refusal('bad-field', f'{path}: must be the bytes of the body, as sent.')
+    # The bytes themselves, read through the buffer, never a subclass's own __bytes__.
+    return bytes(memoryview(value))
+
+
+def _content_digest(data):
+    # The Content-Digest field value of RFC 9530, with SHA-256 only; base64
+    # with padding (RFC 4648, section 4), as a byte sequence of RFC 8941 is written.
+    return 'sha-256=:' + base64.b64encode(sha256(data)).decode('ascii') + ':'
+
+
+def _signature_base(components):
+    # The signature base of RFC 9421, section 2.5: a line for each component,
+    # "<identifier>: <value>" and a line feed, then the line
+    # "@signature-params" with the list of the components and no parameters,
+    # and no line feed after it. Nothing is signed with it.
+    lines = ''.join(f'"{name}": {value}\n' for name, value in components)
+    return lines + '"@signature-params": (' + ' '.join(f'"{name}"' for name, _ in components) + ')'
+
+
+def _is_object(r):
+    return r is not None and not isinstance(r, (str, bytes, bytearray, int, float, bool, list, tuple))
+
+
+def http_request_base(r):
+    """The text that the reserved name "provared.http-request" is made from.
+    r: "method" and "url" exactly as sent, and "body" (bytes) where there is a body."""
+    if not _is_object(r):
+        raise Refusal('bad-field', 'The request must be an object.')
+    method = _member(r, 'method')
+    url = _member(r, 'url')
+    given = _body(_member(r, 'body'), 'body')
+    # The text itself, never a subclass's own way of writing it.
+    method = str.__str__(method) if isinstance(method, str) else method
+    url = str.__str__(url) if isinstance(url, str) else url
+    if not isinstance(method, str) or not _TOKEN.fullmatch(method):
+        raise Refusal('bad-field', 'method: must be the method of the request as sent, a token such as GET or POST.')
+    if not isinstance(url, str) or not _ADDRESS.fullmatch(url):
+        raise Refusal('bad-field', 'url: must be the address of the request as sent: an absolute http or https address of visible ASCII characters, with no fragment.')
+    components = [('@method', method), ('@target-uri', url)]
+    if given is not _ABSENT:
+        components.append(('content-digest', _content_digest(given)))
+    return _signature_base(components)
+
+
+def http_response_base(r):
+    """The text that the reserved name "provared.http-response" is made from.
+    r: "status", and "body" (bytes) where there is a body."""
+    if not _is_object(r):
+        raise Refusal('bad-field', 'The answer must be an object.')
+    status = _member(r, 'status')
+    given = _body(_member(r, 'body'), 'body')
+    # A whole number, whatever its type, as JavaScript reads one: a float
+    # that equals a whole number is that whole number. True and False are
+    # not numbers here. The value is read as the plain number, never through
+    # a subclass's own methods.
+    whole = None
+    if isinstance(status, int) and not isinstance(status, bool):
+        whole = int.__index__(status)
+    elif isinstance(status, float) and float.is_integer(status):
+        whole = float.__int__(status)
+    if whole is None or not 100 <= whole <= 599:
+        raise Refusal('bad-field', 'status: must be the status code of the answer, a whole number from 100 to 599.')
+    components = [('@status', '%d' % whole)]
+    if given is not _ABSENT:
+        components.append(('content-digest', _content_digest(given)))
+    return _signature_base(components)
+
+
+def http_request_fingerprint(r):
+    """The fingerprint of an HTTP request, for the document
+    "provared.http-request": "method" and "url" exactly as sent, and "body"
+    (bytes) where there is a body. Raises a Refusal, "bad-field", if the
+    request is not as set out."""
+    return fingerprint(utf8(http_request_base(r)))
+
+
+def http_response_fingerprint(r):
+    """The fingerprint of an HTTP answer, for the document
+    "provared.http-response": "status", and "body" (bytes) where there is a
+    body. Raises a Refusal, "bad-field", if the answer is not as set out."""
+    return fingerprint(utf8(http_response_base(r)))
+
+
+def identifier_fingerprint(identifier):
+    """The fingerprint of an identifier or of an error text, exactly as given:
+    SHA-256 of its UTF-8 bytes. For "provared.trace-id", "provared.request-id",
+    "provared.event-id" and "provared.error". Raises a Refusal, "bad-field", if
+    it is not text, is empty, or is not well-formed Unicode."""
+    if not isinstance(identifier, str) or len(identifier) == 0:
+        raise Refusal('bad-field', 'The identifier must be text of one character or more.')
+    identifier = str.__str__(identifier)  # the text itself, never a subclass's own methods
+    if not _well_formed(identifier):
+        raise Refusal('bad-field', 'The identifier holds text that is not well-formed Unicode.')
+    return fingerprint(utf8(identifier))

{provared-0.3.0 → provared-0.5.0}/src/provared/encoding.py

@@ -250,7 +250,7 @@ def format_time(when):
     read: text, True or a datetime with no time zone would be read by rules
     that differ from one device to another (as local time), so they are
     refused."""
-    if isinstance(when, _datetime.datetime) and when.tzinfo is not None:
+    if isinstance(when, _datetime.datetime) and when.utcoffset() is not None:
         when = (when - _EPOCH) // _datetime.timedelta(milliseconds=1)
     if not _js.finite(when) or abs(when) > MAX_TIME_MS:
         raise ValueError('Invalid time value')