Skip to content

Class swarmauri_cipher_suite_cose.CoseCipherSuite.CoseCipherSuite

swarmauri_cipher_suite_cose.CoseCipherSuite.CoseCipherSuite

Bases: CipherSuiteBase

COSE algorithm registry surface.

suite_id 

suite_id()
Source code in swarmauri_cipher_suite_cose/CoseCipherSuite.py 
24
25
def suite_id(self) -> str:
    return "cose"

supports 

supports()
Source code in swarmauri_cipher_suite_cose/CoseCipherSuite.py 
27
28
29
30
31
32
33
def supports(self) -> Mapping[CipherOp, Iterable[Alg]]:
    return {
        "sign": tuple(str(value) for value in _COSE_SIGN),
        "verify": tuple(str(value) for value in _COSE_SIGN),
        "encrypt": tuple(str(value) for value in _COSE_AEAD),
        "decrypt": tuple(str(value) for value in _COSE_AEAD),
    }

default_alg 

default_alg(op, *, for_key=None)
Source code in swarmauri_cipher_suite_cose/CoseCipherSuite.py 
35
36
def default_alg(self, op: CipherOp, *, for_key: Optional[KeyRef] = None) -> Alg:
    return {"sign": "-8", "encrypt": "3"}.get(op, "3")

features 

features()
Source code in swarmauri_cipher_suite_cose/CoseCipherSuite.py 
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def features(self) -> Features:
    return {
        "suite": "cose",
        "version": 1,
        "dialects": {
            "cose": list({*self.supports()["sign"], *self.supports()["encrypt"]})
        },
        "ops": {
            "sign": {"default": "-8", "allowed": list(self.supports()["sign"])},
            "encrypt": {
                "default": "3",
                "allowed": list(self.supports()["encrypt"]),
            },
        },
        "constraints": {"aead": {"tagBits": 128, "nonceLen": 12}},
        "compliance": {"fips": False},
    }

normalize 

normalize(
    *, op, alg=None, key=None, params=None, dialect=None
)
Source code in swarmauri_cipher_suite_cose/CoseCipherSuite.py 
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
def normalize(
    self,
    *,
    op: CipherOp,
    alg: Optional[Alg] = None,
    key: Optional[KeyRef] = None,
    params: Optional[ParamMapping] = None,
    dialect: Optional[str] = None,
) -> NormalizedDescriptor:
    allowed = set(self.supports().get(op, ()))
    chosen = str(alg or self.default_alg(op, for_key=key))
    if chosen not in allowed:
        raise ValueError(f"{chosen=} not supported for {op=}")

    resolved = dict(params or {})
    if chosen in {"1", "2", "3"}:
        resolved.setdefault("tagBits", 128)
        resolved.setdefault("nonceLen", 12)
    mapped = {
        "cose": int(chosen),
        "provider": chosen,
    }
    return {
        "op": op,
        "alg": chosen,
        "dialect": "cose" if dialect is None else dialect,
        "mapped": mapped,
        "params": resolved,
        "constraints": {},
        "policy": self.policy(),
    }