5i SSKJr SSKrSSKrSSKrSSKJrJrJrJ r J r SSK J r SSK JrJrJrJr SSKJrJrJr SSKJrJr SSKJr S S KJrJrJr S S KJr "S S \!5r""SS\#5r$Sr%Sr&S'Sjr'Sr(S(Sjr)Sr*Sr+Sr,Sr-Sr.Sr/Sr0Sr1Sr2S'Sjr3\4S:XaSSK5r5S r6\S!RnRq5r9S"r:\5Rj"5r;\<"\:5Hr=\9\6-r>M \?"S#\5Rj"5\;- \:- S$-S%5 \5Rj"5r;\<"\:5Hr=\>\6-r>M \?"S&\5Rj"5\;- \:- S$-S%5 gg)))print_functionN)bordtobytestostrbchr is_string)Integer) DerObjectIdDerOctetString DerSequence DerBitString)_expand_subject_public_key_info_create_subject_public_key_info _extract_subject_public_key_info)SHA512SHAKE256)get_random_bytes)EccPoint EccXPoint_curves)CurveIDc\rSrSrSrg)UnsupportedEccFeature7N)__name__ __module__ __qualname____firstlineno____static_attributes__rb/var/www/html/BTCUSD/btcusdt_trading_app/venv/lib/python3.13/site-packages/Crypto/PublicKey/ECC.pyrr7sr"rc\rSrSrSrSrSrSrSrSr Sr \ S 5r \ S 5r \ S 5rS rS rSrSrSrSSjrSrSrSrSrSrSrSrSrg)EccKey;aClass defining an ECC key. Do not instantiate directly. Use :func:`generate`, :func:`construct` or :func:`import_key` instead. :ivar curve: The **canonical** name of the curve as defined in the `ECC table`_. :vartype curve: string :ivar pointQ: an ECC point representing the public component. :vartype pointQ: :class:`EccPoint` or :class:`EccXPoint` :ivar d: A scalar that represents the private component in NIST P curves. It is smaller than the order of the generator point. :vartype d: integer :ivar seed: A seed that represents the private component in Ed22519 (32 bytes), Curve25519 (32 bytes), Curve448 (56 bytes), Ed448 (57 bytes). :vartype seed: bytes c [U5nURSS5nURSS5UlURSS5UlURSS5UlUc'UR(aURR nU(a[ S[U5-5eU[;a[SU-5e[UUl URRUl[URSL5[URSL5-nUS:XaURc [S 5egUS :Xa [S 5eURR[R:XaURb [S 5e[!UR5S :wa [S5e["R$"UR5R'5nUS SUl[+USS 5nUS==S-ss'USS-S-US'[,R."USS9UlgURR[R0:XaURb [S 5e[!UR5S:wa [S5e[2R$"UR5R5S5nUSSUl[+USS5nUS==S-ss'US==S-ss'SUS'[,R."USS9UlgURR[R6:XaURb [S 5e[!UR5S :wa [S5e[+UR5nUS==S-ss'USS-S-US'[,R."USS9UlgURR[R8:XaURb [S 5e[!UR5S:wa [S5e[+UR5nUS==S-ss'US==S-ss'[,R."USS9UlgURb [S5e[-UR5UlSURs=::aURR::d O [S 5eg)!a(Create a new ECC key Keywords: curve : string The name of the curve. d : integer Mandatory for a private key one NIST P curves. It must be in the range ``[1..order-1]``. seed : bytes Mandatory for a private key on Ed25519 (32 bytes), Curve25519 (32 bytes), Curve448 (56 bytes) or Ed448 (57 bytes). point : EccPoint or EccXPoint Mandatory for a public key. If provided for a private key, the implementation will NOT check whether it matches ``d``. Only one parameter among ``d``, ``seed`` or ``point`` may be used. curveNdseedpointUnknown parameters: zUnsupported curve (%s)rzGAt lest one between parameters 'point', 'd' or 'seed' must be specifiedz,Parameters d and seed are mutually exclusivez/Parameter d can only be used with NIST P curves z0Parameter seed must be 32 bytes long for Ed25519@little byteorder9z.Parameter seed must be 57 bytes long for Ed448rr8z3Parameter seed must be 32 bytes long for Curve25519z1Parameter seed must be 56 bytes long for Curve448z2Parameter 'seed' cannot be used with NIST P-curvesrz;Parameter d must be an integer smaller than the curve order)dictpop_d_seed_pointr( TypeErrorstrr ValueError_curve canonicalintid_CurveIDED25519lenrnewdigest_prefix bytearrayr from_bytesED448rread CURVE25519CURVE448order)selfkwargskwargs_ curve_namecount seed_hashtmps r#__init__EccKey.__init__Qs&v,[[$/ ++c4([[. kk'40  $++**J 2S\AB B W $5 BC Cj) [[** DGG4'(3tzz/E+FF A:{{" !jkk  A:KL L ;;>>X-- -ww" !RSS4::"$ !STT 4::.557I$RS>DLIcrN+C FdNF2w~-CG((ADG [[^^x~~ -ww" !RSS4::"$ !QRR TZZ055c:I$RS>DLIcrN+C FdNF GtOGCG((ADG [[^^x22 2ww" !RSS4::"$ !VWWDJJ'C FdNF2w~-CG((ADG [[^^x00 0ww" !RSS4::"$ !TUUDJJ'C FdNF GtOG((ADGzz% !UVVdgg&DG3$++"3"33 !^__4r"c[U[5(dgUR5UR5:wagURUR:H$)NF) isinstancer% has_privatepointQ)rTothers r#__eq__ EccKey.__eq__sB%((    $"2"2"4 4||t{{**r"c4UR5(aaURR(a-S[[R "UR 55-nOS[UR5-nOSnURR[R[R4;a3URRnSURRX!4-nU$URR up$SURRX$U4-nU$)Nz , seed=%sz, d=%dz EccKey(curve='%s', point_x=%d%s)z,EccKey(curve='%s', point_x=%d, point_y=%d%s))r_rC is_edwardsrbinasciihexlifyr>rEr=rFrGrQrRr`xrDxy)rTextrariresultys r#__repr__EccKey.__repr__s     {{%%#eH,<,>h11&//1 1 A74;;;P;PRS:[[F ;;>>DACt{{G\G\^_diFjjF r"cURSL$)zJ``True`` if this key can be used for making signatures or decrypting data.N)r=rTs r#r_EccKey.has_privateswwd""r"cXSUs=:aURR:de eURRn[R"SUS9nURU-nXB-R U5nURR U-RU-nXdU-XW---U-nXx4$)Nrr) min_inclusive max_exclusive)rCrSr random_ranger=inverseGri) rTzkrSblindblind_d inv_blind_krss r#_sign EccKey._signs1(t{{((((((( !!$$138:''E/y))%0 [[]]Q  ! !E ) 19w{2 3e ;v r"cURRnUSRU5nURRXA-U--nURXBS-U--nXV-R US:H$)Nrr)rCrSrwrxr`ri)rTryrsrSsinvpoint1point2s r#_verifyEccKey._verifysl !!!u}}U#48u"451 67""be++r"cZUR5(d [S5eUR$NzThis is not a private ECC key)r_rBr=rqs r#r)EccKey.ds&!!<= =wwr"cZUR5(d [S5eUR$r)r_rBr>rqs r#r* EccKey.seeds'!!<= =zzr"cURc(URRUR-UlUR$N)r?rCrxr=rqs r#r` EccKey.pointQs. ;; ++--$''1DK{{r"cR[URRURS9$)zFA matching ECC public key. Returns: a new :class:`EccKey` object )r(r+)r%rCrDr`rqs r# public_keyEccKey.public_keysDKK11EEr"cURR(d [S5eURR 5nU(aXURR R 5(aSnOSnUURRRU5-nU$SURRRU5-URR RU5-nU$)Nz/SEC1 format is only supported for NIST P curves) rCis_weierstrassrBr` size_in_bytesrmis_oddrito_bytes)rTcompress modulus_bytes first_byters r# _export_SEC1EccKey._export_SEC1s{{))NO O 113 {{}}##%%$ $ $++--00?@J "++--00?@++--00?@Jr"cURRupURR[R :Xa+[ URSSS95nUS-S-US-US'OXURR[R:Xa%[ URSSS95nUS-S-US'O [S 5e[U5$) Nr.r3r4rr0r6r:zNot an EdDSA key to export) r`rjrCrFrGrHrMrrOrBbytes)rTrirmrls r#_export_eddsa_publicEccKey._export_eddsa_public s{{~~ ;;>>X-- -qzz"zABFq5Q,&*4F2J [[^^x~~ -qzz"zABFa%AF2J9: :V}r"cURR(d [S5eURRnURR 5n[ URUSS95n[U5$)NzNot a Montgomery key to exportr3r4) rC is_montgomeryrBr`rirrMrr)rTri field_sizerls r#_export_montgomery_public EccKey._export_montgomery_public,s[{{((=> > KKMM[[..0 1::jH:EFV}r"cURR(a)URRnUR5nSnOvURR(a)URRnUR 5nSnO2SnUR U5n[URR5n[UUU5$)N1.2.840.10045.2.1) rCrfoidrrrrr r)rTrrrparamss r#_export_subjectPublicKeyInfo#EccKey._export_subjectPublicKeyInfo4s ;; ! !++//C224JF [[ & &++//C779JF%C**84J 1F.s/9/57 7r"cUR5(deURR5nSURRR U5-URR R U5-nS[ URR U55[URRSS9[USS9/nU(dUS [U5R5$)Nrrrexplicitr-)r_r`rrirrmr r)r rCrr r encode)rTinclude_ec_paramsrrseqs r#_export_rfc5915_private_der"EccKey._export_rfc5915_private_derFs!!!! 113 kkmm,,];<kkmm,,];< dffoom<=4;;??Q7J35 !A3&&((r"c xSSKJn URSS5bSU;a [S5eURb<UR R n[UR5R5nSnO0SnURSS9n[UR R 5nUR"UU4S U0UD6nU$) NrPKCS8 passphrase protectionz3At least the 'protection' parameter must be presentrF)r key_params) Crypto.IOrgetrBr>rCrr rrr wrap)rTrUrr private_keyrrls r# _export_pkcs8EccKey._export_pkcs8as# ::lD ) 5,f:TRS S :: !++//C(4;;=KF%C::U:SK 1FK&'-&%& r"cTSSKJn URU5nURUS5$)NrPEMz PUBLIC KEY)rrrr)rTrr encoded_ders r#_export_public_pemEccKey._export_public_pemvs&!77A zz+|44r"c XSSKJn UR5nUR"USU40UD6$)NrrzEC PRIVATE KEY)rrrrrTrrUrrs r#_export_private_pemEccKey._export_private_pem|s,!668 zz+'7NvNNr"cRSSKJn UR5nURUS5$)Nrrz PRIVATE KEY)rrrr)rTrrs r#(_export_private_clear_pkcs8_in_clear_pem/EccKey._export_private_clear_pkcs8_in_clear_pems$!((* zz+}55r"c SSKJn U(deSU;a [S5eUR"SSU0UD6nUR US5$)Nrrrz5At least the 'protection' parameter should be presentrzENCRYPTED PRIVATE KEYr)rrrBrrrs r#,_export_private_encrypted_pkcs8_in_clear_pem3EccKey._export_private_encrypted_pkcs8_in_clear_pemsK!z v %TU U((IJI&I zz+'>??r"c UR5(a [S5eURRnUc[SUR-5eUS:Xa'UR 5n[ U5[ U54nOURR5nU(aYSURRR5-n[U5URRRU5-nONSURRRU5-URRRU5-nURS5Sn[ U5[ U5U4nSRUVs/sH&n[ R""S[%U55U-PM( sn5n US -['[(R*"U 55-$s snf) Nz"Cannot export OpenSSH private keysz Cannot export %s keys as OpenSSH ssh-ed25519r-r-r">I )r_rBrCopensshr(rrr`rrmrrrirsplitjoinstructpackrIrrg b2a_base64) rTrdescrcompsrrmiddleriblobs r#_export_opensshEccKey._export_opensshs     AB B{{"" <?$**LM M ] "224JT]GJ$78E KK557M!5!5!77 ":."kkmm44]CD &"kkmm44]CD"kkmm44]CD ZZ_Q'FT]GFOZ@ExxF1T3q62Q6FGczE("5"5d";<<<Gs-Gc UR5nURS5nUS;a[SU-5eURSS5nUR5(GaUURSS5n[ U5(a[ U5nU(d [S5eURS S 5nUSLa]UR R(a [S 5eUR R(a [S 5eS U;a [S5eUS:XaDU(a*U(aUR"U40UD6$UR5$UR"U40UD6$US:XaDU(aU(d [S5eU(aUR"SSU0UD6$UR5$[SU-5eU(a[SU-5eUS:XaURU5$US:XaURU5$US:XaUR!U5$US:XagUR R(aUR#5$UR R(aUR%5$UR!U5$UR'U5$)a Export this ECC key. Args: format (string): The output format: - ``'DER'``. The key will be encoded in ASN.1 DER format (binary). For a public key, the ASN.1 ``subjectPublicKeyInfo`` structure defined in `RFC5480`_ will be used. For a private key, the ASN.1 ``ECPrivateKey`` structure defined in `RFC5915`_ is used instead (possibly within a PKCS#8 envelope, see the ``use_pkcs8`` flag below). - ``'PEM'``. The key will be encoded in a PEM_ envelope (ASCII). - ``'OpenSSH'``. The key will be encoded in the OpenSSH_ format (ASCII, public keys only). - ``'SEC1'``. The public key (i.e., the EC point) will be encoded into ``bytes`` according to Section 2.3.3 of `SEC1`_ (which is a subset of the older X9.62 ITU standard). Only for NIST P-curves. - ``'raw'``. The public key will be encoded as ``bytes``, without any metadata. * For NIST P-curves: equivalent to ``'SEC1'``. * For Ed25519 and Ed448: ``bytes`` in the format defined in `RFC8032`_. * For Curve25519 and Curve448: ``bytes`` in the format defined in `RFC7748`_. passphrase (bytes or string): (*Private keys only*) The passphrase to protect the private key. use_pkcs8 (boolean): (*Private keys only*) If ``True`` (default and recommended), the `PKCS#8`_ representation will be used. It must be ``True`` for Ed25519, Ed448, Curve25519, and Curve448. If ``False`` and a passphrase is present, the obsolete PEM encryption will be used. protection (string): When a private key is exported with password-protection and PKCS#8 (both ``DER`` and ``PEM`` formats), this parameter MUST be present, For all possible protection schemes, refer to :ref:`the encryption parameters of PKCS#8`. It is recommended to use ``'PBKDF2WithHMAC-SHA512AndAES128-CBC'``. compress (boolean): If ``True``, the method returns a more compact representation of the public key, with the X-coordinate only. If ``False`` (default), the method returns the full public key. This parameter is ignored for Ed25519/Ed448/Curve25519/Curve448, as compression is mandatory. prot_params (dict): When a private key is exported with password-protection and PKCS#8 (both ``DER`` and ``PEM`` formats), this dictionary contains the parameters to use to derive the encryption key from the passphrase. For all possible values, refer to :ref:`the encryption parameters of PKCS#8`. The recommendation is to use ``{'iteration_count':21000}`` for PBKDF2, and ``{'iteration_count':131072}`` for scrypt. .. warning:: If you don't provide a passphrase, the private key will be exported in the clear! .. note:: When exporting a private key with password-protection and `PKCS#8`_ (both ``DER`` and ``PEM`` formats), any extra parameters to ``export_key()`` will be passed to :mod:`Crypto.IO.PKCS8`. .. _PEM: http://www.ietf.org/rfc/rfc1421.txt .. _`PEM encryption`: http://www.ietf.org/rfc/rfc1423.txt .. _OpenSSH: http://www.openssh.com/txt/rfc5656.txt .. _RFC5480: https://tools.ietf.org/html/rfc5480 .. _SEC1: https://www.secg.org/sec1-v2.pdf .. _RFC7748: https://tools.ietf.org/html/rfc7748 Returns: A multi-line string (for ``'PEM'`` and ``'OpenSSH'``) or ``bytes`` (for ``'DER'``, ``'SEC1'``, and ``'raw'``) with the encoded key. format)rDEROpenSSHSEC1rawzUnknown format '%s'rFrNzEmpty passphrase use_pkcs8Tz%'pkcs8' must be True for EdDSA curvesz#'pkcs8' must be True for Curve25519rz)'protection' is only supported for PKCS#8rrz8Private keys can only be encrpyted with DER using PKCS#8z2Private keys cannot be exported in the '%s' formatzUnexpected parameters: '%s'rrr)copyr<rBr_rrrCrfrrrrrrrrrrrr)rTrUargs ext_formatrrrs r# export_keyEccKey.export_keysXt{{}XXh' E E2Z?@ @88J.     ,5J$$$Z0 !$%788d3IE!;;))$%LMM;;,,$%JKK4'$%PQQU"!#PPQ[d_cdd#LLNN33JG$GGu$i$%_``--LLtLL;;== "68B"CDD !>!EFFU"..x88u$88BBv%((22u$;;))4466[[..99;;,,X66++H55r")rCr=r?rLr>r(N)T)rrrr __doc__r[rbrnr_rrpropertyr)r*r`rrrrrrrrrrrrrr!rr"r#r%r%;s*``D+"# ,   F8 7$)6*5 O 6 @=:U6r"r%c <URS5n[UnURS[5nU(a[S[ U5-5e[UR [ R:XaU"S5n[XS9nU$[UR [ R:XaU"S5n[XS9nU$[UR [ R:Xa5U"S5n[XS9n[URUR5 U$[UR [ R:Xa5U"S5n[XS9n[URUR5 U$[R"SUR US 9n[XS 9nU$) aGenerate a new private key on the given curve. Args: curve (string): Mandatory. It must be a curve name defined in the `ECC table`_. randfunc (callable): Optional. The RNG to read randomness from. If ``None``, :func:`Crypto.Random.get_random_bytes` is used. r(randfuncr,r.r(r*r6r:r)rtrur)r(r))r<rrr@rArFrGrHr%rOrQvalidater`rRr rvrS)rUrWr(rr*new_keyr)s r#generaterFsrG$J J Ezz*&67H .V<==z!1!11|z5$ N#    8>> 1|z5 N    8#6#6 6|z5 $$W^^4 N    8#4#4 4|z5 $$W^^4 N  q/4{{*2 4z/ Nr"c USn[UnURSS5nURSS5nSU;a [S5eUR[R :Xa9Ub[ X15US'[S0UD6nURUR5 U$UR[R:Xa9Ub[ X15US'[S0UD6nURUR5 U$SX44;a[X4U5US'[S0UD6nUR5(a;SU;a5URUR-nURX44:wa [!S5eU$) ayBuild a new ECC key (private or public) starting from some base components. In most cases, you will already have an existing key which you can read in with :func:`import_key` instead of this function. Args: curve (string): Mandatory. The name of the elliptic curve, as defined in the `ECC table`_. d (integer): Mandatory for a private key and a NIST P-curve (e.g., P-256). It must be an integer in the range ``[1..order-1]``. seed (bytes): Mandatory for a private key and curves Ed25519 (32 bytes), Curve25519 (32 bytes), Curve448 (56 bytes) and Ed448 (57 bytes). point_x (integer): The X coordinate (affine) of the ECC point. Mandatory for a public key. point_y (integer): The Y coordinate (affine) of the ECC point. Mandatory for a public key, except for Curve25519 and Curve448. Returns: :class:`EccKey` : a new ECC key object r(point_xNpoint_yr+zUnknown keyword: pointz(Private and public ECC keys do not matchr)rr<r@rFrGrQrr%rr`rRrr_rxr)rjrB)rUrWr(rrrpub_keys r# constructrpsVBJ J EjjD)GjjD)G&011 xx8&&&  '#;<J %&CD"$?@H  DsJK K :# ,,V4::I "(@@ .8o+  G#MN N&x0Z@@ ,4M)  G#MN N !( +55$$=$CDD9 :89 9 :s #C--Dc[5RUSS9nUSS:wa [S5e[5RUS5RnSnU[ U5:a?[ SS9RX55RnUbXb:wa [S5eUnUS- nUc [S 5e[R"5HupxURU:XdM O [S U-5eURR5n [ U5U :wa [S 5eS=pU[ U5:a_[SS9RX55Rn [XS 9n U R R"n U R R$n US- n[&R("U5n[+X~XS 9$![a GNf=f![a N=f=f)Nr-rr) nr_elementsrrz!Incorrect ECC private key versionr-rzCurve mismatchzNo curve foundrzPrivate key is too smallr)r(r)rr)r rrBr payloadrIr rrrrrrrr rr`rirmr rNr)rrr ec_private_key scalar_bytes next_element parametersrWr(rrrpublic_key_encrr)s r#_import_rfc5915_derr.2s!]))'y)INaA<==!#**>!+<=EELLc.)) $a0778TU[[J$)@ !122"I A L)**$]]_ 99 ! -$$E $QRRGG))+M <M)344Gc.)) )15<<^=YZ``N+NPJ ''))G ''))G A L <(A :G MM;   2   s%%>F46AG4 GG GGcSSKJn URX5up4nSnSSS.nSSS .nX6;a/[5R U5R n [ XAU 5$X7;a?Ub [S 5eSn [5R U5Rn [XsU S 9$X8;aFXn Ub[S U -5eSn [5R U5Rn [XU S 9$[S U-5e)Nrrrrrrrrrz.EdDSA ECC private key must not have parametersrz+%s ECC private key must not have parametersz!Unsupported ECC purpose (OID: %s)) rrunwrapr rrr.rBr r(rr) rrralgo_oidrrrr r!r r*rWs r# _import_pkcs8r2ms$)LL$E!H6K !J $!H M((066 ";IFF    MN N &&{3;;z3$??  '  J'() ) &&{3;;x1==#$G($RSSr"c.[U5n[U5$r)rr$)rrUsp_infos r#_import_x509_certr5s.w7G ' 00r"c[X5$![anUeSnAf[[[4a Of=f[ X5$![anUeSnAf[[[4a Of=f[ X5$![anUeSnAf[[[4a Of=f[X5$![anUeSnAf[[[4a Of=f[S5e)NzNot an ECC DER key)r$rrBr@ IndexErrorr5r.r2)rrerrs r# _import_derr9s +G@@   : .     55   : .    "777   : .    W11   : .    ) **sm 444 A A* AA*)A*. A99 B BB B $ B// C9B;;CCcURS5n[U5S;a [S5e[R"US5n/n[U5S:aM[ R "SUSS5SnURUSSU-5 USU-Sn[U5S:aMMUSUS:wa [S5eUSRS 5(a[R"5HhupVURcMURRS 5(dM6[URRS 5S 5nUSU:XdMh O [S W-5e[US URS9nU$USS:Xa[US5up[!SXS9nU$[SUS-5e!["[$[R&4a [SUS-5ef=f)N rzNot an openssh public keyrrrrzMismatch in openssh public key ecdsa-sha2- ecdsa-sha2rr-zUnsupported ECC curve: r ssh-ed25519rrzUnsupported SSH key type: zError parsing SSH key type: )rrIrBrg a2b_base64runpackappend startswithrrrrrrrrr7r@Error) rparts keystringkeypartslkrWr(recc_keyrirms r#_import_openssh_publicrIs MM$ E 5z455$D''a1 )nq tYr]3A6B OOIaB/ 0!!b&'*I)nq 8x{ "=> > 8  ~ . .%,]]_! ==(}}// == !4!4S!9!!<=A;&(&5!!:V!CDD(! JG N1X '-hqk:DAiFG N 9E!HDE E  8>> 2D7%(BCCDs%A5F2$B)F2)F2<#F2!F221G#cSSKJnJnJnJn U"X5upgSS[ S40nUR S5(aU"U5upU [;a[SU -5e[U n U RS-S -n U"U5up[U S 5S :wa [S 5e[U 5S U -S-:wa [S5e[R"U SSU -5n [R"U SU -S5nU"U5up[R"U5nUU S.nOEXh;a2XunnnU"U5upU"U 5upU"U5unnUSUnUUS.nO[SU-5eU"U5unnU"U5 [SXS.UD6$)Nr)import_openssh_private_generic read_bytes read_string check_paddingrrr.r=zUnsupported ECC curve %srrrz/Only uncompressed OpenSSH EC keys are supportedr-zIncorrect public key length)r)r()r*r(zUnsupport SSH agent key type:)rrr)_opensshrKrLrMrNrrBrr modulus_bitsrrBrIr rNr)datapasswordrKrLrMrNkey_type decrypted eddsa_keysecdsa_curve_namer(rrrrrr)rrWr"seed_lenprivate_public_keyr*_paddeds r#_import_openssh_private_eccr\sCC9HH  #=rBJ <((&1)&<# 7 *'(BEU(UV V()++a/A5 *9 5  1 ! #NO O z?a-/!3 3:; ;$$Z!M/%BC$$Z-0@%AB!+I!6   { +#34  8B8L5 +X *9 5 2:>(29(=%I!)8,488CDDI&IAv&  @W @ @@r"c[U5S:wa [S5e[S5nSn[U5nUSS- nUS==S-ss'[R"USS 9nXQ:a [S 5eUS :Xag US -S - U-nUS -U-U-S -U-nUR U5nXh-U-n [R "X5n U S -U:waX- n X4$![a [S5ef=f)aAImport an Ed25519 ECC public key, encoded as raw bytes as described in RFC8032_. Args: encoded (bytes): The Ed25519 public key to import. It must be 32 bytes long. Returns: x and y (integer) Raises: ValueError: when the given key cannot be parsed. .. _RFC8032: https://datatracker.ietf.org/doc/html/rfc8032 r.z9Incorrect length. Only Ed25519 public keys are supported.llx&(7Z/ ;(P8se:8 w6Rr0rr1r3r4zInvalid Ed25519 key (y)rrrr-zInvalid Ed25519 public key)rIrBr rMrNrw_tonelli_shanks rrr)rmx_lsbruvv_invx2rs r#rr!s" 7|rTUURSAUA'A bEQJEbETME  h7G|233!| !a1A 1*q.A  !Q&A7 ! i1_))"0 aKE !kG   75667s ;CC%c[U5S:wa [S5e[U5nUS==S-ss'[R"USS9nU$)a@Import a Curve25519 ECC public key, encoded as raw bytes as described in RFC7748_. Args: encoded (bytes): The Curve25519 public key to import. It must be 32 bytes long. Returns: x (integer) Raises: ValueError: when the given key cannot be parsed. .. _RFC7748: https://datatracker.ietf.org/doc/html/rfc7748 r.zIncorrect Curve25519 key lengthr0r1r3r4)rIrBrMr rN)rrirs r#rrNsJ" 7|r:;;'AbETME  h7G Nr"cd[U5S:wa [S5e[R"USS9nU$)a<Import a Curve448 ECC public key, encoded as raw bytes as described in RFC7748_. Args: encoded (bytes): The Curve448 public key to import. It must be 56 bytes long. Returns: x (integer) Raises: ValueError: when the given key cannot be parsed. .. _RFC7748: https://datatracker.ietf.org/doc/html/rfc7748 r:zIncorrect Curve448 key lengthr3r4)rIrBr rN)rrs r#rrjs3" 7|r899  H=G Nr"c[U5S:wa [S5e[SRnUS- nUSSn[ US5S- n[ R "USS 9nXQ:a [S 5eUS :Xag US -S - U-nUS -U-U-S - U-nURU5nXh-U-n [ R"X5n U S -U:waX- n X4$![a [S5ef=f)a?Import an Ed448 ECC public key, encoded as raw bytes as described in RFC8032_. Args: encoded (bytes): The Ed448 public key to import. It must be 57 bytes long. Returns: x and y (integer) Raises: ValueError: when the given key cannot be parsed. .. _RFC8032: https://datatracker.ietf.org/doc/html/rfc8032 r6z7Incorrect length. Only Ed448 public keys are supported.curve448iNr:rr3r4zInvalid Ed448 key (y)rr^r-zInvalid Ed448 public key) rIrBrrrr rNrwr_r`s r#rrs" 7|rRSS A E A A   "E  h7G|011!| !a1A 1*q.A  !Q&A5 ! i1_))"0 aKE !kG   53445s ;CC&c*SSKJn [U5nUb [U5nURS5(a,[ U5nUR XA5upVn[ XQ5nU$URS5(ae[ U5nSn Sn [R"U S-U -S U[RS 9nUR XA5upnU(aSn[X5nU$URS 5(a [U5$[U5S:a[US5S :Xa [X5$[U5S:a)[US5S;aUc [S5e[!XS9$[S5e![an U eSn A f[a [S 5ef=f)a Import an ECC key (public or private). Args: encoded (bytes or multi-line string): The ECC key to import. The function will try to automatically detect the right format. Supported formats for an ECC **public** key: * X.509 certificate: binary (DER) or ASCII (PEM). * X.509 ``subjectPublicKeyInfo``: binary (DER) or ASCII (PEM). * SEC1_ (or X9.62), as ``bytes``. NIST P curves only. You must also provide the ``curve_name`` (with a value from the `ECC table`_) * OpenSSH line, defined in RFC5656_ and RFC8709_ (ASCII). This is normally the content of files like ``~/.ssh/id_ecdsa.pub``. Supported formats for an ECC **private** key: * A binary ``ECPrivateKey`` structure, as defined in `RFC5915`_ (DER). NIST P curves only. * A `PKCS#8`_ structure (or the more recent Asymmetric Key Package, RFC5958_): binary (DER) or ASCII (PEM). * `OpenSSH 6.5`_ and newer versions (ASCII). Private keys can be in the clear or password-protected. For details about the PEM encoding, see `RFC1421`_/`RFC1423`_. passphrase (byte string): The passphrase to use for decrypting a private key. Encryption may be applied protected at the PEM level (not recommended) or at the PKCS#8 level (recommended). This parameter is ignored if the key in input is not encrypted. curve_name (string): For a SEC1 encoding only. This is the name of the curve, as defined in the `ECC table`_. .. note:: To import EdDSA private and public keys, when encoded as raw ``bytes``, use: * :func:`Crypto.Signature.eddsa.import_public_key`, or * :func:`Crypto.Signature.eddsa.import_private_key`. .. note:: To import X25519/X448 private and public keys, when encoded as raw ``bytes``, use: * :func:`Crypto.Protocol.DH.import_x25519_public_key` * :func:`Crypto.Protocol.DH.import_x25519_private_key` * :func:`Crypto.Protocol.DH.import_x448_public_key` * :func:`Crypto.Protocol.DH.import_x448_private_key` Returns: :class:`EccKey` : a new ECC key object Raises: ValueError: when the given key cannot be parsed (possibly because the pass phrase is wrong). .. _RFC1421: https://datatracker.ietf.org/doc/html/rfc1421 .. _RFC1423: https://datatracker.ietf.org/doc/html/rfc1423 .. _RFC5915: https://datatracker.ietf.org/doc/html/rfc5915 .. _RFC5656: https://datatracker.ietf.org/doc/html/rfc5656 .. _RFC8709: https://datatracker.ietf.org/doc/html/rfc8709 .. _RFC5958: https://datatracker.ietf.org/doc/html/rfc5958 .. _`PKCS#8`: https://datatracker.ietf.org/doc/html/rfc5208 .. _`OpenSSH 6.5`: https://flak.tedunangst.com/post/new-openssh-key-format-and-bcrypt-pbkdf .. _SEC1: https://www.secg.org/sec1-v2.pdf rrNs-----BEGIN OPENSSH PRIVATE KEYs-----z-----BEGIN EC PARAMETERS-----z-----END EC PARAMETERS-----z.*?re)flagsz(Invalid DER encoding inside the PEM file)r<r>0r&zNo curve name was provided)rWzECC key format is not supported)rrrrBrrr\resubDOTALLr9rrBrIrIrr) rrrWr text_encodedopenssh_encodedmarkerenc_flagrlecparams_start ecparams_end der_encodeduefs r# import_keyrxsRgGZ( ;<<W~ ,/JJ|,P),_I   H % %W~ 94 vvnu4|CR*$&II/ ), <(L% X J I 9F  :;;%g.. 7|aD,47// 7|aD,0BB  9: :!'AA 6 77)% I IGH H Is E-- F7E99F__main__l_,)N$c hKf-5lkrsw>& GG',,@@)*00' J H6VH6V'TDN5>p@EF8Nv%TP1 +B+\4An*Z82)X{8| zJA FO   " " $E E IIKE 5\ + e+u4t;TB IIKE 5\! #diikE&9U%BT%I4P#r"