1JOSEPY(1) josepy JOSEPY(1)
2
6 josepy - josepy Documentation
7 Javascript Object Signing and Encryption (JOSE).
9 This package is a Python implementation of the standards developed by
11 IETF Javascript Object Signing and Encryption (Active WG), in particu‐
12 lar the following RFCs:
13 · JSON Web Algorithms (JWA)
15 · JSON Web Key (JWK)
17 · JSON Web Signature (JWS)
19 Originally developed as part of the ACME protocol implementation.
21
23 JOSE Base64 is defined as:
24 · URL-safe Base64
26 · padding stripped
28 josepy.b64.b64encode(data)
30 JOSE Base64 encode.
31 Parameters
33 data (bytes) -- Data to be encoded.
34 Returns
36 JOSE Base64 string.
37 Return type
39 bytes
40 Raises TypeError -- if data is of incorrect type
42 josepy.b64.b64decode(data)
44 JOSE Base64 decode.
45 Parameters
47 data (bytes or unicode) -- Base64 string to be decoded.
48 If it's unicode, then only ASCII characters are allowed.
49 Returns
51 Decoded data.
52 Return type
54 bytes
55 Raises
57 · TypeError -- if input is of incorrect type
59 · ValueError -- if input is unicode with non-ASCII char‐
61 acters
62
64 JOSE errors.
65 exception josepy.errors.Error
67 Bases: Exception
68 Generic JOSE Error.
70 exception josepy.errors.DeserializationError
72 Bases: josepy.errors.Error
73 JSON deserialization error.
75 exception josepy.errors.SerializationError
77 Bases: josepy.errors.Error
78 JSON serialization error.
80 exception josepy.errors.UnrecognizedTypeError(typ, jobj)
82 Bases: josepy.errors.DeserializationError
83 Unrecognized type error.
85 Variables
87 · typ (str) -- The unrecognized type of the JSON object.
89 · jobj -- Full JSON object.
91
93 JOSE interfaces.
94 class josepy.interfaces.JSONDeSerializable
96 Bases: object
97 Interface for (de)serializable JSON objects.
99 Please recall, that standard Python library implements json.JSO‐
101 NEncoder and json.JSONDecoder that perform translations based on
102 respective conversion tables that look pretty much like the one
103 below (for complete tables see relevant Python documentation):
104 ┌───────┬────────┐
106 │JSON │ Python │
107 ├───────┼────────┤
108 │object │ dict │
109 ├───────┼────────┤
110 │... │ ... │
111 └───────┴────────┘
112 While the above conversion table is about translation of JSON
114 documents to/from the basic Python types only,
115 JSONDeSerializable introduces the following two concepts:
116 serialization
118 Turning an arbitrary Python object into Python object
119 that can be encoded into a JSON document. Full serial‐
120 ization produces a Python object composed of only
121 basic types as required by the conversion table. Par‐
122 tial serialization (accomplished by to_partial_json())
123 produces a Python object that might also be built from
124 other JSONDeSerializable objects.
125 deserialization
127 Turning a decoded Python object (necessarily one of
128 the basic types as required by the conversion table)
129 into an arbitrary Python object.
130 Serialization produces serialized object ("partially serialized
132 object" or "fully serialized object" for partial and full seri‐
133 alization respectively) and deserialization produces deserial‐
134 ized object, both usually denoted in the source code as jobj.
135 Wording in the official Python documentation might be confusing
137 after reading the above, but in the light of those definitions,
138 one can view json.JSONDecoder.decode() as decoder and deserial‐
139 izer of basic types, json.JSONEncoder.default() as serializer of
140 basic types, json.JSONEncoder.encode() as serializer and
141 encoder of basic types.
142 One could extend json to support arbitrary object (de)serializa‐
144 tion either by:
145 · overriding json.JSONDecoder.decode() and json.JSONEn‐
147 coder.default() in subclasses
148 · or passing object_hook argument (or object_hook_pairs) to
150 json.load()/json.loads() or default argument for
151 json.dump()/json.dumps().
152 Interestingly, default is required to perform only partial seri‐
154 alization, as json.dumps() applies default recursively. This is
155 the idea behind making to_partial_json() produce only partial
156 serialization, while providing custom json_dumps() that dumps
157 with default set to json_dump_default().
158 To make further documentation a bit more concrete, please, con‐
160 sider the following imaginatory implementation example:
161 class Foo(JSONDeSerializable):
163 def to_partial_json(self):
164 return 'foo'
165 @classmethod
167 def from_json(cls, jobj):
168 return Foo()
169 class Bar(JSONDeSerializable):
171 def to_partial_json(self):
172 return [Foo(), Foo()]
173 @classmethod
175 def from_json(cls, jobj):
176 return Bar()
177 abstract to_partial_json()
179 Partially serialize.
180 Following the example, partial serialization means the
182 following:
183 assert isinstance(Bar().to_partial_json()[0], Foo)
185 assert isinstance(Bar().to_partial_json()[1], Foo)
186 # in particular...
188 assert Bar().to_partial_json() != ['foo', 'foo']
189 Raises josepy.errors.SerializationError -- in case of any
191 serialization error.
192 Returns
194 Partially serializable object.
195 to_json()
197 Fully serialize.
198 Again, following the example from before, full serializa‐
200 tion means the following:
201 assert Bar().to_json() == ['foo', 'foo']
203 Raises josepy.errors.SerializationError -- in case of any
205 serialization error.
206 Returns
208 Fully serialized object.
209 abstract classmethod from_json(jobj)
211 Deserialize a decoded JSON document.
212 Parameters
214 jobj -- Python object, composed of only other
215 basic data types, as decoded from JSON document.
216 Not necessarily dict (as decoded from "JSON
217 object" document).
218 Raises josepy.errors.DeserializationError -- if decoding
220 was unsuccessful, e.g. in case of unparseable X509
221 certificate, or wrong padding in JOSE base64
222 encoded string, etc.
223 classmethod json_loads(json_string)
225 Deserialize from JSON document string.
226 json_dumps(**kwargs)
228 Dump to JSON string using proper serializer.
229 Returns
231 JSON document string.
232 Return type
234 str
235 json_dumps_pretty()
237 Dump the object to pretty JSON document string.
238 Return type
240 str
241 classmethod json_dump_default(python_object)
243 Serialize Python object.
244 This function is meant to be passed as default to
246 json.dump() or json.dumps(). They call
247 default(python_object) only for non-basic Python types,
248 so this function necessarily raises TypeError if
249 python_object is not an instance of IJSONSerializable.
250 Please read the class docstring for more information.
252
254 JSON (de)serialization framework.
255 The framework presented here is somewhat based on Go's "json" package
257 (especially the omitempty functionality).
258 class josepy.json_util.Field(json_name, default=None, omitempty=False,
260 decoder=None, encoder=None)
261 Bases: object
262 JSON object field.
264 Field is meant to be used together with JSONObjectWithFields.
266 encoder (decoder) is a callable that accepts a single parameter,
268 i.e. a value to be encoded (decoded), and returns the serialized
269 (deserialized) value. In case of errors it should raise Serial‐
270 izationError (DeserializationError).
271 Note, that decoder should perform partial serialization only.
273 Variables
275 · json_name (str) -- Name of the field when encoded to
277 JSON.
278 · default -- Default value (used when not present in JSON
280 object).
281 · omitempty (bool) -- If True and the field value is
283 empty, then it will not be included in the serialized
284 JSON object, and default will be used for deserializa‐
285 tion. Otherwise, if False, field is considered as
286 required, value will always be included in the serial‐
287 ized JSON objected, and it must also be present when
288 deserializing.
289 classmethod _empty(value)
291 Is the provided value considered "empty" for this field?
292 This is useful for subclasses that might want to override
294 the definition of being empty, e.g. for some more exotic
295 data types.
296 omit(value)
298 Omit the value in output?
299 decoder(fdec)
301 Descriptor to change the decoder on JSON object field.
302 encoder(fenc)
304 Descriptor to change the encoder on JSON object field.
305 decode(value)
307 Decode a value, optionally with context JSON object.
308 encode(value)
310 Encode a value, optionally with context JSON object.
311 classmethod default_decoder(value)
313 Default decoder.
314 Recursively deserialize into immutable types (
316 josepy.util.frozendict instead of dict(), tuple() instead
317 of list()).
318 classmethod default_encoder(value)
320 Default (passthrough) encoder.
321 class josepy.json_util.JSONObjectWithFieldsMeta
323 Bases: abc.ABCMeta
324 Metaclass for JSONObjectWithFields and its subclasses.
326 It makes sure that, for any class cls with __metaclass__ set to
328 JSONObjectWithFieldsMeta:
329 1. All fields (attributes of type Field) in the class definition
331 are moved to the cls._fields dictionary, where keys are field
332 attribute names and values are fields themselves.
333 2. cls.__slots__ is extended by all field attribute names (i.e.
335 not Field.json_name). Original cls.__slots__ are stored in
336 cls._orig_slots.
337 In a consequence, for a field attribute name some_field,
339 cls.some_field will be a slot descriptor and not an instance of
340 Field. For example:
341 some_field = Field('someField', default=())
343 class Foo(object):
345 __metaclass__ = JSONObjectWithFieldsMeta
346 __slots__ = ('baz',)
347 some_field = some_field
348 assert Foo.__slots__ == ('some_field', 'baz')
350 assert Foo._orig_slots == ()
351 assert Foo.some_field is not Field
352 assert Foo._fields.keys() == ['some_field']
354 assert Foo._fields['some_field'] is some_field
355 As an implementation note, this metaclass inherits from
357 abc.ABCMeta (and not the usual type) to mitigate the metaclass
358 conflict (ImmutableMap and JSONDeSerializable, parents of
359 JSONObjectWithFields, use abc.ABCMeta as its metaclass).
360 class josepy.json_util.JSONObjectWithFields(**kwargs)
362 Bases: josepy.util.ImmutableMap, josepy.interfaces.JSONDeSerial‐
363 izable
364 JSON object with fields.
366 Example:
368 class Foo(JSONObjectWithFields):
370 bar = Field('Bar')
371 empty = Field('Empty', omitempty=True)
372 @bar.encoder
374 def bar(value):
375 return value + 'bar'
376 @bar.decoder
378 def bar(value):
379 if not value.endswith('bar'):
380 raise errors.DeserializationError('No bar suffix!')
381 return value[:-3]
382 assert Foo(bar='baz').to_partial_json() == {'Bar': 'bazbar'}
384 assert Foo.from_json({'Bar': 'bazbar'}) == Foo(bar='baz')
385 assert (Foo.from_json({'Bar': 'bazbar', 'Empty': '!'})
386 == Foo(bar='baz', empty='!'))
387 assert Foo(bar='baz').bar == 'baz'
388 classmethod _defaults()
390 Get default fields values.
391 encode(name)
393 Encode a single field.
394 Parameters
396 name (str) -- Name of the field to be encoded.
397 Raises
399 · errors.SerializationError -- if field cannot be
401 serialized
402 · errors.Error -- if field could not be found
404 fields_to_partial_json()
406 Serialize fields to JSON.
407 to_partial_json()
409 Partially serialize.
410 Following the example, partial serialization means the
412 following:
413 assert isinstance(Bar().to_partial_json()[0], Foo)
415 assert isinstance(Bar().to_partial_json()[1], Foo)
416 # in particular...
418 assert Bar().to_partial_json() != ['foo', 'foo']
419 Raises josepy.errors.SerializationError -- in case of any
421 serialization error.
422 Returns
424 Partially serializable object.
425 classmethod fields_from_json(jobj)
427 Deserialize fields from JSON.
428 classmethod from_json(jobj)
430 Deserialize a decoded JSON document.
431 Parameters
433 jobj -- Python object, composed of only other
434 basic data types, as decoded from JSON document.
435 Not necessarily dict (as decoded from "JSON
436 object" document).
437 Raises josepy.errors.DeserializationError -- if decoding
439 was unsuccessful, e.g. in case of unparseable X509
440 certificate, or wrong padding in JOSE base64
441 encoded string, etc.
442 josepy.json_util.encode_b64jose(data)
444 Encode JOSE Base-64 field.
445 Parameters
447 data (bytes) --
448 Return type
450 unicode
451 josepy.json_util.decode_b64jose(data, size=None, minimum=False)
453 Decode JOSE Base-64 field.
454 Parameters
456 · data (unicode) --
458 · size (int) -- Required length (after decoding).
460 · minimum (bool) -- If True, then size will be treated as
462 minimum required length, as opposed to exact equality.
463 Return type
465 bytes
466 josepy.json_util.encode_hex16(value)
468 Hexlify.
469 Parameters
471 value (bytes) --
472 Return type
474 unicode
475 josepy.json_util.decode_hex16(value, size=None, minimum=False)
477 Decode hexlified field.
478 Parameters
480 · value (unicode) --
482 · size (int) -- Required length (after decoding).
484 · minimum (bool) -- If True, then size will be treated as
486 minimum required length, as opposed to exact equality.
487 Return type
489 bytes
490 josepy.json_util.encode_cert(cert)
492 Encode certificate as JOSE Base-64 DER.
493 Return type
495 unicode
496 josepy.json_util.decode_cert(b64der)
498 Decode JOSE Base-64 DER-encoded certificate.
499 Parameters
501 b64der (unicode) --
502 Return type
504 OpenSSL.crypto.X509 wrapped in ComparableX509
505 josepy.json_util.encode_csr(csr)
507 Encode CSR as JOSE Base-64 DER.
508 Return type
510 unicode
511 josepy.json_util.decode_csr(b64der)
513 Decode JOSE Base-64 DER-encoded CSR.
514 Parameters
516 b64der (unicode) --
517 Return type
519 OpenSSL.crypto.X509Req wrapped in ComparableX509
520 class josepy.json_util.TypedJSONObjectWithFields(**kwargs)
522 Bases: josepy.json_util.JSONObjectWithFields
523 JSON object with type.
525 typ = NotImplemented
527 Type of the object. Subclasses must override.
528 type_field_name = 'type'
530 Field name used to distinguish different object types.
531 Subclasses will probably have to override this.
533 TYPES = NotImplemented
535 Types registered for JSON deserialization
536 classmethod register(type_cls, typ=None)
538 Register class for JSON deserialization.
539 classmethod get_type_cls(jobj)
541 Get the registered class for jobj.
542 to_partial_json()
544 Get JSON serializable object.
545 Returns
547 Serializable JSON object representing ACME typed
548 object. validate() will almost certainly not
549 work, due to reasons explained in josepy.inter‐
550 faces.IJSONSerializable.
551 Return type
553 dict
554 classmethod from_json(jobj)
556 Deserialize ACME object from valid JSON object.
557 Raises josepy.errors.UnrecognizedTypeError -- if type of
559 the ACME object has not been registered.
560
562 JSON Web Algorithms.
563 https://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-40
565 class josepy.jwa.JWA
567 Bases: josepy.interfaces.JSONDeSerializable
568 JSON Web Algorithm.
570 class josepy.jwa.JWASignature(name)
572 Bases: josepy.jwa.JWA, collections.abc.Hashable
573 Base class for JSON Web Signature Algorithms.
575 classmethod register(signature_cls)
577 Register class for JSON deserialization.
578 to_partial_json()
580 Partially serialize.
581 Following the example, partial serialization means the
583 following:
584 assert isinstance(Bar().to_partial_json()[0], Foo)
586 assert isinstance(Bar().to_partial_json()[1], Foo)
587 # in particular...
589 assert Bar().to_partial_json() != ['foo', 'foo']
590 Raises josepy.errors.SerializationError -- in case of any
592 serialization error.
593 Returns
595 Partially serializable object.
596 classmethod from_json(jobj)
598 Deserialize a decoded JSON document.
599 Parameters
601 jobj -- Python object, composed of only other
602 basic data types, as decoded from JSON document.
603 Not necessarily dict (as decoded from "JSON
604 object" document).
605 Raises josepy.errors.DeserializationError -- if decoding
607 was unsuccessful, e.g. in case of unparseable X509
608 certificate, or wrong padding in JOSE base64
609 encoded string, etc.
610 abstract sign(key, msg)
612 Sign the msg using key.
613 abstract verify(key, msg, sig)
615 Verify the msg and sig using key.
616 class josepy.jwa._JWAHS(name, hash_)
618 Bases: josepy.jwa.JWASignature
619 kty alias of josepy.jwk.JWKOct
621 sign(key, msg)
623 Sign the msg using key.
624 verify(key, msg, sig)
626 Verify the msg and sig using key.
627 class josepy.jwa._JWARS(name, hash_)
629 Bases: josepy.jwa._JWARSA, josepy.jwa.JWASignature
630 class josepy.jwa._JWAPS(name, hash_)
632 Bases: josepy.jwa._JWARSA, josepy.jwa.JWASignature
633 class josepy.jwa._JWAES(name)
635 Bases: josepy.jwa.JWASignature
636 sign(key, msg)
638 Sign the msg using key.
639 verify(key, msg, sig)
641 Verify the msg and sig using key.
642 josepy.jwa.HS256 = HS256
644 HMAC using SHA-256
645 josepy.jwa.HS384 = HS384
647 HMAC using SHA-384
648 josepy.jwa.HS512 = HS512
650 HMAC using SHA-512
651 josepy.jwa.RS256 = RS256
653 RSASSA-PKCS-v1_5 using SHA-256
654 josepy.jwa.RS384 = RS384
656 RSASSA-PKCS-v1_5 using SHA-384
657 josepy.jwa.RS512 = RS512
659 RSASSA-PKCS-v1_5 using SHA-512
660 josepy.jwa.PS256 = PS256
662 RSASSA-PSS using SHA-256 and MGF1 with SHA-256
663 josepy.jwa.PS384 = PS384
665 RSASSA-PSS using SHA-384 and MGF1 with SHA-384
666 josepy.jwa.PS512 = PS512
668 RSASSA-PSS using SHA-512 and MGF1 with SHA-512
669 josepy.jwa.ES256 = ES256
671 ECDSA using P-256 and SHA-256
672 josepy.jwa.ES384 = ES384
674 ECDSA using P-384 and SHA-384
675 josepy.jwa.ES512 = ES512
677 ECDSA using P-521 and SHA-512
678
680 JSON Web Key.
681 class josepy.jwk.JWK(**kwargs)
683 Bases: josepy.json_util.TypedJSONObjectWithFields
684 JSON Web Key.
686 cryptography_key_types = ()
688 Subclasses should override.
689 required = NotImplemented
691 Required members of public key's representation as
692 defined by JWK/JWA.
693 thumbprint(hash_function=<class 'cryptography.hazmat.primi‐
695 tives.hashes.SHA256'>)
696 Compute JWK Thumbprint.
697 https://tools.ietf.org/html/rfc7638
699 Returns
701 bytes
702 abstract public_key()
704 Generate JWK with public key.
705 For symmetric cryptosystems, this would return self.
707 classmethod load(data, password=None, backend=None)
709 Load serialized key as JWK.
710 Parameters
712 · data (str) -- Public or private key serialized
714 as PEM or DER.
715 · password (str) -- Optional password.
717 · backend -- A PEMSerializationBackend and DERSe‐
719 rializationBackend provider.
720 Raises errors.Error -- if unable to deserialize, or
722 unsupported JWK algorithm
723 Returns
725 JWK of an appropriate type.
726 Return type
728 JWK
729 class josepy.jwk.JWKES(**kwargs)
731 Bases: josepy.jwk.JWK
732 ES JWK.
734 WARNING:
736 This is not yet implemented!
737 fields_to_partial_json()
739 Serialize fields to JSON.
740 classmethod fields_from_json(jobj)
742 Deserialize fields from JSON.
743 public_key()
745 Generate JWK with public key.
746 For symmetric cryptosystems, this would return self.
748 class josepy.jwk.JWKOct(**kwargs)
750 Bases: josepy.jwk.JWK
751 Symmetric JWK.
753 fields_to_partial_json()
755 Serialize fields to JSON.
756 classmethod fields_from_json(jobj)
758 Deserialize fields from JSON.
759 public_key()
761 Generate JWK with public key.
762 For symmetric cryptosystems, this would return self.
764 class josepy.jwk.JWKRSA(*args, **kwargs)
766 Bases: josepy.jwk.JWK
767 RSA JWK.
769 Variables
771 key -- RSAPrivateKey or RSAPublicKey wrapped in Compara‐
772 bleRSAKey
773 classmethod _encode_param(data)
775 Encode Base64urlUInt.
776 Return type
778 unicode
779 classmethod _decode_param(data)
781 Decode Base64urlUInt.
782 public_key()
784 Generate JWK with public key.
785 For symmetric cryptosystems, this would return self.
787 classmethod fields_from_json(jobj)
789 Deserialize fields from JSON.
790 fields_to_partial_json()
792 Serialize fields to JSON.
793
795 JSON Web Signature.
796 class josepy.jws.MediaType
798 Bases: object
799 MediaType field encoder/decoder.
801 PREFIX = 'application/'
803 MIME Media Type and Content Type prefix.
804 classmethod decode(value)
806 Decoder.
807 classmethod encode(value)
809 Encoder.
810 class josepy.jws.Header(**kwargs)
812 Bases: josepy.json_util.JSONObjectWithFields
813 JOSE Header.
815 WARNING:
817 This class supports only Registered Header Parameter Names
818 (as defined in section 4.1 of the protocol). If you need Pub‐
819 lic Header Parameter Names (4.2) or Private Header Parameter
820 Names (4.3), you must subclass and override from_json() and
821 to_partial_json() appropriately.
822 WARNING:
824 This class does not support any extensions through the "crit"
825 (Critical) Header Parameter (4.1.11) and as a conforming
826 implementation, from_json() treats its occurrence as an
827 error. Please subclass if you seek for a different behaviour.
828 Variables
830 · x5tS256 -- "x5t#S256"
832 · typ (str) -- MIME Media Type, inc. MediaType.PREFIX.
834 · cty (str) -- Content-Type, inc. MediaType.PREFIX.
836 not_omitted()
838 Fields that would not be omitted in the JSON object.
839 find_key()
841 Find key based on header.
842
844 Supports only "jwk" header parameter lookup.
845 Returns
847 (Public) key found in the header.
848 Return type
850 JWK
851 Raises josepy.errors.Error -- if key could not be found
853 class josepy.jws.Signature(**kwargs)
855 Bases: josepy.json_util.JSONObjectWithFields
856 JWS Signature.
858 Variables
860 · combined -- Combined Header (protected and unprotected,
862 Header).
863 · protected (unicode) -- JWS protected header (Jose
865 Base-64 decoded).
866 · header -- JWS Unprotected Header (Header).
868 · signature (str) -- The signature.
870 header_cls
872 alias of Header
873 verify(payload, key=None)
875 Verify.
876 Parameters
878 key (JWK) -- Key used for verification.
879 classmethod sign(payload, key, alg, include_jwk=True, pro‐
881 tect=frozenset({}), **kwargs)
882 Sign.
883 Parameters
885 key (JWK) -- Key for signature.
886 fields_to_partial_json()
888 Serialize fields to JSON.
889 classmethod fields_from_json(jobj)
891 Deserialize fields from JSON.
892 class josepy.jws.JWS(**kwargs)
894 Bases: josepy.json_util.JSONObjectWithFields
895 JSON Web Signature.
897 Variables
899 · payload (str) -- JWS Payload.
901 · signature (str) -- JWS Signatures.
903 signature_cls
905 alias of Signature
906 verify(key=None)
908 Verify.
909 classmethod sign(payload, **kwargs)
911 Sign.
912 property signature
914 Get a singleton signature.
915 Return type
917 JWS.signature_cls
918 to_compact()
920 Compact serialization.
921 Return type
923 bytes
924 classmethod from_compact(compact)
926 Compact deserialization.
927 Parameters
929 compact (bytes) --
930 to_partial_json(flat=True)
932 Partially serialize.
933 Following the example, partial serialization means the
935 following:
936 assert isinstance(Bar().to_partial_json()[0], Foo)
938 assert isinstance(Bar().to_partial_json()[1], Foo)
939 # in particular...
941 assert Bar().to_partial_json() != ['foo', 'foo']
942 Raises josepy.errors.SerializationError -- in case of any
944 serialization error.
945 Returns
947 Partially serializable object.
948 classmethod from_json(jobj)
950 Deserialize a decoded JSON document.
951 Parameters
953 jobj -- Python object, composed of only other
954 basic data types, as decoded from JSON document.
955 Not necessarily dict (as decoded from "JSON
956 object" document).
957 Raises josepy.errors.DeserializationError -- if decoding
959 was unsuccessful, e.g. in case of unparseable X509
960 certificate, or wrong padding in JOSE base64
961 encoded string, etc.
962 class josepy.jws.CLI
964 Bases: object
965 JWS CLI.
967 classmethod sign(args)
969 Sign.
970 classmethod verify(args)
972 Verify.
973 classmethod run(args=None)
975 Parse arguments and sign/verify.
976
978 JOSE utilities.
979 class josepy.util.abstractclassmethod(target)
981 Bases: classmethod
982 Descriptor for an abstract classmethod.
984 It augments the abc framework with an abstract classmethod. This
986 is implemented as abc.abstractclassmethod in the standard Python
987 library starting with version 3.2.
988 This particular implementation, allegedly based on Python 3.3
990 source code, is stolen from
991 http://stackoverflow.com/questions/11217878/python-2-7-combine-abc-abstractmethod-and-classmethod.
992 class josepy.util.ComparableX509(wrapped)
994 Bases: object
995 Wrapper for OpenSSL.crypto.X509** objects that supports __eq__.
997 Variables
999 wrapped -- Wrapped certificate or certificate request.
1000 _dump(filetype=2)
1002 Dumps the object into a buffer with the specified encod‐
1003 ing.
1004 Parameters
1006 filetype (int) -- The desired encoding. Should be
1007 one of OpenSSL.crypto.FILETYPE_ASN1,
1008 OpenSSL.crypto.FILETYPE_PEM, or
1009 OpenSSL.crypto.FILETYPE_TEXT.
1010 Returns
1012 Encoded X509 object.
1013 Return type
1015 str
1016 class josepy.util.ComparableKey(wrapped)
1018 Bases: object
1019 Comparable wrapper for cryptography keys.
1021 See https://github.com/pyca/cryptography/issues/2122.
1023 public_key()
1025 Get wrapped public key.
1026 class josepy.util.ComparableRSAKey(wrapped)
1028 Bases: josepy.util.ComparableKey
1029 Wrapper for cryptography RSA keys.
1031 Wraps around:
1033 · RSAPrivateKey
1035 · RSAPublicKey
1037 class josepy.util.ImmutableMap(**kwargs)
1039 Bases: collections.abc.Mapping, collections.abc.Hashable
1040 Immutable key to value mapping with attribute access.
1042 update(**kwargs)
1044 Return updated map.
1045 class josepy.util.frozendict(*args, **kwargs)
1047 Bases: collections.abc.Mapping, collections.abc.Hashable
1048 Frozen dictionary.
1050
1052 1.2.0 (2019-06-28)
1053 · Support for Python 2.6 and 3.3 has been removed.
1054 · Known incompatibilities with Python 3.8 have been resolved.
1056 1.1.0 (2018-04-13)
1058 · Deprecated support for Python 2.6 and 3.3.
1059 · Use the sign and verify methods when they are available in cryptogra‐
1061 phy instead of the deprecated methods signer and verifier.
1062 1.0.1 (2017-10-25)
1064 Stop installing mock as part of the default but only as part of the
1065 testing dependencies.
1066 1.0.0 (2017-10-13)
1068 First release after moving the josepy package into a standalone
1069 library.
1070 · genindex
1072 · modindex
1074 · search
1076
1078 Let's Encrypt Project
1079
1081 2015-2019, Let's Encrypt Project
10821.2 Jul 26, 2019 JOSEPY(1)