eidZdZdZdZdS)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 d}d}ddtdD tdD]>}tdD],d|dzzz}||||dz |<-?d}tdD]u} fd tdD fd tdD fd tdD dd dd c}}tdD]E}d |zdzzdzc}|dz|d zzd z} ||| c} |<FtdD]` fdtdD} tdD]2}| || |dzdz| |d zdzzz |<3atdD]7} |dz|dz dzz dz}|d zr d d xxdd| zdz zzcc<8wtdD]>}tdD],d|dzzz}| ||||dz<-?|S)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]. cTtfdtdDS)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. c34K|]}|d|zzVdS)N).0ibs d/var/www/html/volatility/venv/lib/python3.11/site-packages/ccxt/static_dependencies/keccak/keccak.py z0keccak_f_1600..load64..Cs/77AaDQUO777777r)sumrange)r s`r load64zkeccak_f_1600..load649s.7777eAhh777777r cTtfdtdDS)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.K|]}d|zz dzVdS)rNr)rras r r z1keccak_f_1600..store64..Os0;;QQ1q5\S(;;;;;;r r)listr)rs`r store64zkeccak_f_1600..store64Es.;;;;%((;;;;;;r c0|d|dzz z ||dzzzdzS)a= 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 rotatezkeccak_f_1600..rotateQs)rQV}%!B-8WEEr c@g|]}dtdDS)cg|]}dS)rr_s r z,keccak_f_1600..._s   !   r rrs r rz!keccak_f_1600.._s-1111  U1XX   111r r rcg|]L}|d|dz |dz |dz |dz MS)rr"r)rxAs r rz!keccak_f_1600..gsU O O OQqT!WqtAw 1a (1Q47 2QqT!W < O O Or c^g|])}|dz dz|dzdzdz *S)r"r r)rr(Crs r rz!keccak_f_1600..hsB J J JAQA{^ffQA{^Q77 7 J J Jr cLg|]fdtdD S)c>g|]}|z Srr)ryr)Dr(s r rz,keccak_f_1600...is) / / /ad1g!n / / /r r r!)rr(r)r/s @r rz!keccak_f_1600..is; B B BA / / / / / /eAhh / / / B B Br rr%r&c,g|]}|Srr)rr(r)r.s r rz!keccak_f_1600..rs!+++Q1a+++r qrr!)staterrr(rRrcurrenttoffsetTjr)r+r/rr.s @@@@@r keccak_f_1600r:s+F 8 8 8 < < < F F F 21a111A 1XX//q / /AQQYAfU1q1u9-..AaDGG / A 2YY// O O O OeAhh O O O J J J J Jq J J J B B B B Bq B B B1ad1g 1gr @ @Aq1uq1u})DAq1uQ'A-F tAww(?(? GQqT!WWq F FA+++++%((+++A1XX F FA$Aq1ukN?aQ! n"DE!Q Fq / /Aq&a1f_-4A1u /!Q1!q&A.. / 1XX00q 0 0AQQYA&wqtAw//E!a!e)   0 Lr ct||zdz}|dzdd}}}|t|krztt||z |}t|D]} || xx|| |zzcc<||z }||krt |}d}|t|kz||xx|zcc<|dzr||dz krt |}||dz xxdzcc<t |}t} |r5t||}| |d|z } ||z}|rt |}|5| S)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. rrr"N) bytearraylenminrr:) rc_inputsuffix output_lenr3 rate_bytesblockr7routputs r KeccakrHs. q1ul # #E !Q1vJ 3v;;  CKK&(*55u + +A !HHHq6z* *HHHH% J  !%((EE 3v;;   %LLLFLLL %Ej1n55e$$ *q.T! % E [[F )J ++%-e  )!%((E ) Mr cHd}d}td|dzz |dz|||dzS)a  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)rH)rBsizepaddings r SHA3rLs4 DG $/4!8VWdai H HHr N)__doc__r:rHrLrr r rNsP$jjjZ111hIIIIIr