E#iSrSrSrSrg)ukeccakf1600.py Keccak is a family of hash functions based on the sponge construction. It was chosen by NIST to become the SHA-3 standard. This code implements the Keccak-f[1600] permutation. Detailed information about this function can be found on the official site [1]. Original implementation [2] by the Keccak Team. Some caveats about the implementation: * width `b` of permutation is fixed as 1600 (5 * 5 * 64), which means the number of rounds is 24 (12 + 2ℓ, ℓ = log_2(b / 25)) * ρ step could have its offsets pre-computed as the array `r`. * ι step could have its round constants pre-computed as the array `RC`. [1] http://keccak.noekeon.org/ [2] https://git.io/vKfkb c \SnSnSn[S5Vs/sHn[S5Vs/sHnSPM snPM! nn[S5H2n[S5H nSUSU---nU"XUS-5XVU'M" M4 Sn [S5GHn[S5Vs/sH*oeUSXVS- XVS - XVS - XVS - PM, n n[S5Vs/sHojUS- S-U"XS-S-S5- PM! n n[S5VVs/sH)n[S5Vs/sHouUUX- PM snPM+ nnnSSUSSpn[S5H5n US U-S U--S-pvU S-U S --S -nXVUU"X5soUU'M7 [S5HUn[S5Vs/sH oeUUPM nn[S5H#nXXS-S-)XS -S--- XVU'M% MW [S 5H9nU S-U S - S -- S-n U S -(dM USS==SSU-S- --ss'M; GM [S5H2n[S5H nSUSU---nU"XVU5XUS-&M" M4 U$s snfs snfs snfs snfs snfs snnfs snf)uThe inner permutation for the Keccak sponge function. The Keccak-f permutation is an iterated construction consisting of a sequence of almost identical rounds. It operates on a state array with each of the twenty-four rounds performing five steps, described below with detail. The loops above and below the core of the permutation are used to save and restore the state array to a stream of bytes, used outside the permutation. The original state array has three dimensions, whereas this characteristic can be cleverly optimized to a 5x5 matrix with 64-bit words. As such, this implementation makes use of this trick and stores an entire lane (a z-axis set of bits within the state) as a single word. The θ step diffuses the bits alongside the state array by calculating the parity of nearby columns relative to a lane. The ρ and π steps are merged; together, they move more bits around according to two alike recurrence relations. The χ step is similar to an S-box permutation; it makes the whole round non-linear with a few logic operations on bits inside a line. The ι step is a simple LFSR that breaks the symmetry of the rounds. It generates constants by doing computations according to the round number and its previous output, modulo polynomials over GF(2)[x]. Args: state: square matrix of order 5 that holds the input bytes. Returns: state: bytes permuted by Keccak-f[1600]. c@^[U4Sj[S555$)z Saves each byte on its respective position within a 64-bit word. Args: b: partial list of bytes from input. Returns: Sum of list with numbers shifted. c3:># UHnTUSU--v M g7f)N).0ibs `/home/james-whalen/.local/lib/python3.13/site-packages/ccxt/static_dependencies/keccak/keccak.py 0keccak_f_1600..load64..Cs7hAaDQUOhr)sumrange)r s`r load64keccak_f_1600..load649s7eAh777c@^[U4Sj[S555$)z Transforms a 64-bit word into a list of bytes. Args: a: 64-bit word. Returns: List of bytes separated by position on the word. c3:># UHnTSU-- S-v M g7f)rNr)rras r r 1keccak_f_1600..store64..Os;(QQ1q5\S((r r)listr)rs`r store64keccak_f_1600..store64Es;%(;;;rc.USUS-- - XS---S-$)z Denotes the bitwise cyclic shift operation, moving bit at position `i` into position `i + n` (modulo the lane size). Args: a: lane with a 64-bit word, or elements from the state array. n: offset for rotation. Returns: The rotated lane. @lr)rns r rotatekeccak_f_1600..rotateQs'rQV}%!B-8WEErrqr)r)staterrr_AxyrRCDcurrenttoffsetTjs r keccak_f_1600r6sF 8 < F).a11U1X X!X A1 1XqAQQYAUq1u-.ADG A 2YFKAh OhqT!WqtAw a (147 2QT!W q BAeAh /hd1gnh / B1ad1ggrAq1uq1u})q1uQ'A-F tAww(? GqT!W qA"'(+(Q1a(A+1X$A1ukN?aQ! n"DEQ qAq&a1f_-4A1uu!Q1!q&A..!*1XqAQQYA&qtAw/Ea!e  LC 1 P J / B,s?J J J1J&JJ#'J=J#1J) JJ#c"[X-S-5nUS-SSpnU[U5:ab[[U5U- U5n[U5Hn XY==X)U--ss'M X- nXv:Xa [ U5nSnU[U5:aMbXW==U-ss'US-(aXvS- :Xa [ U5nXVS- ==S-ss'[ U5n[5n U(a1[XF5nXSU- n XG-nU(a [ U5nU(aM1U $)a The general sponge function, consisting of the inner permutation and a padding rule (`pad10*1`). It consists of three main parts. * absorbing, where the input will be permuted repeatedly every time it is divided into a block of size `r + c`. * padding, where an oddly sized last block will be filled with bits until it can be fed into the permutation. * squeezing, where the output's blocks will be permuted more times until they are concatenated to the desired size. Args: r: rate, or the number of input bits processed or output bits generated per invocation of the underlying function c: capacity, or the width of the underlying function minus the rate _input: list of bytes containing the desired object to be hashed suffix: distinguishes the inputs arising from SHA-3/SHAKE functions output_len: length of hash output. Returns: Hash of the input bytes. rr!r"N) bytearraylenminrr6) rc_inputsuffix output_lenr) rate_bytesblockr3routputs r KeccakrDs. qul #E !Q1vJ 3v; CK&(*5uA H6z* *H  !%(EE 3v;  LFL E1n5e$ q.T! % E [F J+- !%(E * Mrc>SnSn[SUS-- US-XUS-5$)z FIPS 202 generalized instance of the SHA-3 hash function. Args: size: instance of desired SHA3 algorithm. _input: list of bytes to compute a hash from. Returns: Instance of the Keccak permutation that calculates the hash. rr"i@r$r)rD)r>sizepaddings r SHA3rHs/ DG $/4!8Vdai HHrN)__doc__r6rDrHrrr rJs$jZ1hIr