+ @iVFRt^RIHt^RIt^RIt^RIt^RIt^RIHt^RI H t H t H t ^RI Ht^RIHtR%t]P$!]!tR&tR't]P,R(8dRtMRt]P,R)8dR tMR tR tR*R lt!R R4tRtRtRt]3Rlt]3Rlt Rt!Rt"Rt#Rt$Rt%Rt&Rt'Rt(Rt)Rt*Rt+Rt,!R R!]-4t.R"t/R#t0R$t1R#)+a This module includes some utility functions. The methods most typically used are the sigencode and sigdecode functions to be used with :func:`~ecdsa.keys.SigningKey.sign` and :func:`~ecdsa.keys.VerifyingKey.verify` respectively. See the :func:`sigencode_strings`, :func:`sigdecode_string`, :func:`sigencode_der`, :func:`sigencode_strings_canonize`, :func:`sigencode_string_canonize`, :func:`sigencode_der_canonize`, :func:`sigdecode_strings`, :func:`sigdecode_string`, and :func:`sigdecode_der` functions. )divisionN)sha256)PY2int2bytenext)der)normalise_bytesc\\PVR44R,P\ V4^,4#)-Convert a bytestring to string of 0's and 1'sbigNN)binint from_byteszfilllenent_256s&H/var/www/html/photoedit/myenv/lib/python3.14/site-packages/ecdsa/util.pyentropy_to_bitsr4s13>>'51226<"entropy_to_bits..<s*AAs3q6{2,,Q//s79)joinrs&rrr:swwAAAArc8\\V44^, #r )rrrs&r bit_lengthr$As3q6{Qrc6VP4;'g^#)r$r#s&rr$r$Fs||~"""rcB^\RV,4,^,#)r'z%x)r)orders&rorderlenr*Js D5L! !a ''rcV^8gQhVf\Pp\V^, 4pV^,^,pV!V4p\V4p\ VRV^R7^,p^Tu;8d V8gK<V#KB)aReturn a random integer k such that 1 <= k < order, uniformly distributed across that range. Worst case should be a mean of 2 loops at (2**k)+2. Note that this function is not declared to be forwards-compatible: we may change the behavior in future releases. The entropy= argument (which should get a callable that behaves like os.urandom) can be used to achieve stability within a given release (for repeatable unit tests), but should not be used as a long-term-compatible key generation algorithm. N)base)osurandomr$rr)r)entropyupper_2 upper_256rent_2rand_nums&& r randranger4Ns 199**#G1 q I )$(uXgQ/!3 x % O rc2a]tRt^ftoRtRtRtRtVtR#)PRNGc2VPV4VnR#N)block_generator generator)selfseeds&&r__init__ PRNG.__init__ls--d3rc\V4Uu.uFp\VP4NK pp\'dRP V4#\ V4#uupi)r)rangerr:rr bytes)r;numbytesias&& r__call__ PRNG.__call__osD+0? ;?aT$.. !? ; 3771: 8O rc.\WV4wr4W4,#)a Encode the signature to raw format (:term:`raw encoding`) It's expected that this function will be used as a ``sigencode=`` parameter in :func:`ecdsa.keys.SigningKey.sign` method. :param int r: first parameter of the signature :param int s: second parameter of the signature :param int order: the order of the curve over which the signature was computed :return: raw encoding of ECDSA signature :rtype: bytes )rrs&&& rsigencode_stringrs"%Q51LE =rc\P!\P!V4\P!V44#)aO Encode the signature into the ECDSA-Sig-Value structure using :term:`DER`. Encodes the signature to the following :term:`ASN.1` structure:: Ecdsa-Sig-Value ::= SEQUENCE { r INTEGER, s INTEGER } It's expected that this function will be used as a ``sigencode=`` parameter in :func:`ecdsa.keys.SigningKey.sign` method. :param int r: first parameter of the signature :param int s: second parameter of the signature :param int order: the order of the curve over which the signature was computed :return: DER encoding of ECDSA signature :rtype: bytes )rencode_sequenceencode_integerrrr)s&&&r sigencode_derrs-,   s11!4c6H6H6K LLrc0W^,8d W, pV#)a Internal function for ensuring that the ``s`` value of a signature is in the "canonical" format. :param int s: the second parameter of ECDSA signature :param int order: the order of the curve over which the signatures was computed :return: canonical value of s :rtype: int r[)rr)s&&r _canonizer3s A:~ I Hrc0\W4p\WV4#)a Encode the signature to a pair of strings in a tuple Encodes signature into raw encoding (:term:`raw encoding`) with the ``r`` and ``s`` parts of the signature encoded separately. Makes sure that the signature is encoded in the canonical format, where the ``s`` parameter is always smaller than ``order / 2``. Most commonly used in bitcoin. It's expected that this function will be used as a ``sigencode=`` parameter in :func:`ecdsa.keys.SigningKey.sign` method. :param int r: first parameter of the signature :param int s: second parameter of the signature :param int order: the order of the curve over which the signature was computed :return: raw encoding of ECDSA signature :rtype: tuple(bytes, bytes) )rrrs&&&rsigencode_strings_canonizerDs, !A Q5 ))rc0\W4p\WV4#)aC Encode the signature to raw format (:term:`raw encoding`) Makes sure that the signature is encoded in the canonical format, where the ``s`` parameter is always smaller than ``order / 2``. Most commonly used in bitcoin. It's expected that this function will be used as a ``sigencode=`` parameter in :func:`ecdsa.keys.SigningKey.sign` method. :param int r: first parameter of the signature :param int s: second parameter of the signature :param int order: the order of the curve over which the signature was computed :return: raw encoding of ECDSA signature :rtype: bytes )rrrs&&&rsigencode_string_canonizer^s& !A A% ((rc0\W4p\WV4#)a Encode the signature into the ECDSA-Sig-Value structure using :term:`DER`. Makes sure that the signature is encoded in the canonical format, where the ``s`` parameter is always smaller than ``order / 2``. Most commonly used in bitcoin. Encodes the signature to the following :term:`ASN.1` structure:: Ecdsa-Sig-Value ::= SEQUENCE { r INTEGER, s INTEGER } It's expected that this function will be used as a ``sigencode=`` parameter in :func:`ecdsa.keys.SigningKey.sign` method. :param int r: first parameter of the signature :param int s: second parameter of the signature :param int order: the order of the curve over which the signature was computed :return: DER encoding of ECDSA signature :rtype: bytes )rrrs&&&rsigencode_der_canonizerus4 !A u %%rc]tRtRtRtRtR#)MalformedSignatureia* Raised by decoding functions when the signature is malformed. Malformed in this context means that the relevant strings or integers do not match what a signature over provided curve would create. Either because the byte strings have incorrect lengths or because the encoded values are too large. r[N)rNrOrPrQ__doc__rRr[rrrrs  rrc\V4p\V4p\V4^V,8Xg,\RP ^V,\V444h\ VRVV4p\ WRV4pW43#)a Decoder for :term:`raw encoding` of ECDSA signatures. raw encoding is a simple concatenation of the two integers that comprise the signature, with each encoded using the same amount of bytes depending on curve size/order. It's expected that this function will be used as the ``sigdecode=`` parameter to the :func:`ecdsa.keys.VerifyingKey.verify` method. :param signature: encoded signature :type signature: bytes like object :param order: order of the curve over which the signature was computed :type order: int :raises MalformedSignature: when the encoding of the signature is invalid :return: tuple with decoded ``r`` and ``s`` values of signature :rtype: tuple of ints zWInvalid length of signature, expected {0} bytes long, provided string is {1} bytes longN)rr*rrformatr) signaturer)ryrrs&& rsigdecode_stringrsx* *IA y>QU "  006q1uc)n0M   ")BQ-7A!)B-7A 4Krc\V4^8Xg$\RP\V444hVwr#\V4p\V4p\ V4p\V4V8Xg%\RPV\V444h\V4V8Xg%\RPV\V444h\ W!4p\ W14pWV3#)a Decode the signature from two strings. First string needs to be a big endian encoding of ``r``, second needs to be a big endian encoding of the ``s`` parameter of an ECDSA signature. It's expected that this function will be used as the ``sigdecode=`` parameter to the :func:`ecdsa.keys.VerifyingKey.verify` method. :param list rs_strings: list of two bytes-like objects, each encoding one parameter of signature :param int order: order of the curve over which the signature was computed :raises MalformedSignature: when the encoding of the signature is invalid :return: tuple with decoded ``r`` and ``s`` values of signature :rtype: tuple of ints z3Invalid number of strings provided: {0}, expected 2zjInvalid length of first string ('r' parameter), expected {0} bytes long, provided string is {1} bytes longzkInvalid length of second string ('s' parameter), expected {0} bytes long, provided string is {1} bytes long)rrrrr*r) rs_stringsr)rrryrrs&& rsigdecode_stringsrs& z?a  A H HJ    NU E "E E "EA u:?  3u:.  u:?  3u:.  "%/A!%/A 4Krc\V4p\P!V4wr#VR8wd2\P!R\P !V4,4h\P !V4wrE\P !V4wrcVR8wd2\P!R\P !V4,4hWF3#)a Decoder for DER format of ECDSA signatures. DER format of signature is one that uses the :term:`ASN.1` :term:`DER` rules to encode it as a sequence of two integers:: Ecdsa-Sig-Value ::= SEQUENCE { r INTEGER, s INTEGER } It's expected that this function will be used as as the ``sigdecode=`` parameter to the :func:`ecdsa.keys.VerifyingKey.verify` method. :param sig_der: encoded signature :type sig_der: bytes like object :param order: order of the curve over which the signature was computed :type order: int :raises UnexpectedDER: when the encoding of signature is invalid :return: tuple with decoded ``r`` and ``s`` values of signature :rtype: tuple of ints rztrailing junk after DER sig: %sz#trailing junk after DER numbers: %s)rrremove_sequence UnexpectedDERrVrWremove_integer)sig_derr)remptyrrestrs&& r sigdecode_derrs2g&G++G4J | -0@0@0G G    ,GA!!$'HA | 1H4D4DU4K K   4Kr)r'r iHi='r r')r'r' )r'rrr' )r)r r8)2r __future__rr-r_rVsyshashlibrsixrrrrr_compatroid_ecPublicKey encode_oidencoded_oid_ecPublicKeyoid_ecDH oid_ecMQV version_inforr$r*r4r6rYr]rcrhrlrrr|r~rnrrrrrrrr Exceptionrrrrr[rrrs   ##$+../:   tO B f #(06 "&>D =C &-- .*M2 "*4).&<    B+\&r