<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="generator" content="rustdoc">
<meta name="description" content="Source to the Rust file `/home/dimitris/.cargo/registry/src/github.com-1ecc6299db9ec823/rust-crypto-0.2.36/src/aessafe.rs`.">
<meta name="keywords" content="rust, rustlang, rust-lang">
<title>aessafe.rs.html -- source</title>
<link rel="stylesheet" type="text/css" href="../../normalize.css">
<link rel="stylesheet" type="text/css" href="../../rustdoc.css">
<link rel="stylesheet" type="text/css" href="../../main.css">
</head>
<body class="rustdoc">
<!--[if lte IE 8]>
<div class="warning">
This old browser is unsupported and will most likely display funky
things.
</div>
<![endif]-->
<nav class="sidebar">
</nav>
<nav class="sub">
<form class="search-form js-only">
<div class="search-container">
<input class="search-input" name="search"
autocomplete="off"
placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
type="search">
</div>
</form>
</nav>
<section id='main' class="content source"><pre class="line-numbers"><span id="1"> 1</span>
<span id="2"> 2</span>
<span id="3"> 3</span>
<span id="4"> 4</span>
<span id="5"> 5</span>
<span id="6"> 6</span>
<span id="7"> 7</span>
<span id="8"> 8</span>
<span id="9"> 9</span>
<span id="10"> 10</span>
<span id="11"> 11</span>
<span id="12"> 12</span>
<span id="13"> 13</span>
<span id="14"> 14</span>
<span id="15"> 15</span>
<span id="16"> 16</span>
<span id="17"> 17</span>
<span id="18"> 18</span>
<span id="19"> 19</span>
<span id="20"> 20</span>
<span id="21"> 21</span>
<span id="22"> 22</span>
<span id="23"> 23</span>
<span id="24"> 24</span>
<span id="25"> 25</span>
<span id="26"> 26</span>
<span id="27"> 27</span>
<span id="28"> 28</span>
<span id="29"> 29</span>
<span id="30"> 30</span>
<span id="31"> 31</span>
<span id="32"> 32</span>
<span id="33"> 33</span>
<span id="34"> 34</span>
<span id="35"> 35</span>
<span id="36"> 36</span>
<span id="37"> 37</span>
<span id="38"> 38</span>
<span id="39"> 39</span>
<span id="40"> 40</span>
<span id="41"> 41</span>
<span id="42"> 42</span>
<span id="43"> 43</span>
<span id="44"> 44</span>
<span id="45"> 45</span>
<span id="46"> 46</span>
<span id="47"> 47</span>
<span id="48"> 48</span>
<span id="49"> 49</span>
<span id="50"> 50</span>
<span id="51"> 51</span>
<span id="52"> 52</span>
<span id="53"> 53</span>
<span id="54"> 54</span>
<span id="55"> 55</span>
<span id="56"> 56</span>
<span id="57"> 57</span>
<span id="58"> 58</span>
<span id="59"> 59</span>
<span id="60"> 60</span>
<span id="61"> 61</span>
<span id="62"> 62</span>
<span id="63"> 63</span>
<span id="64"> 64</span>
<span id="65"> 65</span>
<span id="66"> 66</span>
<span id="67"> 67</span>
<span id="68"> 68</span>
<span id="69"> 69</span>
<span id="70"> 70</span>
<span id="71"> 71</span>
<span id="72"> 72</span>
<span id="73"> 73</span>
<span id="74"> 74</span>
<span id="75"> 75</span>
<span id="76"> 76</span>
<span id="77"> 77</span>
<span id="78"> 78</span>
<span id="79"> 79</span>
<span id="80"> 80</span>
<span id="81"> 81</span>
<span id="82"> 82</span>
<span id="83"> 83</span>
<span id="84"> 84</span>
<span id="85"> 85</span>
<span id="86"> 86</span>
<span id="87"> 87</span>
<span id="88"> 88</span>
<span id="89"> 89</span>
<span id="90"> 90</span>
<span id="91"> 91</span>
<span id="92"> 92</span>
<span id="93"> 93</span>
<span id="94"> 94</span>
<span id="95"> 95</span>
<span id="96"> 96</span>
<span id="97"> 97</span>
<span id="98"> 98</span>
<span id="99"> 99</span>
<span id="100"> 100</span>
<span id="101"> 101</span>
<span id="102"> 102</span>
<span id="103"> 103</span>
<span id="104"> 104</span>
<span id="105"> 105</span>
<span id="106"> 106</span>
<span id="107"> 107</span>
<span id="108"> 108</span>
<span id="109"> 109</span>
<span id="110"> 110</span>
<span id="111"> 111</span>
<span id="112"> 112</span>
<span id="113"> 113</span>
<span id="114"> 114</span>
<span id="115"> 115</span>
<span id="116"> 116</span>
<span id="117"> 117</span>
<span id="118"> 118</span>
<span id="119"> 119</span>
<span id="120"> 120</span>
<span id="121"> 121</span>
<span id="122"> 122</span>
<span id="123"> 123</span>
<span id="124"> 124</span>
<span id="125"> 125</span>
<span id="126"> 126</span>
<span id="127"> 127</span>
<span id="128"> 128</span>
<span id="129"> 129</span>
<span id="130"> 130</span>
<span id="131"> 131</span>
<span id="132"> 132</span>
<span id="133"> 133</span>
<span id="134"> 134</span>
<span id="135"> 135</span>
<span id="136"> 136</span>
<span id="137"> 137</span>
<span id="138"> 138</span>
<span id="139"> 139</span>
<span id="140"> 140</span>
<span id="141"> 141</span>
<span id="142"> 142</span>
<span id="143"> 143</span>
<span id="144"> 144</span>
<span id="145"> 145</span>
<span id="146"> 146</span>
<span id="147"> 147</span>
<span id="148"> 148</span>
<span id="149"> 149</span>
<span id="150"> 150</span>
<span id="151"> 151</span>
<span id="152"> 152</span>
<span id="153"> 153</span>
<span id="154"> 154</span>
<span id="155"> 155</span>
<span id="156"> 156</span>
<span id="157"> 157</span>
<span id="158"> 158</span>
<span id="159"> 159</span>
<span id="160"> 160</span>
<span id="161"> 161</span>
<span id="162"> 162</span>
<span id="163"> 163</span>
<span id="164"> 164</span>
<span id="165"> 165</span>
<span id="166"> 166</span>
<span id="167"> 167</span>
<span id="168"> 168</span>
<span id="169"> 169</span>
<span id="170"> 170</span>
<span id="171"> 171</span>
<span id="172"> 172</span>
<span id="173"> 173</span>
<span id="174"> 174</span>
<span id="175"> 175</span>
<span id="176"> 176</span>
<span id="177"> 177</span>
<span id="178"> 178</span>
<span id="179"> 179</span>
<span id="180"> 180</span>
<span id="181"> 181</span>
<span id="182"> 182</span>
<span id="183"> 183</span>
<span id="184"> 184</span>
<span id="185"> 185</span>
<span id="186"> 186</span>
<span id="187"> 187</span>
<span id="188"> 188</span>
<span id="189"> 189</span>
<span id="190"> 190</span>
<span id="191"> 191</span>
<span id="192"> 192</span>
<span id="193"> 193</span>
<span id="194"> 194</span>
<span id="195"> 195</span>
<span id="196"> 196</span>
<span id="197"> 197</span>
<span id="198"> 198</span>
<span id="199"> 199</span>
<span id="200"> 200</span>
<span id="201"> 201</span>
<span id="202"> 202</span>
<span id="203"> 203</span>
<span id="204"> 204</span>
<span id="205"> 205</span>
<span id="206"> 206</span>
<span id="207"> 207</span>
<span id="208"> 208</span>
<span id="209"> 209</span>
<span id="210"> 210</span>
<span id="211"> 211</span>
<span id="212"> 212</span>
<span id="213"> 213</span>
<span id="214"> 214</span>
<span id="215"> 215</span>
<span id="216"> 216</span>
<span id="217"> 217</span>
<span id="218"> 218</span>
<span id="219"> 219</span>
<span id="220"> 220</span>
<span id="221"> 221</span>
<span id="222"> 222</span>
<span id="223"> 223</span>
<span id="224"> 224</span>
<span id="225"> 225</span>
<span id="226"> 226</span>
<span id="227"> 227</span>
<span id="228"> 228</span>
<span id="229"> 229</span>
<span id="230"> 230</span>
<span id="231"> 231</span>
<span id="232"> 232</span>
<span id="233"> 233</span>
<span id="234"> 234</span>
<span id="235"> 235</span>
<span id="236"> 236</span>
<span id="237"> 237</span>
<span id="238"> 238</span>
<span id="239"> 239</span>
<span id="240"> 240</span>
<span id="241"> 241</span>
<span id="242"> 242</span>
<span id="243"> 243</span>
<span id="244"> 244</span>
<span id="245"> 245</span>
<span id="246"> 246</span>
<span id="247"> 247</span>
<span id="248"> 248</span>
<span id="249"> 249</span>
<span id="250"> 250</span>
<span id="251"> 251</span>
<span id="252"> 252</span>
<span id="253"> 253</span>
<span id="254"> 254</span>
<span id="255"> 255</span>
<span id="256"> 256</span>
<span id="257"> 257</span>
<span id="258"> 258</span>
<span id="259"> 259</span>
<span id="260"> 260</span>
<span id="261"> 261</span>
<span id="262"> 262</span>
<span id="263"> 263</span>
<span id="264"> 264</span>
<span id="265"> 265</span>
<span id="266"> 266</span>
<span id="267"> 267</span>
<span id="268"> 268</span>
<span id="269"> 269</span>
<span id="270"> 270</span>
<span id="271"> 271</span>
<span id="272"> 272</span>
<span id="273"> 273</span>
<span id="274"> 274</span>
<span id="275"> 275</span>
<span id="276"> 276</span>
<span id="277"> 277</span>
<span id="278"> 278</span>
<span id="279"> 279</span>
<span id="280"> 280</span>
<span id="281"> 281</span>
<span id="282"> 282</span>
<span id="283"> 283</span>
<span id="284"> 284</span>
<span id="285"> 285</span>
<span id="286"> 286</span>
<span id="287"> 287</span>
<span id="288"> 288</span>
<span id="289"> 289</span>
<span id="290"> 290</span>
<span id="291"> 291</span>
<span id="292"> 292</span>
<span id="293"> 293</span>
<span id="294"> 294</span>
<span id="295"> 295</span>
<span id="296"> 296</span>
<span id="297"> 297</span>
<span id="298"> 298</span>
<span id="299"> 299</span>
<span id="300"> 300</span>
<span id="301"> 301</span>
<span id="302"> 302</span>
<span id="303"> 303</span>
<span id="304"> 304</span>
<span id="305"> 305</span>
<span id="306"> 306</span>
<span id="307"> 307</span>
<span id="308"> 308</span>
<span id="309"> 309</span>
<span id="310"> 310</span>
<span id="311"> 311</span>
<span id="312"> 312</span>
<span id="313"> 313</span>
<span id="314"> 314</span>
<span id="315"> 315</span>
<span id="316"> 316</span>
<span id="317"> 317</span>
<span id="318"> 318</span>
<span id="319"> 319</span>
<span id="320"> 320</span>
<span id="321"> 321</span>
<span id="322"> 322</span>
<span id="323"> 323</span>
<span id="324"> 324</span>
<span id="325"> 325</span>
<span id="326"> 326</span>
<span id="327"> 327</span>
<span id="328"> 328</span>
<span id="329"> 329</span>
<span id="330"> 330</span>
<span id="331"> 331</span>
<span id="332"> 332</span>
<span id="333"> 333</span>
<span id="334"> 334</span>
<span id="335"> 335</span>
<span id="336"> 336</span>
<span id="337"> 337</span>
<span id="338"> 338</span>
<span id="339"> 339</span>
<span id="340"> 340</span>
<span id="341"> 341</span>
<span id="342"> 342</span>
<span id="343"> 343</span>
<span id="344"> 344</span>
<span id="345"> 345</span>
<span id="346"> 346</span>
<span id="347"> 347</span>
<span id="348"> 348</span>
<span id="349"> 349</span>
<span id="350"> 350</span>
<span id="351"> 351</span>
<span id="352"> 352</span>
<span id="353"> 353</span>
<span id="354"> 354</span>
<span id="355"> 355</span>
<span id="356"> 356</span>
<span id="357"> 357</span>
<span id="358"> 358</span>
<span id="359"> 359</span>
<span id="360"> 360</span>
<span id="361"> 361</span>
<span id="362"> 362</span>
<span id="363"> 363</span>
<span id="364"> 364</span>
<span id="365"> 365</span>
<span id="366"> 366</span>
<span id="367"> 367</span>
<span id="368"> 368</span>
<span id="369"> 369</span>
<span id="370"> 370</span>
<span id="371"> 371</span>
<span id="372"> 372</span>
<span id="373"> 373</span>
<span id="374"> 374</span>
<span id="375"> 375</span>
<span id="376"> 376</span>
<span id="377"> 377</span>
<span id="378"> 378</span>
<span id="379"> 379</span>
<span id="380"> 380</span>
<span id="381"> 381</span>
<span id="382"> 382</span>
<span id="383"> 383</span>
<span id="384"> 384</span>
<span id="385"> 385</span>
<span id="386"> 386</span>
<span id="387"> 387</span>
<span id="388"> 388</span>
<span id="389"> 389</span>
<span id="390"> 390</span>
<span id="391"> 391</span>
<span id="392"> 392</span>
<span id="393"> 393</span>
<span id="394"> 394</span>
<span id="395"> 395</span>
<span id="396"> 396</span>
<span id="397"> 397</span>
<span id="398"> 398</span>
<span id="399"> 399</span>
<span id="400"> 400</span>
<span id="401"> 401</span>
<span id="402"> 402</span>
<span id="403"> 403</span>
<span id="404"> 404</span>
<span id="405"> 405</span>
<span id="406"> 406</span>
<span id="407"> 407</span>
<span id="408"> 408</span>
<span id="409"> 409</span>
<span id="410"> 410</span>
<span id="411"> 411</span>
<span id="412"> 412</span>
<span id="413"> 413</span>
<span id="414"> 414</span>
<span id="415"> 415</span>
<span id="416"> 416</span>
<span id="417"> 417</span>
<span id="418"> 418</span>
<span id="419"> 419</span>
<span id="420"> 420</span>
<span id="421"> 421</span>
<span id="422"> 422</span>
<span id="423"> 423</span>
<span id="424"> 424</span>
<span id="425"> 425</span>
<span id="426"> 426</span>
<span id="427"> 427</span>
<span id="428"> 428</span>
<span id="429"> 429</span>
<span id="430"> 430</span>
<span id="431"> 431</span>
<span id="432"> 432</span>
<span id="433"> 433</span>
<span id="434"> 434</span>
<span id="435"> 435</span>
<span id="436"> 436</span>
<span id="437"> 437</span>
<span id="438"> 438</span>
<span id="439"> 439</span>
<span id="440"> 440</span>
<span id="441"> 441</span>
<span id="442"> 442</span>
<span id="443"> 443</span>
<span id="444"> 444</span>
<span id="445"> 445</span>
<span id="446"> 446</span>
<span id="447"> 447</span>
<span id="448"> 448</span>
<span id="449"> 449</span>
<span id="450"> 450</span>
<span id="451"> 451</span>
<span id="452"> 452</span>
<span id="453"> 453</span>
<span id="454"> 454</span>
<span id="455"> 455</span>
<span id="456"> 456</span>
<span id="457"> 457</span>
<span id="458"> 458</span>
<span id="459"> 459</span>
<span id="460"> 460</span>
<span id="461"> 461</span>
<span id="462"> 462</span>
<span id="463"> 463</span>
<span id="464"> 464</span>
<span id="465"> 465</span>
<span id="466"> 466</span>
<span id="467"> 467</span>
<span id="468"> 468</span>
<span id="469"> 469</span>
<span id="470"> 470</span>
<span id="471"> 471</span>
<span id="472"> 472</span>
<span id="473"> 473</span>
<span id="474"> 474</span>
<span id="475"> 475</span>
<span id="476"> 476</span>
<span id="477"> 477</span>
<span id="478"> 478</span>
<span id="479"> 479</span>
<span id="480"> 480</span>
<span id="481"> 481</span>
<span id="482"> 482</span>
<span id="483"> 483</span>
<span id="484"> 484</span>
<span id="485"> 485</span>
<span id="486"> 486</span>
<span id="487"> 487</span>
<span id="488"> 488</span>
<span id="489"> 489</span>
<span id="490"> 490</span>
<span id="491"> 491</span>
<span id="492"> 492</span>
<span id="493"> 493</span>
<span id="494"> 494</span>
<span id="495"> 495</span>
<span id="496"> 496</span>
<span id="497"> 497</span>
<span id="498"> 498</span>
<span id="499"> 499</span>
<span id="500"> 500</span>
<span id="501"> 501</span>
<span id="502"> 502</span>
<span id="503"> 503</span>
<span id="504"> 504</span>
<span id="505"> 505</span>
<span id="506"> 506</span>
<span id="507"> 507</span>
<span id="508"> 508</span>
<span id="509"> 509</span>
<span id="510"> 510</span>
<span id="511"> 511</span>
<span id="512"> 512</span>
<span id="513"> 513</span>
<span id="514"> 514</span>
<span id="515"> 515</span>
<span id="516"> 516</span>
<span id="517"> 517</span>
<span id="518"> 518</span>
<span id="519"> 519</span>
<span id="520"> 520</span>
<span id="521"> 521</span>
<span id="522"> 522</span>
<span id="523"> 523</span>
<span id="524"> 524</span>
<span id="525"> 525</span>
<span id="526"> 526</span>
<span id="527"> 527</span>
<span id="528"> 528</span>
<span id="529"> 529</span>
<span id="530"> 530</span>
<span id="531"> 531</span>
<span id="532"> 532</span>
<span id="533"> 533</span>
<span id="534"> 534</span>
<span id="535"> 535</span>
<span id="536"> 536</span>
<span id="537"> 537</span>
<span id="538"> 538</span>
<span id="539"> 539</span>
<span id="540"> 540</span>
<span id="541"> 541</span>
<span id="542"> 542</span>
<span id="543"> 543</span>
<span id="544"> 544</span>
<span id="545"> 545</span>
<span id="546"> 546</span>
<span id="547"> 547</span>
<span id="548"> 548</span>
<span id="549"> 549</span>
<span id="550"> 550</span>
<span id="551"> 551</span>
<span id="552"> 552</span>
<span id="553"> 553</span>
<span id="554"> 554</span>
<span id="555"> 555</span>
<span id="556"> 556</span>
<span id="557"> 557</span>
<span id="558"> 558</span>
<span id="559"> 559</span>
<span id="560"> 560</span>
<span id="561"> 561</span>
<span id="562"> 562</span>
<span id="563"> 563</span>
<span id="564"> 564</span>
<span id="565"> 565</span>
<span id="566"> 566</span>
<span id="567"> 567</span>
<span id="568"> 568</span>
<span id="569"> 569</span>
<span id="570"> 570</span>
<span id="571"> 571</span>
<span id="572"> 572</span>
<span id="573"> 573</span>
<span id="574"> 574</span>
<span id="575"> 575</span>
<span id="576"> 576</span>
<span id="577"> 577</span>
<span id="578"> 578</span>
<span id="579"> 579</span>
<span id="580"> 580</span>
<span id="581"> 581</span>
<span id="582"> 582</span>
<span id="583"> 583</span>
<span id="584"> 584</span>
<span id="585"> 585</span>
<span id="586"> 586</span>
<span id="587"> 587</span>
<span id="588"> 588</span>
<span id="589"> 589</span>
<span id="590"> 590</span>
<span id="591"> 591</span>
<span id="592"> 592</span>
<span id="593"> 593</span>
<span id="594"> 594</span>
<span id="595"> 595</span>
<span id="596"> 596</span>
<span id="597"> 597</span>
<span id="598"> 598</span>
<span id="599"> 599</span>
<span id="600"> 600</span>
<span id="601"> 601</span>
<span id="602"> 602</span>
<span id="603"> 603</span>
<span id="604"> 604</span>
<span id="605"> 605</span>
<span id="606"> 606</span>
<span id="607"> 607</span>
<span id="608"> 608</span>
<span id="609"> 609</span>
<span id="610"> 610</span>
<span id="611"> 611</span>
<span id="612"> 612</span>
<span id="613"> 613</span>
<span id="614"> 614</span>
<span id="615"> 615</span>
<span id="616"> 616</span>
<span id="617"> 617</span>
<span id="618"> 618</span>
<span id="619"> 619</span>
<span id="620"> 620</span>
<span id="621"> 621</span>
<span id="622"> 622</span>
<span id="623"> 623</span>
<span id="624"> 624</span>
<span id="625"> 625</span>
<span id="626"> 626</span>
<span id="627"> 627</span>
<span id="628"> 628</span>
<span id="629"> 629</span>
<span id="630"> 630</span>
<span id="631"> 631</span>
<span id="632"> 632</span>
<span id="633"> 633</span>
<span id="634"> 634</span>
<span id="635"> 635</span>
<span id="636"> 636</span>
<span id="637"> 637</span>
<span id="638"> 638</span>
<span id="639"> 639</span>
<span id="640"> 640</span>
<span id="641"> 641</span>
<span id="642"> 642</span>
<span id="643"> 643</span>
<span id="644"> 644</span>
<span id="645"> 645</span>
<span id="646"> 646</span>
<span id="647"> 647</span>
<span id="648"> 648</span>
<span id="649"> 649</span>
<span id="650"> 650</span>
<span id="651"> 651</span>
<span id="652"> 652</span>
<span id="653"> 653</span>
<span id="654"> 654</span>
<span id="655"> 655</span>
<span id="656"> 656</span>
<span id="657"> 657</span>
<span id="658"> 658</span>
<span id="659"> 659</span>
<span id="660"> 660</span>
<span id="661"> 661</span>
<span id="662"> 662</span>
<span id="663"> 663</span>
<span id="664"> 664</span>
<span id="665"> 665</span>
<span id="666"> 666</span>
<span id="667"> 667</span>
<span id="668"> 668</span>
<span id="669"> 669</span>
<span id="670"> 670</span>
<span id="671"> 671</span>
<span id="672"> 672</span>
<span id="673"> 673</span>
<span id="674"> 674</span>
<span id="675"> 675</span>
<span id="676"> 676</span>
<span id="677"> 677</span>
<span id="678"> 678</span>
<span id="679"> 679</span>
<span id="680"> 680</span>
<span id="681"> 681</span>
<span id="682"> 682</span>
<span id="683"> 683</span>
<span id="684"> 684</span>
<span id="685"> 685</span>
<span id="686"> 686</span>
<span id="687"> 687</span>
<span id="688"> 688</span>
<span id="689"> 689</span>
<span id="690"> 690</span>
<span id="691"> 691</span>
<span id="692"> 692</span>
<span id="693"> 693</span>
<span id="694"> 694</span>
<span id="695"> 695</span>
<span id="696"> 696</span>
<span id="697"> 697</span>
<span id="698"> 698</span>
<span id="699"> 699</span>
<span id="700"> 700</span>
<span id="701"> 701</span>
<span id="702"> 702</span>
<span id="703"> 703</span>
<span id="704"> 704</span>
<span id="705"> 705</span>
<span id="706"> 706</span>
<span id="707"> 707</span>
<span id="708"> 708</span>
<span id="709"> 709</span>
<span id="710"> 710</span>
<span id="711"> 711</span>
<span id="712"> 712</span>
<span id="713"> 713</span>
<span id="714"> 714</span>
<span id="715"> 715</span>
<span id="716"> 716</span>
<span id="717"> 717</span>
<span id="718"> 718</span>
<span id="719"> 719</span>
<span id="720"> 720</span>
<span id="721"> 721</span>
<span id="722"> 722</span>
<span id="723"> 723</span>
<span id="724"> 724</span>
<span id="725"> 725</span>
<span id="726"> 726</span>
<span id="727"> 727</span>
<span id="728"> 728</span>
<span id="729"> 729</span>
<span id="730"> 730</span>
<span id="731"> 731</span>
<span id="732"> 732</span>
<span id="733"> 733</span>
<span id="734"> 734</span>
<span id="735"> 735</span>
<span id="736"> 736</span>
<span id="737"> 737</span>
<span id="738"> 738</span>
<span id="739"> 739</span>
<span id="740"> 740</span>
<span id="741"> 741</span>
<span id="742"> 742</span>
<span id="743"> 743</span>
<span id="744"> 744</span>
<span id="745"> 745</span>
<span id="746"> 746</span>
<span id="747"> 747</span>
<span id="748"> 748</span>
<span id="749"> 749</span>
<span id="750"> 750</span>
<span id="751"> 751</span>
<span id="752"> 752</span>
<span id="753"> 753</span>
<span id="754"> 754</span>
<span id="755"> 755</span>
<span id="756"> 756</span>
<span id="757"> 757</span>
<span id="758"> 758</span>
<span id="759"> 759</span>
<span id="760"> 760</span>
<span id="761"> 761</span>
<span id="762"> 762</span>
<span id="763"> 763</span>
<span id="764"> 764</span>
<span id="765"> 765</span>
<span id="766"> 766</span>
<span id="767"> 767</span>
<span id="768"> 768</span>
<span id="769"> 769</span>
<span id="770"> 770</span>
<span id="771"> 771</span>
<span id="772"> 772</span>
<span id="773"> 773</span>
<span id="774"> 774</span>
<span id="775"> 775</span>
<span id="776"> 776</span>
<span id="777"> 777</span>
<span id="778"> 778</span>
<span id="779"> 779</span>
<span id="780"> 780</span>
<span id="781"> 781</span>
<span id="782"> 782</span>
<span id="783"> 783</span>
<span id="784"> 784</span>
<span id="785"> 785</span>
<span id="786"> 786</span>
<span id="787"> 787</span>
<span id="788"> 788</span>
<span id="789"> 789</span>
<span id="790"> 790</span>
<span id="791"> 791</span>
<span id="792"> 792</span>
<span id="793"> 793</span>
<span id="794"> 794</span>
<span id="795"> 795</span>
<span id="796"> 796</span>
<span id="797"> 797</span>
<span id="798"> 798</span>
<span id="799"> 799</span>
<span id="800"> 800</span>
<span id="801"> 801</span>
<span id="802"> 802</span>
<span id="803"> 803</span>
<span id="804"> 804</span>
<span id="805"> 805</span>
<span id="806"> 806</span>
<span id="807"> 807</span>
<span id="808"> 808</span>
<span id="809"> 809</span>
<span id="810"> 810</span>
<span id="811"> 811</span>
<span id="812"> 812</span>
<span id="813"> 813</span>
<span id="814"> 814</span>
<span id="815"> 815</span>
<span id="816"> 816</span>
<span id="817"> 817</span>
<span id="818"> 818</span>
<span id="819"> 819</span>
<span id="820"> 820</span>
<span id="821"> 821</span>
<span id="822"> 822</span>
<span id="823"> 823</span>
<span id="824"> 824</span>
<span id="825"> 825</span>
<span id="826"> 826</span>
<span id="827"> 827</span>
<span id="828"> 828</span>
<span id="829"> 829</span>
<span id="830"> 830</span>
<span id="831"> 831</span>
<span id="832"> 832</span>
<span id="833"> 833</span>
<span id="834"> 834</span>
<span id="835"> 835</span>
<span id="836"> 836</span>
<span id="837"> 837</span>
<span id="838"> 838</span>
<span id="839"> 839</span>
<span id="840"> 840</span>
<span id="841"> 841</span>
<span id="842"> 842</span>
<span id="843"> 843</span>
<span id="844"> 844</span>
<span id="845"> 845</span>
<span id="846"> 846</span>
<span id="847"> 847</span>
<span id="848"> 848</span>
<span id="849"> 849</span>
<span id="850"> 850</span>
<span id="851"> 851</span>
<span id="852"> 852</span>
<span id="853"> 853</span>
<span id="854"> 854</span>
<span id="855"> 855</span>
<span id="856"> 856</span>
<span id="857"> 857</span>
<span id="858"> 858</span>
<span id="859"> 859</span>
<span id="860"> 860</span>
<span id="861"> 861</span>
<span id="862"> 862</span>
<span id="863"> 863</span>
<span id="864"> 864</span>
<span id="865"> 865</span>
<span id="866"> 866</span>
<span id="867"> 867</span>
<span id="868"> 868</span>
<span id="869"> 869</span>
<span id="870"> 870</span>
<span id="871"> 871</span>
<span id="872"> 872</span>
<span id="873"> 873</span>
<span id="874"> 874</span>
<span id="875"> 875</span>
<span id="876"> 876</span>
<span id="877"> 877</span>
<span id="878"> 878</span>
<span id="879"> 879</span>
<span id="880"> 880</span>
<span id="881"> 881</span>
<span id="882"> 882</span>
<span id="883"> 883</span>
<span id="884"> 884</span>
<span id="885"> 885</span>
<span id="886"> 886</span>
<span id="887"> 887</span>
<span id="888"> 888</span>
<span id="889"> 889</span>
<span id="890"> 890</span>
<span id="891"> 891</span>
<span id="892"> 892</span>
<span id="893"> 893</span>
<span id="894"> 894</span>
<span id="895"> 895</span>
<span id="896"> 896</span>
<span id="897"> 897</span>
<span id="898"> 898</span>
<span id="899"> 899</span>
<span id="900"> 900</span>
<span id="901"> 901</span>
<span id="902"> 902</span>
<span id="903"> 903</span>
<span id="904"> 904</span>
<span id="905"> 905</span>
<span id="906"> 906</span>
<span id="907"> 907</span>
<span id="908"> 908</span>
<span id="909"> 909</span>
<span id="910"> 910</span>
<span id="911"> 911</span>
<span id="912"> 912</span>
<span id="913"> 913</span>
<span id="914"> 914</span>
<span id="915"> 915</span>
<span id="916"> 916</span>
<span id="917"> 917</span>
<span id="918"> 918</span>
<span id="919"> 919</span>
<span id="920"> 920</span>
<span id="921"> 921</span>
<span id="922"> 922</span>
<span id="923"> 923</span>
<span id="924"> 924</span>
<span id="925"> 925</span>
<span id="926"> 926</span>
<span id="927"> 927</span>
<span id="928"> 928</span>
<span id="929"> 929</span>
<span id="930"> 930</span>
<span id="931"> 931</span>
<span id="932"> 932</span>
<span id="933"> 933</span>
<span id="934"> 934</span>
<span id="935"> 935</span>
<span id="936"> 936</span>
<span id="937"> 937</span>
<span id="938"> 938</span>
<span id="939"> 939</span>
<span id="940"> 940</span>
<span id="941"> 941</span>
<span id="942"> 942</span>
<span id="943"> 943</span>
<span id="944"> 944</span>
<span id="945"> 945</span>
<span id="946"> 946</span>
<span id="947"> 947</span>
<span id="948"> 948</span>
<span id="949"> 949</span>
<span id="950"> 950</span>
<span id="951"> 951</span>
<span id="952"> 952</span>
<span id="953"> 953</span>
<span id="954"> 954</span>
<span id="955"> 955</span>
<span id="956"> 956</span>
<span id="957"> 957</span>
<span id="958"> 958</span>
<span id="959"> 959</span>
<span id="960"> 960</span>
<span id="961"> 961</span>
<span id="962"> 962</span>
<span id="963"> 963</span>
<span id="964"> 964</span>
<span id="965"> 965</span>
<span id="966"> 966</span>
<span id="967"> 967</span>
<span id="968"> 968</span>
<span id="969"> 969</span>
<span id="970"> 970</span>
<span id="971"> 971</span>
<span id="972"> 972</span>
<span id="973"> 973</span>
<span id="974"> 974</span>
<span id="975"> 975</span>
<span id="976"> 976</span>
<span id="977"> 977</span>
<span id="978"> 978</span>
<span id="979"> 979</span>
<span id="980"> 980</span>
<span id="981"> 981</span>
<span id="982"> 982</span>
<span id="983"> 983</span>
<span id="984"> 984</span>
<span id="985"> 985</span>
<span id="986"> 986</span>
<span id="987"> 987</span>
<span id="988"> 988</span>
<span id="989"> 989</span>
<span id="990"> 990</span>
<span id="991"> 991</span>
<span id="992"> 992</span>
<span id="993"> 993</span>
<span id="994"> 994</span>
<span id="995"> 995</span>
<span id="996"> 996</span>
<span id="997"> 997</span>
<span id="998"> 998</span>
<span id="999"> 999</span>
<span id="1000">1000</span>
<span id="1001">1001</span>
<span id="1002">1002</span>
<span id="1003">1003</span>
<span id="1004">1004</span>
<span id="1005">1005</span>
<span id="1006">1006</span>
<span id="1007">1007</span>
<span id="1008">1008</span>
<span id="1009">1009</span>
<span id="1010">1010</span>
<span id="1011">1011</span>
<span id="1012">1012</span>
<span id="1013">1013</span>
<span id="1014">1014</span>
<span id="1015">1015</span>
<span id="1016">1016</span>
<span id="1017">1017</span>
<span id="1018">1018</span>
<span id="1019">1019</span>
<span id="1020">1020</span>
<span id="1021">1021</span>
<span id="1022">1022</span>
<span id="1023">1023</span>
<span id="1024">1024</span>
<span id="1025">1025</span>
<span id="1026">1026</span>
<span id="1027">1027</span>
<span id="1028">1028</span>
<span id="1029">1029</span>
<span id="1030">1030</span>
<span id="1031">1031</span>
<span id="1032">1032</span>
<span id="1033">1033</span>
<span id="1034">1034</span>
<span id="1035">1035</span>
<span id="1036">1036</span>
<span id="1037">1037</span>
<span id="1038">1038</span>
<span id="1039">1039</span>
<span id="1040">1040</span>
<span id="1041">1041</span>
<span id="1042">1042</span>
<span id="1043">1043</span>
<span id="1044">1044</span>
<span id="1045">1045</span>
<span id="1046">1046</span>
<span id="1047">1047</span>
<span id="1048">1048</span>
<span id="1049">1049</span>
<span id="1050">1050</span>
<span id="1051">1051</span>
<span id="1052">1052</span>
<span id="1053">1053</span>
<span id="1054">1054</span>
<span id="1055">1055</span>
<span id="1056">1056</span>
<span id="1057">1057</span>
<span id="1058">1058</span>
<span id="1059">1059</span>
<span id="1060">1060</span>
<span id="1061">1061</span>
<span id="1062">1062</span>
<span id="1063">1063</span>
<span id="1064">1064</span>
<span id="1065">1065</span>
<span id="1066">1066</span>
<span id="1067">1067</span>
<span id="1068">1068</span>
<span id="1069">1069</span>
<span id="1070">1070</span>
<span id="1071">1071</span>
<span id="1072">1072</span>
<span id="1073">1073</span>
<span id="1074">1074</span>
<span id="1075">1075</span>
<span id="1076">1076</span>
<span id="1077">1077</span>
<span id="1078">1078</span>
<span id="1079">1079</span>
<span id="1080">1080</span>
<span id="1081">1081</span>
<span id="1082">1082</span>
<span id="1083">1083</span>
<span id="1084">1084</span>
<span id="1085">1085</span>
<span id="1086">1086</span>
<span id="1087">1087</span>
<span id="1088">1088</span>
<span id="1089">1089</span>
<span id="1090">1090</span>
<span id="1091">1091</span>
<span id="1092">1092</span>
<span id="1093">1093</span>
<span id="1094">1094</span>
<span id="1095">1095</span>
<span id="1096">1096</span>
<span id="1097">1097</span>
<span id="1098">1098</span>
<span id="1099">1099</span>
<span id="1100">1100</span>
<span id="1101">1101</span>
<span id="1102">1102</span>
<span id="1103">1103</span>
<span id="1104">1104</span>
<span id="1105">1105</span>
<span id="1106">1106</span>
<span id="1107">1107</span>
<span id="1108">1108</span>
<span id="1109">1109</span>
<span id="1110">1110</span>
<span id="1111">1111</span>
<span id="1112">1112</span>
<span id="1113">1113</span>
<span id="1114">1114</span>
<span id="1115">1115</span>
<span id="1116">1116</span>
<span id="1117">1117</span>
<span id="1118">1118</span>
<span id="1119">1119</span>
<span id="1120">1120</span>
<span id="1121">1121</span>
<span id="1122">1122</span>
<span id="1123">1123</span>
<span id="1124">1124</span>
<span id="1125">1125</span>
<span id="1126">1126</span>
<span id="1127">1127</span>
<span id="1128">1128</span>
<span id="1129">1129</span>
<span id="1130">1130</span>
<span id="1131">1131</span>
<span id="1132">1132</span>
<span id="1133">1133</span>
<span id="1134">1134</span>
<span id="1135">1135</span>
<span id="1136">1136</span>
<span id="1137">1137</span>
<span id="1138">1138</span>
<span id="1139">1139</span>
<span id="1140">1140</span>
<span id="1141">1141</span>
<span id="1142">1142</span>
<span id="1143">1143</span>
<span id="1144">1144</span>
<span id="1145">1145</span>
<span id="1146">1146</span>
<span id="1147">1147</span>
<span id="1148">1148</span>
<span id="1149">1149</span>
<span id="1150">1150</span>
<span id="1151">1151</span>
<span id="1152">1152</span>
<span id="1153">1153</span>
<span id="1154">1154</span>
<span id="1155">1155</span>
<span id="1156">1156</span>
<span id="1157">1157</span>
<span id="1158">1158</span>
<span id="1159">1159</span>
<span id="1160">1160</span>
<span id="1161">1161</span>
<span id="1162">1162</span>
<span id="1163">1163</span>
<span id="1164">1164</span>
<span id="1165">1165</span>
<span id="1166">1166</span>
<span id="1167">1167</span>
<span id="1168">1168</span>
<span id="1169">1169</span>
<span id="1170">1170</span>
<span id="1171">1171</span>
<span id="1172">1172</span>
<span id="1173">1173</span>
<span id="1174">1174</span>
<span id="1175">1175</span>
<span id="1176">1176</span>
<span id="1177">1177</span>
<span id="1178">1178</span>
<span id="1179">1179</span>
<span id="1180">1180</span>
<span id="1181">1181</span>
<span id="1182">1182</span>
<span id="1183">1183</span>
<span id="1184">1184</span>
<span id="1185">1185</span>
<span id="1186">1186</span>
<span id="1187">1187</span>
<span id="1188">1188</span>
<span id="1189">1189</span>
<span id="1190">1190</span>
<span id="1191">1191</span>
<span id="1192">1192</span>
<span id="1193">1193</span>
<span id="1194">1194</span>
<span id="1195">1195</span>
<span id="1196">1196</span>
<span id="1197">1197</span>
<span id="1198">1198</span>
<span id="1199">1199</span>
<span id="1200">1200</span>
<span id="1201">1201</span>
<span id="1202">1202</span>
<span id="1203">1203</span>
<span id="1204">1204</span>
<span id="1205">1205</span>
<span id="1206">1206</span>
<span id="1207">1207</span>
<span id="1208">1208</span>
<span id="1209">1209</span>
<span id="1210">1210</span>
<span id="1211">1211</span>
<span id="1212">1212</span>
<span id="1213">1213</span>
<span id="1214">1214</span>
<span id="1215">1215</span>
<span id="1216">1216</span>
<span id="1217">1217</span>
<span id="1218">1218</span>
<span id="1219">1219</span>
<span id="1220">1220</span>
<span id="1221">1221</span>
<span id="1222">1222</span>
<span id="1223">1223</span>
<span id="1224">1224</span>
<span id="1225">1225</span>
<span id="1226">1226</span>
<span id="1227">1227</span>
<span id="1228">1228</span>
<span id="1229">1229</span>
<span id="1230">1230</span>
<span id="1231">1231</span>
</pre><pre class='rust '>
<span class='comment'>// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or</span>
<span class='comment'>// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license</span>
<span class='comment'>// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your</span>
<span class='comment'>// option. This file may not be copied, modified, or distributed</span>
<span class='comment'>// except according to those terms.</span>
<span class='doccomment'>/*!
The `aessafe` module implements the AES algorithm completely in software without using any table
lookups or other timing dependant mechanisms. This module actually contains two seperate
implementations - an implementation that works on a single block at a time and a second
implementation that processes 8 blocks in parallel. Some block encryption modes really only work if
you are processing a single blocks (CFB, OFB, and CBC encryption for example) while other modes
are trivially parallelizable (CTR and CBC decryption). Processing more blocks at once allows for
greater efficiency, especially when using wide registers, such as the XMM registers available in
x86 processors.
## AES Algorithm
There are lots of places to go to on the internet for an involved description of how AES works. For
the purposes of this description, it sufficies to say that AES is just a block cipher that takes
a key of 16, 24, or 32 bytes and uses that to either encrypt or decrypt a block of 16 bytes. An
encryption or decryption operation consists of a number of rounds which involve some combination of
the following 4 basic operations:
* ShiftRows
* MixColumns
* SubBytes
* AddRoundKey
## Timing problems
Most software implementations of AES use a large set of lookup tables - generally at least the
SubBytes step is implemented via lookup tables; faster implementations generally implement the
MixColumns step this way as well. This is largely a design flaw in the AES implementation as it was
not realized during the NIST standardization process that table lookups can lead to security
problems [1]. The issue is that not all table lookups occur in constant time - an address that was
recently used is looked up much faster than one that hasn't been used in a while. A careful
adversary can measure the amount of time that each AES operation takes and use that information to
help determine the secret key or plain text information. More specifically, its not table lookups
that lead to these types of timing attacks - the issue is table lookups that use secret information
as part of the address to lookup. A table lookup that is performed the exact same way every time
regardless of the key or plaintext doesn't leak any information. This implementation uses no data
dependant table lookups.
## Bit Slicing
Bit Slicing is a technique that is basically a software emulation of hardware implementation
techniques. One of the earliest implementations of this technique was for a DES implementation [4].
In hardware, table lookups do not present the same timing problems as they do in software, however
they present other problems - namely that a 256 byte S-box table takes up a huge amount of space on
a chip. Hardware implementations, thus, tend to avoid table lookups and instead calculate the
contents of the S-Boxes as part of every operation. So, the key to an efficient Bit Sliced software
implementation is to re-arrange all of the bits of data to process into a form that can easily be
applied in much the same way that it would be in hardeware. It is fortunate, that AES was designed
such that these types of hardware implementations could be very efficient - the contents of the
S-boxes are defined by a mathematical formula.
A hardware implementation works on single bits at a time. Unlike adding variables in software,
however, that occur generally one at a time, hardware implementations are extremely parallel and
operate on many, many bits at once. Bit Slicing emulates that by moving all "equivalent" bits into
common registers and then operating on large groups of bits all at once. Calculating the S-box value
for a single bit is extremely expensive, but its much cheaper when you can amortize that cost over
128 bits (as in an XMM register). This implementation follows the same strategy as in [5] and that
is an excellent source for more specific details. However, a short description follows.
The input data is simply a collection of bytes. Each byte is comprised of 8 bits, a low order bit
(bit 0) through a high order bit (bit 7). Bit slicing the input data simply takes all of the low
order bits (bit 0) from the input data, and moves them into a single register (eg: XMM0). Next, all
of them 2nd lowest bits are moved into their own register (eg: XMM1), and so on. After completion,
we're left with 8 variables, each of which contains an equivalent set of bits. The exact order of
those bits is irrevent for the implementation of the SubBytes step, however, it is very important
for the MixColumns step. Again, see [5] for details. Due to the design of AES, its them possible to
execute the entire AES operation using just bitwise exclusive ors and rotates once we have Bit
Sliced the input data. After the completion of the AES operation, we then un-Bit Slice the data
to give us our output. Clearly, the more bits that we can process at once, the faster this will go -
thus, the version that processes 8 blocks at once is roughly 8 times faster than processing just a
single block at a time.
The ShiftRows step is fairly straight-forward to implement on the Bit Sliced state. The MixColumns
and especially the SubBytes steps are more complicated. This implementation draws heavily on the
formulas from [5], [6], and [7] to implement these steps.
## Implementation
Both implementations work basically the same way and share pretty much all of their code. The key
is first processed to create all of the round keys where each round key is just a 16 byte chunk of
data that is combined into the AES state by the AddRoundKey step as part of each encryption or
decryption round. Processing the round key can be expensive, so this is done before encryption or
decryption. Before encrypting or decrypting data, the data to be processed by be Bit Sliced into 8
seperate variables where each variable holds equivalent bytes from the state. This Bit Sliced state
is stored as a Bs8State<T>, where T is the type that stores each set of bits. The first
implementation stores these bits in a u32 which permits up to 8 * 32 = 1024 bits of data to be
processed at once. This implementation only processes a single block at a time, so, in reality, only
512 bits are processed at once and the remaining 512 bits of the variables are unused. The 2nd
implementation uses u32x4s - vectors of 4 u32s. Thus, we can process 8 * 128 = 4096 bits at once,
which corresponds exactly to 8 blocks.
The Bs8State struct implements the AesOps trait, which contains methods for each of the 4 main steps
of the AES algorithm. The types, T, each implement the AesBitValueOps trait, which containts methods
necessary for processing a collection or bit values and the AesOps trait relies heavily on this
trait to perform its operations.
The Bs4State and Bs2State struct implement operations of various subfields of the full GF(2^8)
finite field which allows for efficient computation of the AES S-Boxes. See [7] for details.
## References
[1] - "Cache-Collision Timing Attacks Against AES". Joseph Bonneau and Ilya Mironov.
http://www.jbonneau.com/doc/BM06-CHES-aes_cache_timing.pdf
[2] - "Software mitigations to hedge AES against cache-based software side channel vulnerabilities".
Ernie Brickell, et al. http://eprint.iacr.org/2006/052.pdf.
[3] - "Cache Attacks and Countermeasures: the Case of AES (Extended Version)".
Dag Arne Osvik, et al. tau.ac.il/~tromer/papers/cache.pdf‎.
[4] - "A Fast New DES Implementation in Software". Eli Biham.
http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.52.5429&rep=rep1&type=pdf.
[5] - "Faster and Timing-Attack Resistant AES-GCM". Emilia K ̈asper and Peter Schwabe.
http://www.chesworkshop.org/ches2009/presentations/01_Session_1/CHES2009_ekasper.pdf.
[6] - "FAST AES DECRYPTION". Vinit Azad. http://webcache.googleusercontent.com/
search?q=cache:ld_f8pSgURcJ:csusdspace.calstate.edu/bitstream/handle/10211.9/1224/
Vinit_Azad_MS_Report.doc%3Fsequence%3D2+&cd=4&hl=en&ct=clnk&gl=us&client=ubuntu.
[7] - "A Very Compact Rijndael S-box". D. Canright.
http://www.dtic.mil/cgi-bin/GetTRDoc?AD=ADA434781.
*/</span>
<span class='kw'>use</span> <span class='ident'>std</span>::<span class='ident'>ops</span>::{<span class='ident'>BitAnd</span>, <span class='ident'>BitXor</span>, <span class='ident'>Not</span>};
<span class='kw'>use</span> <span class='ident'>std</span>::<span class='ident'>default</span>::<span class='ident'>Default</span>;
<span class='kw'>use</span> <span class='ident'>cryptoutil</span>::{<span class='ident'>read_u32v_le</span>, <span class='ident'>write_u32_le</span>};
<span class='kw'>use</span> <span class='ident'>simd</span>::<span class='ident'>u32x4</span>;
<span class='kw'>use</span> <span class='ident'>step_by</span>::<span class='ident'>RangeExt</span>;
<span class='kw'>use</span> <span class='ident'>symmetriccipher</span>::{<span class='ident'>BlockEncryptor</span>, <span class='ident'>BlockEncryptorX8</span>, <span class='ident'>BlockDecryptor</span>, <span class='ident'>BlockDecryptorX8</span>};
<span class='kw'>const</span> <span class='ident'>U32X4_0</span>: <span class='ident'>u32x4</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>);
<span class='kw'>const</span> <span class='ident'>U32X4_1</span>: <span class='ident'>u32x4</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0xffffffff</span>, <span class='number'>0xffffffff</span>, <span class='number'>0xffffffff</span>, <span class='number'>0xffffffff</span>);
<span class='macro'>macro_rules</span><span class='macro'>!</span> <span class='ident'>define_aes_struct</span>(
(
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span>:<span class='ident'>ident</span>,
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span>:<span class='ident'>expr</span>
) <span class='op'>=></span> (
<span class='attribute'>#[<span class='ident'>derive</span>(<span class='ident'>Clone</span>, <span class='ident'>Copy</span>)]</span>
<span class='kw'>pub</span> <span class='kw'>struct</span> <span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span> {
<span class='ident'>sk</span>: [<span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>u16</span><span class='op'>></span>; (<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span> <span class='op'>+</span> <span class='number'>1</span>)]
}
)
);
<span class='macro'>macro_rules</span><span class='macro'>!</span> <span class='ident'>define_aes_impl</span>(
(
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span>:<span class='ident'>ident</span>,
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>mode</span>:<span class='ident'>ident</span>,
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span>:<span class='ident'>expr</span>,
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>key_size</span>:<span class='ident'>expr</span>
) <span class='op'>=></span> (
<span class='kw'>impl</span> <span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span> {
<span class='kw'>pub</span> <span class='kw'>fn</span> <span class='ident'>new</span>(<span class='ident'>key</span>: <span class='kw-2'>&</span>[<span class='ident'>u8</span>]) <span class='op'>-></span> <span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span> {
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span> {
<span class='ident'>sk</span>: [<span class='ident'>Bs8State</span>(<span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>); (<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span> <span class='op'>+</span> <span class='number'>1</span>)]
};
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>tmp</span> <span class='op'>=</span> [[<span class='number'>0u32</span>; <span class='number'>4</span>]; (<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span> <span class='op'>+</span> <span class='number'>1</span>)];
<span class='ident'>create_round_keys</span>(<span class='ident'>key</span>, <span class='ident'>KeyType</span>::<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>mode</span>, <span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>tmp</span>);
<span class='kw'>for</span> <span class='ident'>i</span> <span class='kw'>in</span> <span class='number'>0</span>..<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span> <span class='op'>+</span> <span class='number'>1</span> {
<span class='ident'>a</span>.<span class='ident'>sk</span>[<span class='ident'>i</span>] <span class='op'>=</span> <span class='ident'>bit_slice_4x4_with_u16</span>(<span class='ident'>tmp</span>[<span class='ident'>i</span>][<span class='number'>0</span>], <span class='ident'>tmp</span>[<span class='ident'>i</span>][<span class='number'>1</span>], <span class='ident'>tmp</span>[<span class='ident'>i</span>][<span class='number'>2</span>], <span class='ident'>tmp</span>[<span class='ident'>i</span>][<span class='number'>3</span>]);
}
<span class='ident'>a</span>
}
}
)
);
<span class='macro'>macro_rules</span><span class='macro'>!</span> <span class='ident'>define_aes_enc</span>(
(
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span>:<span class='ident'>ident</span>,
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span>:<span class='ident'>expr</span>
) <span class='op'>=></span> (
<span class='kw'>impl</span> <span class='ident'>BlockEncryptor</span> <span class='kw'>for</span> <span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span> {
<span class='kw'>fn</span> <span class='ident'>block_size</span>(<span class='kw-2'>&</span><span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>usize</span> { <span class='number'>16</span> }
<span class='kw'>fn</span> <span class='ident'>encrypt_block</span>(<span class='kw-2'>&</span><span class='self'>self</span>, <span class='ident'>input</span>: <span class='kw-2'>&</span>[<span class='ident'>u8</span>], <span class='ident'>output</span>: <span class='kw-2'>&</span><span class='kw-2'>mut</span> [<span class='ident'>u8</span>]) {
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>bs</span> <span class='op'>=</span> <span class='ident'>bit_slice_1x16_with_u16</span>(<span class='ident'>input</span>);
<span class='ident'>bs</span> <span class='op'>=</span> <span class='ident'>encrypt_core</span>(<span class='kw-2'>&</span><span class='ident'>bs</span>, <span class='kw-2'>&</span><span class='self'>self</span>.<span class='ident'>sk</span>);
<span class='ident'>un_bit_slice_1x16_with_u16</span>(<span class='kw-2'>&</span><span class='ident'>bs</span>, <span class='ident'>output</span>);
}
}
)
);
<span class='macro'>macro_rules</span><span class='macro'>!</span> <span class='ident'>define_aes_dec</span>(
(
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span>:<span class='ident'>ident</span>,
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span>:<span class='ident'>expr</span>
) <span class='op'>=></span> (
<span class='kw'>impl</span> <span class='ident'>BlockDecryptor</span> <span class='kw'>for</span> <span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span> {
<span class='kw'>fn</span> <span class='ident'>block_size</span>(<span class='kw-2'>&</span><span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>usize</span> { <span class='number'>16</span> }
<span class='kw'>fn</span> <span class='ident'>decrypt_block</span>(<span class='kw-2'>&</span><span class='self'>self</span>, <span class='ident'>input</span>: <span class='kw-2'>&</span>[<span class='ident'>u8</span>], <span class='ident'>output</span>: <span class='kw-2'>&</span><span class='kw-2'>mut</span> [<span class='ident'>u8</span>]) {
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>bs</span> <span class='op'>=</span> <span class='ident'>bit_slice_1x16_with_u16</span>(<span class='ident'>input</span>);
<span class='ident'>bs</span> <span class='op'>=</span> <span class='ident'>decrypt_core</span>(<span class='kw-2'>&</span><span class='ident'>bs</span>, <span class='kw-2'>&</span><span class='self'>self</span>.<span class='ident'>sk</span>);
<span class='ident'>un_bit_slice_1x16_with_u16</span>(<span class='kw-2'>&</span><span class='ident'>bs</span>, <span class='ident'>output</span>);
}
}
)
);
<span class='macro'>define_aes_struct</span><span class='macro'>!</span>(<span class='ident'>AesSafe128Encryptor</span>, <span class='number'>10</span>);
<span class='macro'>define_aes_struct</span><span class='macro'>!</span>(<span class='ident'>AesSafe128Decryptor</span>, <span class='number'>10</span>);
<span class='macro'>define_aes_impl</span><span class='macro'>!</span>(<span class='ident'>AesSafe128Encryptor</span>, <span class='ident'>Encryption</span>, <span class='number'>10</span>, <span class='number'>16</span>);
<span class='macro'>define_aes_impl</span><span class='macro'>!</span>(<span class='ident'>AesSafe128Decryptor</span>, <span class='ident'>Decryption</span>, <span class='number'>10</span>, <span class='number'>16</span>);
<span class='macro'>define_aes_enc</span><span class='macro'>!</span>(<span class='ident'>AesSafe128Encryptor</span>, <span class='number'>10</span>);
<span class='macro'>define_aes_dec</span><span class='macro'>!</span>(<span class='ident'>AesSafe128Decryptor</span>, <span class='number'>10</span>);
<span class='macro'>define_aes_struct</span><span class='macro'>!</span>(<span class='ident'>AesSafe192Encryptor</span>, <span class='number'>12</span>);
<span class='macro'>define_aes_struct</span><span class='macro'>!</span>(<span class='ident'>AesSafe192Decryptor</span>, <span class='number'>12</span>);
<span class='macro'>define_aes_impl</span><span class='macro'>!</span>(<span class='ident'>AesSafe192Encryptor</span>, <span class='ident'>Encryption</span>, <span class='number'>12</span>, <span class='number'>24</span>);
<span class='macro'>define_aes_impl</span><span class='macro'>!</span>(<span class='ident'>AesSafe192Decryptor</span>, <span class='ident'>Decryption</span>, <span class='number'>12</span>, <span class='number'>24</span>);
<span class='macro'>define_aes_enc</span><span class='macro'>!</span>(<span class='ident'>AesSafe192Encryptor</span>, <span class='number'>12</span>);
<span class='macro'>define_aes_dec</span><span class='macro'>!</span>(<span class='ident'>AesSafe192Decryptor</span>, <span class='number'>12</span>);
<span class='macro'>define_aes_struct</span><span class='macro'>!</span>(<span class='ident'>AesSafe256Encryptor</span>, <span class='number'>14</span>);
<span class='macro'>define_aes_struct</span><span class='macro'>!</span>(<span class='ident'>AesSafe256Decryptor</span>, <span class='number'>14</span>);
<span class='macro'>define_aes_impl</span><span class='macro'>!</span>(<span class='ident'>AesSafe256Encryptor</span>, <span class='ident'>Encryption</span>, <span class='number'>14</span>, <span class='number'>32</span>);
<span class='macro'>define_aes_impl</span><span class='macro'>!</span>(<span class='ident'>AesSafe256Decryptor</span>, <span class='ident'>Decryption</span>, <span class='number'>14</span>, <span class='number'>32</span>);
<span class='macro'>define_aes_enc</span><span class='macro'>!</span>(<span class='ident'>AesSafe256Encryptor</span>, <span class='number'>14</span>);
<span class='macro'>define_aes_dec</span><span class='macro'>!</span>(<span class='ident'>AesSafe256Decryptor</span>, <span class='number'>14</span>);
<span class='macro'>macro_rules</span><span class='macro'>!</span> <span class='ident'>define_aes_struct_x8</span>(
(
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span>:<span class='ident'>ident</span>,
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span>:<span class='ident'>expr</span>
) <span class='op'>=></span> (
<span class='attribute'>#[<span class='ident'>derive</span>(<span class='ident'>Clone</span>, <span class='ident'>Copy</span>)]</span>
<span class='kw'>pub</span> <span class='kw'>struct</span> <span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span> {
<span class='ident'>sk</span>: [<span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>u32x4</span><span class='op'>></span>; (<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span> <span class='op'>+</span> <span class='number'>1</span>)]
}
)
);
<span class='macro'>macro_rules</span><span class='macro'>!</span> <span class='ident'>define_aes_impl_x8</span>(
(
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span>:<span class='ident'>ident</span>,
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>mode</span>:<span class='ident'>ident</span>,
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span>:<span class='ident'>expr</span>,
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>key_size</span>:<span class='ident'>expr</span>
) <span class='op'>=></span> (
<span class='kw'>impl</span> <span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span> {
<span class='kw'>pub</span> <span class='kw'>fn</span> <span class='ident'>new</span>(<span class='ident'>key</span>: <span class='kw-2'>&</span>[<span class='ident'>u8</span>]) <span class='op'>-></span> <span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span> {
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span> {
<span class='ident'>sk</span>: [
<span class='ident'>Bs8State</span>(
<span class='ident'>U32X4_0</span>,
<span class='ident'>U32X4_0</span>,
<span class='ident'>U32X4_0</span>,
<span class='ident'>U32X4_0</span>,
<span class='ident'>U32X4_0</span>,
<span class='ident'>U32X4_0</span>,
<span class='ident'>U32X4_0</span>,
<span class='ident'>U32X4_0</span>);
(<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span> <span class='op'>+</span> <span class='number'>1</span>)]
};
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>tmp</span> <span class='op'>=</span> [[<span class='number'>0u32</span>; <span class='number'>4</span>]; (<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span> <span class='op'>+</span> <span class='number'>1</span>)];
<span class='ident'>create_round_keys</span>(<span class='ident'>key</span>, <span class='ident'>KeyType</span>::<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>mode</span>, <span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>tmp</span>);
<span class='kw'>for</span> <span class='ident'>i</span> <span class='kw'>in</span> <span class='number'>0</span>..<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span> <span class='op'>+</span> <span class='number'>1</span> {
<span class='ident'>a</span>.<span class='ident'>sk</span>[<span class='ident'>i</span>] <span class='op'>=</span> <span class='ident'>bit_slice_fill_4x4_with_u32x4</span>(
<span class='ident'>tmp</span>[<span class='ident'>i</span>][<span class='number'>0</span>],
<span class='ident'>tmp</span>[<span class='ident'>i</span>][<span class='number'>1</span>],
<span class='ident'>tmp</span>[<span class='ident'>i</span>][<span class='number'>2</span>],
<span class='ident'>tmp</span>[<span class='ident'>i</span>][<span class='number'>3</span>]);
}
<span class='ident'>a</span>
}
}
)
);
<span class='macro'>macro_rules</span><span class='macro'>!</span> <span class='ident'>define_aes_enc_x8</span>(
(
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span>:<span class='ident'>ident</span>,
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span>:<span class='ident'>expr</span>
) <span class='op'>=></span> (
<span class='kw'>impl</span> <span class='ident'>BlockEncryptorX8</span> <span class='kw'>for</span> <span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span> {
<span class='kw'>fn</span> <span class='ident'>block_size</span>(<span class='kw-2'>&</span><span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>usize</span> { <span class='number'>16</span> }
<span class='kw'>fn</span> <span class='ident'>encrypt_block_x8</span>(<span class='kw-2'>&</span><span class='self'>self</span>, <span class='ident'>input</span>: <span class='kw-2'>&</span>[<span class='ident'>u8</span>], <span class='ident'>output</span>: <span class='kw-2'>&</span><span class='kw-2'>mut</span> [<span class='ident'>u8</span>]) {
<span class='kw'>let</span> <span class='ident'>bs</span> <span class='op'>=</span> <span class='ident'>bit_slice_1x128_with_u32x4</span>(<span class='ident'>input</span>);
<span class='kw'>let</span> <span class='ident'>bs2</span> <span class='op'>=</span> <span class='ident'>encrypt_core</span>(<span class='kw-2'>&</span><span class='ident'>bs</span>, <span class='kw-2'>&</span><span class='self'>self</span>.<span class='ident'>sk</span>);
<span class='ident'>un_bit_slice_1x128_with_u32x4</span>(<span class='ident'>bs2</span>, <span class='ident'>output</span>);
}
}
)
);
<span class='macro'>macro_rules</span><span class='macro'>!</span> <span class='ident'>define_aes_dec_x8</span>(
(
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span>:<span class='ident'>ident</span>,
<span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>rounds</span>:<span class='ident'>expr</span>
) <span class='op'>=></span> (
<span class='kw'>impl</span> <span class='ident'>BlockDecryptorX8</span> <span class='kw'>for</span> <span class='macro-nonterminal'>$</span><span class='macro-nonterminal'>name</span> {
<span class='kw'>fn</span> <span class='ident'>block_size</span>(<span class='kw-2'>&</span><span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>usize</span> { <span class='number'>16</span> }
<span class='kw'>fn</span> <span class='ident'>decrypt_block_x8</span>(<span class='kw-2'>&</span><span class='self'>self</span>, <span class='ident'>input</span>: <span class='kw-2'>&</span>[<span class='ident'>u8</span>], <span class='ident'>output</span>: <span class='kw-2'>&</span><span class='kw-2'>mut</span> [<span class='ident'>u8</span>]) {
<span class='kw'>let</span> <span class='ident'>bs</span> <span class='op'>=</span> <span class='ident'>bit_slice_1x128_with_u32x4</span>(<span class='ident'>input</span>);
<span class='kw'>let</span> <span class='ident'>bs2</span> <span class='op'>=</span> <span class='ident'>decrypt_core</span>(<span class='kw-2'>&</span><span class='ident'>bs</span>, <span class='kw-2'>&</span><span class='self'>self</span>.<span class='ident'>sk</span>);
<span class='ident'>un_bit_slice_1x128_with_u32x4</span>(<span class='ident'>bs2</span>, <span class='ident'>output</span>);
}
}
)
);
<span class='macro'>define_aes_struct_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe128EncryptorX8</span>, <span class='number'>10</span>);
<span class='macro'>define_aes_struct_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe128DecryptorX8</span>, <span class='number'>10</span>);
<span class='macro'>define_aes_impl_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe128EncryptorX8</span>, <span class='ident'>Encryption</span>, <span class='number'>10</span>, <span class='number'>16</span>);
<span class='macro'>define_aes_impl_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe128DecryptorX8</span>, <span class='ident'>Decryption</span>, <span class='number'>10</span>, <span class='number'>16</span>);
<span class='macro'>define_aes_enc_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe128EncryptorX8</span>, <span class='number'>10</span>);
<span class='macro'>define_aes_dec_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe128DecryptorX8</span>, <span class='number'>10</span>);
<span class='macro'>define_aes_struct_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe192EncryptorX8</span>, <span class='number'>12</span>);
<span class='macro'>define_aes_struct_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe192DecryptorX8</span>, <span class='number'>12</span>);
<span class='macro'>define_aes_impl_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe192EncryptorX8</span>, <span class='ident'>Encryption</span>, <span class='number'>12</span>, <span class='number'>24</span>);
<span class='macro'>define_aes_impl_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe192DecryptorX8</span>, <span class='ident'>Decryption</span>, <span class='number'>12</span>, <span class='number'>24</span>);
<span class='macro'>define_aes_enc_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe192EncryptorX8</span>, <span class='number'>12</span>);
<span class='macro'>define_aes_dec_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe192DecryptorX8</span>, <span class='number'>12</span>);
<span class='macro'>define_aes_struct_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe256EncryptorX8</span>, <span class='number'>14</span>);
<span class='macro'>define_aes_struct_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe256DecryptorX8</span>, <span class='number'>14</span>);
<span class='macro'>define_aes_impl_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe256EncryptorX8</span>, <span class='ident'>Encryption</span>, <span class='number'>14</span>, <span class='number'>32</span>);
<span class='macro'>define_aes_impl_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe256DecryptorX8</span>, <span class='ident'>Decryption</span>, <span class='number'>14</span>, <span class='number'>32</span>);
<span class='macro'>define_aes_enc_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe256EncryptorX8</span>, <span class='number'>14</span>);
<span class='macro'>define_aes_dec_x8</span><span class='macro'>!</span>(<span class='ident'>AesSafe256DecryptorX8</span>, <span class='number'>14</span>);
<span class='kw'>fn</span> <span class='ident'>ffmulx</span>(<span class='ident'>x</span>: <span class='ident'>u32</span>) <span class='op'>-></span> <span class='ident'>u32</span> {
<span class='kw'>let</span> <span class='ident'>m1</span>: <span class='ident'>u32</span> <span class='op'>=</span> <span class='number'>0x80808080</span>;
<span class='kw'>let</span> <span class='ident'>m2</span>: <span class='ident'>u32</span> <span class='op'>=</span> <span class='number'>0x7f7f7f7f</span>;
<span class='kw'>let</span> <span class='ident'>m3</span>: <span class='ident'>u32</span> <span class='op'>=</span> <span class='number'>0x0000001b</span>;
((<span class='ident'>x</span> <span class='op'>&</span> <span class='ident'>m2</span>) <span class='op'><<</span> <span class='number'>1</span>) <span class='op'>^</span> (((<span class='ident'>x</span> <span class='op'>&</span> <span class='ident'>m1</span>) <span class='op'>>></span> <span class='number'>7</span>) <span class='op'>*</span> <span class='ident'>m3</span>)
}
<span class='kw'>fn</span> <span class='ident'>inv_mcol</span>(<span class='ident'>x</span>: <span class='ident'>u32</span>) <span class='op'>-></span> <span class='ident'>u32</span> {
<span class='kw'>let</span> <span class='ident'>f2</span> <span class='op'>=</span> <span class='ident'>ffmulx</span>(<span class='ident'>x</span>);
<span class='kw'>let</span> <span class='ident'>f4</span> <span class='op'>=</span> <span class='ident'>ffmulx</span>(<span class='ident'>f2</span>);
<span class='kw'>let</span> <span class='ident'>f8</span> <span class='op'>=</span> <span class='ident'>ffmulx</span>(<span class='ident'>f4</span>);
<span class='kw'>let</span> <span class='ident'>f9</span> <span class='op'>=</span> <span class='ident'>x</span> <span class='op'>^</span> <span class='ident'>f8</span>;
<span class='ident'>f2</span> <span class='op'>^</span> <span class='ident'>f4</span> <span class='op'>^</span> <span class='ident'>f8</span> <span class='op'>^</span> (<span class='ident'>f2</span> <span class='op'>^</span> <span class='ident'>f9</span>).<span class='ident'>rotate_right</span>(<span class='number'>8</span>) <span class='op'>^</span> (<span class='ident'>f4</span> <span class='op'>^</span> <span class='ident'>f9</span>).<span class='ident'>rotate_right</span>(<span class='number'>16</span>) <span class='op'>^</span> <span class='ident'>f9</span>.<span class='ident'>rotate_right</span>(<span class='number'>24</span>)
}
<span class='kw'>fn</span> <span class='ident'>sub_word</span>(<span class='ident'>x</span>: <span class='ident'>u32</span>) <span class='op'>-></span> <span class='ident'>u32</span> {
<span class='kw'>let</span> <span class='ident'>bs</span> <span class='op'>=</span> <span class='ident'>bit_slice_4x1_with_u16</span>(<span class='ident'>x</span>).<span class='ident'>sub_bytes</span>();
<span class='ident'>un_bit_slice_4x1_with_u16</span>(<span class='kw-2'>&</span><span class='ident'>bs</span>)
}
<span class='kw'>enum</span> <span class='ident'>KeyType</span> {
<span class='ident'>Encryption</span>,
<span class='ident'>Decryption</span>
}
<span class='comment'>// This array is not accessed in any key-dependant way, so there are no timing problems inherent in</span>
<span class='comment'>// using it.</span>
<span class='kw'>static</span> <span class='ident'>RCON</span>: [<span class='ident'>u32</span>; <span class='number'>10</span>] <span class='op'>=</span> [<span class='number'>0x01</span>, <span class='number'>0x02</span>, <span class='number'>0x04</span>, <span class='number'>0x08</span>, <span class='number'>0x10</span>, <span class='number'>0x20</span>, <span class='number'>0x40</span>, <span class='number'>0x80</span>, <span class='number'>0x1b</span>, <span class='number'>0x36</span>];
<span class='comment'>// The round keys are created without bit-slicing the key data. The individual implementations bit</span>
<span class='comment'>// slice the round keys returned from this function. This function, and the few functions above, are</span>
<span class='comment'>// derived from the BouncyCastle AES implementation.</span>
<span class='kw'>fn</span> <span class='ident'>create_round_keys</span>(<span class='ident'>key</span>: <span class='kw-2'>&</span>[<span class='ident'>u8</span>], <span class='ident'>key_type</span>: <span class='ident'>KeyType</span>, <span class='ident'>round_keys</span>: <span class='kw-2'>&</span><span class='kw-2'>mut</span> [[<span class='ident'>u32</span>; <span class='number'>4</span>]]) {
<span class='kw'>let</span> (<span class='ident'>key_words</span>, <span class='ident'>rounds</span>) <span class='op'>=</span> <span class='kw'>match</span> <span class='ident'>key</span>.<span class='ident'>len</span>() {
<span class='number'>16</span> <span class='op'>=></span> (<span class='number'>4</span>, <span class='number'>10</span>),
<span class='number'>24</span> <span class='op'>=></span> (<span class='number'>6</span>, <span class='number'>12</span>),
<span class='number'>32</span> <span class='op'>=></span> (<span class='number'>8</span>, <span class='number'>14</span>),
_ <span class='op'>=></span> <span class='macro'>panic</span><span class='macro'>!</span>(<span class='string'>"Invalid AES key size."</span>)
};
<span class='comment'>// The key is copied directly into the first few round keys</span>
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>j</span> <span class='op'>=</span> <span class='number'>0</span>;
<span class='kw'>for</span> <span class='ident'>i</span> <span class='kw'>in</span> (<span class='number'>0</span>..<span class='ident'>key</span>.<span class='ident'>len</span>()).<span class='ident'>step_up</span>(<span class='number'>4</span>) {
<span class='ident'>round_keys</span>[<span class='ident'>j</span> <span class='op'>/</span> <span class='number'>4</span>][<span class='ident'>j</span> <span class='op'>%</span> <span class='number'>4</span>] <span class='op'>=</span>
(<span class='ident'>key</span>[<span class='ident'>i</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'>|</span>
((<span class='ident'>key</span>[<span class='ident'>i</span><span class='op'>+</span><span class='number'>1</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='number'>8</span>) <span class='op'>|</span>
((<span class='ident'>key</span>[<span class='ident'>i</span><span class='op'>+</span><span class='number'>2</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='number'>16</span>) <span class='op'>|</span>
((<span class='ident'>key</span>[<span class='ident'>i</span><span class='op'>+</span><span class='number'>3</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='number'>24</span>);
<span class='ident'>j</span> <span class='op'>+=</span> <span class='number'>1</span>;
};
<span class='comment'>// Calculate the rest of the round keys</span>
<span class='kw'>for</span> <span class='ident'>i</span> <span class='kw'>in</span> <span class='ident'>key_words</span>..(<span class='ident'>rounds</span> <span class='op'>+</span> <span class='number'>1</span>) <span class='op'>*</span> <span class='number'>4</span> {
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>round_keys</span>[(<span class='ident'>i</span> <span class='op'>-</span> <span class='number'>1</span>) <span class='op'>/</span> <span class='number'>4</span>][(<span class='ident'>i</span> <span class='op'>-</span> <span class='number'>1</span>) <span class='op'>%</span> <span class='number'>4</span>];
<span class='kw'>if</span> (<span class='ident'>i</span> <span class='op'>%</span> <span class='ident'>key_words</span>) <span class='op'>==</span> <span class='number'>0</span> {
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>sub_word</span>(<span class='ident'>tmp</span>.<span class='ident'>rotate_right</span>(<span class='number'>8</span>)) <span class='op'>^</span> <span class='ident'>RCON</span>[(<span class='ident'>i</span> <span class='op'>/</span> <span class='ident'>key_words</span>) <span class='op'>-</span> <span class='number'>1</span>];
} <span class='kw'>else</span> <span class='kw'>if</span> (<span class='ident'>key_words</span> <span class='op'>==</span> <span class='number'>8</span>) <span class='op'>&&</span> ((<span class='ident'>i</span> <span class='op'>%</span> <span class='ident'>key_words</span>) <span class='op'>==</span> <span class='number'>4</span>) {
<span class='comment'>// This is only necessary for AES-256 keys</span>
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>sub_word</span>(<span class='ident'>tmp</span>);
}
<span class='ident'>round_keys</span>[<span class='ident'>i</span> <span class='op'>/</span> <span class='number'>4</span>][<span class='ident'>i</span> <span class='op'>%</span> <span class='number'>4</span>] <span class='op'>=</span> <span class='ident'>round_keys</span>[(<span class='ident'>i</span> <span class='op'>-</span> <span class='ident'>key_words</span>) <span class='op'>/</span> <span class='number'>4</span>][(<span class='ident'>i</span> <span class='op'>-</span> <span class='ident'>key_words</span>) <span class='op'>%</span> <span class='number'>4</span>] <span class='op'>^</span> <span class='ident'>tmp</span>;
}
<span class='comment'>// Decryption round keys require extra processing</span>
<span class='kw'>match</span> <span class='ident'>key_type</span> {
<span class='ident'>KeyType</span>::<span class='ident'>Decryption</span> <span class='op'>=></span> {
<span class='kw'>for</span> <span class='ident'>j</span> <span class='kw'>in</span> <span class='number'>1</span>..<span class='ident'>rounds</span> {
<span class='kw'>for</span> <span class='ident'>i</span> <span class='kw'>in</span> <span class='number'>0</span>..<span class='number'>4</span> {
<span class='ident'>round_keys</span>[<span class='ident'>j</span>][<span class='ident'>i</span>] <span class='op'>=</span> <span class='ident'>inv_mcol</span>(<span class='ident'>round_keys</span>[<span class='ident'>j</span>][<span class='ident'>i</span>]);
}
}
},
<span class='ident'>KeyType</span>::<span class='ident'>Encryption</span> <span class='op'>=></span> { }
}
}
<span class='comment'>// This trait defines all of the operations needed for a type to be processed as part of an AES</span>
<span class='comment'>// encryption or decryption operation.</span>
<span class='kw'>trait</span> <span class='ident'>AesOps</span> {
<span class='kw'>fn</span> <span class='ident'>sub_bytes</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='kw'>fn</span> <span class='ident'>inv_sub_bytes</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='kw'>fn</span> <span class='ident'>shift_rows</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='kw'>fn</span> <span class='ident'>inv_shift_rows</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='kw'>fn</span> <span class='ident'>mix_columns</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='kw'>fn</span> <span class='ident'>inv_mix_columns</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='kw'>fn</span> <span class='ident'>add_round_key</span>(<span class='self'>self</span>, <span class='ident'>rk</span>: <span class='kw-2'>&</span><span class='self'>Self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
}
<span class='kw'>fn</span> <span class='ident'>encrypt_core</span><span class='op'><</span><span class='ident'>S</span>: <span class='ident'>AesOps</span> <span class='op'>+</span> <span class='ident'>Copy</span><span class='op'>></span>(<span class='ident'>state</span>: <span class='kw-2'>&</span><span class='ident'>S</span>, <span class='ident'>sk</span>: <span class='kw-2'>&</span>[<span class='ident'>S</span>]) <span class='op'>-></span> <span class='ident'>S</span> {
<span class='comment'>// Round 0 - add round key</span>
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>state</span>.<span class='ident'>add_round_key</span>(<span class='kw-2'>&</span><span class='ident'>sk</span>[<span class='number'>0</span>]);
<span class='comment'>// Remaining rounds (except last round)</span>
<span class='kw'>for</span> <span class='ident'>i</span> <span class='kw'>in</span> <span class='number'>1</span>..<span class='ident'>sk</span>.<span class='ident'>len</span>() <span class='op'>-</span> <span class='number'>1</span> {
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>tmp</span>.<span class='ident'>sub_bytes</span>();
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>tmp</span>.<span class='ident'>shift_rows</span>();
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>tmp</span>.<span class='ident'>mix_columns</span>();
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>tmp</span>.<span class='ident'>add_round_key</span>(<span class='kw-2'>&</span><span class='ident'>sk</span>[<span class='ident'>i</span>]);
}
<span class='comment'>// Last round</span>
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>tmp</span>.<span class='ident'>sub_bytes</span>();
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>tmp</span>.<span class='ident'>shift_rows</span>();
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>tmp</span>.<span class='ident'>add_round_key</span>(<span class='kw-2'>&</span><span class='ident'>sk</span>[<span class='ident'>sk</span>.<span class='ident'>len</span>() <span class='op'>-</span> <span class='number'>1</span>]);
<span class='ident'>tmp</span>
}
<span class='kw'>fn</span> <span class='ident'>decrypt_core</span><span class='op'><</span><span class='ident'>S</span>: <span class='ident'>AesOps</span> <span class='op'>+</span> <span class='ident'>Copy</span><span class='op'>></span>(<span class='ident'>state</span>: <span class='kw-2'>&</span><span class='ident'>S</span>, <span class='ident'>sk</span>: <span class='kw-2'>&</span>[<span class='ident'>S</span>]) <span class='op'>-></span> <span class='ident'>S</span> {
<span class='comment'>// Round 0 - add round key</span>
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>state</span>.<span class='ident'>add_round_key</span>(<span class='kw-2'>&</span><span class='ident'>sk</span>[<span class='ident'>sk</span>.<span class='ident'>len</span>() <span class='op'>-</span> <span class='number'>1</span>]);
<span class='comment'>// Remaining rounds (except last round)</span>
<span class='kw'>for</span> <span class='ident'>i</span> <span class='kw'>in</span> <span class='number'>1</span>..<span class='ident'>sk</span>.<span class='ident'>len</span>() <span class='op'>-</span> <span class='number'>1</span> {
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>tmp</span>.<span class='ident'>inv_sub_bytes</span>();
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>tmp</span>.<span class='ident'>inv_shift_rows</span>();
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>tmp</span>.<span class='ident'>inv_mix_columns</span>();
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>tmp</span>.<span class='ident'>add_round_key</span>(<span class='kw-2'>&</span><span class='ident'>sk</span>[<span class='ident'>sk</span>.<span class='ident'>len</span>() <span class='op'>-</span> <span class='number'>1</span> <span class='op'>-</span> <span class='ident'>i</span>]);
}
<span class='comment'>// Last round</span>
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>tmp</span>.<span class='ident'>inv_sub_bytes</span>();
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>tmp</span>.<span class='ident'>inv_shift_rows</span>();
<span class='ident'>tmp</span> <span class='op'>=</span> <span class='ident'>tmp</span>.<span class='ident'>add_round_key</span>(<span class='kw-2'>&</span><span class='ident'>sk</span>[<span class='number'>0</span>]);
<span class='ident'>tmp</span>
}
<span class='attribute'>#[<span class='ident'>derive</span>(<span class='ident'>Clone</span>, <span class='ident'>Copy</span>)]</span>
<span class='kw'>struct</span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span>(<span class='ident'>T</span>, <span class='ident'>T</span>, <span class='ident'>T</span>, <span class='ident'>T</span>, <span class='ident'>T</span>, <span class='ident'>T</span>, <span class='ident'>T</span>, <span class='ident'>T</span>);
<span class='kw'>impl</span> <span class='op'><</span><span class='ident'>T</span>: <span class='ident'>Copy</span><span class='op'>></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>fn</span> <span class='ident'>split</span>(<span class='self'>self</span>) <span class='op'>-></span> (<span class='ident'>Bs4State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span>, <span class='ident'>Bs4State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span>) {
<span class='kw'>let</span> <span class='ident'>Bs8State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>, <span class='ident'>x2</span>, <span class='ident'>x3</span>, <span class='ident'>x4</span>, <span class='ident'>x5</span>, <span class='ident'>x6</span>, <span class='ident'>x7</span>) <span class='op'>=</span> <span class='self'>self</span>;
(<span class='ident'>Bs4State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>, <span class='ident'>x2</span>, <span class='ident'>x3</span>), <span class='ident'>Bs4State</span>(<span class='ident'>x4</span>, <span class='ident'>x5</span>, <span class='ident'>x6</span>, <span class='ident'>x7</span>))
}
}
<span class='kw'>impl</span> <span class='op'><</span><span class='ident'>T</span>: <span class='ident'>BitXor</span><span class='op'><</span><span class='ident'>Output</span> <span class='op'>=</span> <span class='ident'>T</span><span class='op'>></span> <span class='op'>+</span> <span class='ident'>Copy</span><span class='op'>></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>fn</span> <span class='ident'>xor</span>(<span class='self'>self</span>, <span class='ident'>rhs</span>: <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>Bs8State</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span>, <span class='ident'>a2</span>, <span class='ident'>a3</span>, <span class='ident'>a4</span>, <span class='ident'>a5</span>, <span class='ident'>a6</span>, <span class='ident'>a7</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='kw'>let</span> <span class='ident'>Bs8State</span>(<span class='ident'>b0</span>, <span class='ident'>b1</span>, <span class='ident'>b2</span>, <span class='ident'>b3</span>, <span class='ident'>b4</span>, <span class='ident'>b5</span>, <span class='ident'>b6</span>, <span class='ident'>b7</span>) <span class='op'>=</span> <span class='ident'>rhs</span>;
<span class='ident'>Bs8State</span>(<span class='ident'>a0</span> <span class='op'>^</span> <span class='ident'>b0</span>, <span class='ident'>a1</span> <span class='op'>^</span> <span class='ident'>b1</span>, <span class='ident'>a2</span> <span class='op'>^</span> <span class='ident'>b2</span>, <span class='ident'>a3</span> <span class='op'>^</span> <span class='ident'>b3</span>, <span class='ident'>a4</span> <span class='op'>^</span> <span class='ident'>b4</span>, <span class='ident'>a5</span> <span class='op'>^</span> <span class='ident'>b5</span>, <span class='ident'>a6</span> <span class='op'>^</span> <span class='ident'>b6</span>, <span class='ident'>a7</span> <span class='op'>^</span> <span class='ident'>b7</span>)
}
<span class='comment'>// We need to be able to convert a Bs8State to and from a polynomial basis and a normal</span>
<span class='comment'>// basis. That transformation could be done via pseudocode that roughly looks like the</span>
<span class='comment'>// following:</span>
<span class='comment'>//</span>
<span class='comment'>// for x in 0..8 {</span>
<span class='comment'>// for y in 0..8 {</span>
<span class='comment'>// result.x ^= input.y & MATRIX[7 - y][x]</span>
<span class='comment'>// }</span>
<span class='comment'>// }</span>
<span class='comment'>//</span>
<span class='comment'>// Where the MATRIX is one of the following depending on the conversion being done.</span>
<span class='comment'>// (The affine transformation step is included in all of these matrices):</span>
<span class='comment'>//</span>
<span class='comment'>// A2X = [</span>
<span class='comment'>// [ 0, 0, 0, -1, -1, 0, 0, -1],</span>
<span class='comment'>// [-1, -1, 0, 0, -1, -1, -1, -1],</span>
<span class='comment'>// [ 0, -1, 0, 0, -1, -1, -1, -1],</span>
<span class='comment'>// [ 0, 0, 0, -1, 0, 0, -1, 0],</span>
<span class='comment'>// [-1, 0, 0, -1, 0, 0, 0, 0],</span>
<span class='comment'>// [-1, 0, 0, 0, 0, 0, 0, -1],</span>
<span class='comment'>// [-1, 0, 0, -1, 0, -1, 0, -1],</span>
<span class='comment'>// [-1, -1, -1, -1, -1, -1, -1, -1]</span>
<span class='comment'>// ];</span>
<span class='comment'>//</span>
<span class='comment'>// X2A = [</span>
<span class='comment'>// [ 0, 0, -1, 0, 0, -1, -1, 0],</span>
<span class='comment'>// [ 0, 0, 0, -1, -1, -1, -1, 0],</span>
<span class='comment'>// [ 0, -1, -1, -1, 0, -1, -1, 0],</span>
<span class='comment'>// [ 0, 0, -1, -1, 0, 0, 0, -1],</span>
<span class='comment'>// [ 0, 0, 0, -1, 0, -1, -1, 0],</span>
<span class='comment'>// [-1, 0, 0, -1, 0, -1, 0, 0],</span>
<span class='comment'>// [ 0, -1, -1, -1, -1, 0, -1, -1],</span>
<span class='comment'>// [ 0, 0, 0, 0, 0, -1, -1, 0],</span>
<span class='comment'>// ];</span>
<span class='comment'>//</span>
<span class='comment'>// X2S = [</span>
<span class='comment'>// [ 0, 0, 0, -1, -1, 0, -1, 0],</span>
<span class='comment'>// [-1, 0, -1, -1, 0, -1, 0, 0],</span>
<span class='comment'>// [ 0, -1, -1, -1, -1, 0, 0, -1],</span>
<span class='comment'>// [-1, -1, 0, -1, 0, 0, 0, 0],</span>
<span class='comment'>// [ 0, 0, -1, -1, -1, 0, -1, -1],</span>
<span class='comment'>// [ 0, 0, -1, 0, 0, 0, 0, 0],</span>
<span class='comment'>// [-1, -1, 0, 0, 0, 0, 0, 0],</span>
<span class='comment'>// [ 0, 0, -1, 0, 0, -1, 0, 0],</span>
<span class='comment'>// ];</span>
<span class='comment'>//</span>
<span class='comment'>// S2X = [</span>
<span class='comment'>// [ 0, 0, -1, -1, 0, 0, 0, -1],</span>
<span class='comment'>// [-1, 0, 0, -1, -1, -1, -1, 0],</span>
<span class='comment'>// [-1, 0, -1, 0, 0, 0, 0, 0],</span>
<span class='comment'>// [-1, -1, 0, -1, 0, -1, -1, -1],</span>
<span class='comment'>// [ 0, -1, 0, 0, -1, 0, 0, 0],</span>
<span class='comment'>// [ 0, 0, -1, 0, 0, 0, 0, 0],</span>
<span class='comment'>// [-1, 0, 0, 0, -1, 0, -1, 0],</span>
<span class='comment'>// [-1, -1, 0, 0, -1, 0, -1, 0],</span>
<span class='comment'>// ];</span>
<span class='comment'>//</span>
<span class='comment'>// Looking at the pseudocode implementation, we see that there is no point</span>
<span class='comment'>// in processing any of the elements in those matrices that have zero values</span>
<span class='comment'>// since a logical AND with 0 will produce 0 which will have no effect when it</span>
<span class='comment'>// is XORed into the result.</span>
<span class='comment'>//</span>
<span class='comment'>// LLVM doesn't appear to be able to fully unroll the loops in the pseudocode</span>
<span class='comment'>// above and to eliminate processing of the 0 elements. So, each transformation is</span>
<span class='comment'>// implemented independently directly in fully unrolled form with the 0 elements</span>
<span class='comment'>// removed.</span>
<span class='comment'>//</span>
<span class='comment'>// As an optimization, elements that are XORed together multiple times are</span>
<span class='comment'>// XORed just once and then used multiple times. I wrote a simple program that</span>
<span class='comment'>// greedily looked for terms to combine to create the implementations below.</span>
<span class='comment'>// It is likely that this could be optimized more.</span>
<span class='kw'>fn</span> <span class='ident'>change_basis_a2x</span>(<span class='kw-2'>&</span><span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>t06</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>6</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>0</span>;
<span class='kw'>let</span> <span class='ident'>t056</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>5</span> <span class='op'>^</span> <span class='ident'>t06</span>;
<span class='kw'>let</span> <span class='ident'>t0156</span> <span class='op'>=</span> <span class='ident'>t056</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>1</span>;
<span class='kw'>let</span> <span class='ident'>t13</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>1</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>3</span>;
<span class='kw'>let</span> <span class='ident'>x0</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>2</span> <span class='op'>^</span> <span class='ident'>t06</span> <span class='op'>^</span> <span class='ident'>t13</span>;
<span class='kw'>let</span> <span class='ident'>x1</span> <span class='op'>=</span> <span class='ident'>t056</span>;
<span class='kw'>let</span> <span class='ident'>x2</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>0</span>;
<span class='kw'>let</span> <span class='ident'>x3</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>0</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>4</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>7</span> <span class='op'>^</span> <span class='ident'>t13</span>;
<span class='kw'>let</span> <span class='ident'>x4</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>7</span> <span class='op'>^</span> <span class='ident'>t056</span>;
<span class='kw'>let</span> <span class='ident'>x5</span> <span class='op'>=</span> <span class='ident'>t0156</span>;
<span class='kw'>let</span> <span class='ident'>x6</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>4</span> <span class='op'>^</span> <span class='ident'>t056</span>;
<span class='kw'>let</span> <span class='ident'>x7</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>2</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>7</span> <span class='op'>^</span> <span class='ident'>t0156</span>;
<span class='ident'>Bs8State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>, <span class='ident'>x2</span>, <span class='ident'>x3</span>, <span class='ident'>x4</span>, <span class='ident'>x5</span>, <span class='ident'>x6</span>, <span class='ident'>x7</span>)
}
<span class='kw'>fn</span> <span class='ident'>change_basis_x2s</span>(<span class='kw-2'>&</span><span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>t46</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>4</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>6</span>;
<span class='kw'>let</span> <span class='ident'>t35</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>3</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>5</span>;
<span class='kw'>let</span> <span class='ident'>t06</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>0</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>6</span>;
<span class='kw'>let</span> <span class='ident'>t357</span> <span class='op'>=</span> <span class='ident'>t35</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>7</span>;
<span class='kw'>let</span> <span class='ident'>x0</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>1</span> <span class='op'>^</span> <span class='ident'>t46</span>;
<span class='kw'>let</span> <span class='ident'>x1</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>1</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>4</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>5</span>;
<span class='kw'>let</span> <span class='ident'>x2</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>2</span> <span class='op'>^</span> <span class='ident'>t35</span> <span class='op'>^</span> <span class='ident'>t06</span>;
<span class='kw'>let</span> <span class='ident'>x3</span> <span class='op'>=</span> <span class='ident'>t46</span> <span class='op'>^</span> <span class='ident'>t357</span>;
<span class='kw'>let</span> <span class='ident'>x4</span> <span class='op'>=</span> <span class='ident'>t357</span>;
<span class='kw'>let</span> <span class='ident'>x5</span> <span class='op'>=</span> <span class='ident'>t06</span>;
<span class='kw'>let</span> <span class='ident'>x6</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>3</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>7</span>;
<span class='kw'>let</span> <span class='ident'>x7</span> <span class='op'>=</span> <span class='ident'>t35</span>;
<span class='ident'>Bs8State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>, <span class='ident'>x2</span>, <span class='ident'>x3</span>, <span class='ident'>x4</span>, <span class='ident'>x5</span>, <span class='ident'>x6</span>, <span class='ident'>x7</span>)
}
<span class='kw'>fn</span> <span class='ident'>change_basis_x2a</span>(<span class='kw-2'>&</span><span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>t15</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>1</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>5</span>;
<span class='kw'>let</span> <span class='ident'>t36</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>3</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>6</span>;
<span class='kw'>let</span> <span class='ident'>t1356</span> <span class='op'>=</span> <span class='ident'>t15</span> <span class='op'>^</span> <span class='ident'>t36</span>;
<span class='kw'>let</span> <span class='ident'>t07</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>0</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>7</span>;
<span class='kw'>let</span> <span class='ident'>x0</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>2</span>;
<span class='kw'>let</span> <span class='ident'>x1</span> <span class='op'>=</span> <span class='ident'>t15</span>;
<span class='kw'>let</span> <span class='ident'>x2</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>4</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>7</span> <span class='op'>^</span> <span class='ident'>t15</span>;
<span class='kw'>let</span> <span class='ident'>x3</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>2</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>4</span> <span class='op'>^</span> <span class='ident'>t1356</span>;
<span class='kw'>let</span> <span class='ident'>x4</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>1</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>6</span>;
<span class='kw'>let</span> <span class='ident'>x5</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>2</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>5</span> <span class='op'>^</span> <span class='ident'>t36</span> <span class='op'>^</span> <span class='ident'>t07</span>;
<span class='kw'>let</span> <span class='ident'>x6</span> <span class='op'>=</span> <span class='ident'>t1356</span> <span class='op'>^</span> <span class='ident'>t07</span>;
<span class='kw'>let</span> <span class='ident'>x7</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>1</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>4</span>;
<span class='ident'>Bs8State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>, <span class='ident'>x2</span>, <span class='ident'>x3</span>, <span class='ident'>x4</span>, <span class='ident'>x5</span>, <span class='ident'>x6</span>, <span class='ident'>x7</span>)
}
<span class='kw'>fn</span> <span class='ident'>change_basis_s2x</span>(<span class='kw-2'>&</span><span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>t46</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>4</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>6</span>;
<span class='kw'>let</span> <span class='ident'>t01</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>0</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>1</span>;
<span class='kw'>let</span> <span class='ident'>t0146</span> <span class='op'>=</span> <span class='ident'>t01</span> <span class='op'>^</span> <span class='ident'>t46</span>;
<span class='kw'>let</span> <span class='ident'>x0</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>5</span> <span class='op'>^</span> <span class='ident'>t0146</span>;
<span class='kw'>let</span> <span class='ident'>x1</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>0</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>3</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>4</span>;
<span class='kw'>let</span> <span class='ident'>x2</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>2</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>5</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>7</span>;
<span class='kw'>let</span> <span class='ident'>x3</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>7</span> <span class='op'>^</span> <span class='ident'>t46</span>;
<span class='kw'>let</span> <span class='ident'>x4</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>3</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>6</span> <span class='op'>^</span> <span class='ident'>t01</span>;
<span class='kw'>let</span> <span class='ident'>x5</span> <span class='op'>=</span> <span class='ident'>t46</span>;
<span class='kw'>let</span> <span class='ident'>x6</span> <span class='op'>=</span> <span class='ident'>t0146</span>;
<span class='kw'>let</span> <span class='ident'>x7</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='number'>4</span> <span class='op'>^</span> <span class='self'>self</span>.<span class='number'>7</span>;
<span class='ident'>Bs8State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>, <span class='ident'>x2</span>, <span class='ident'>x3</span>, <span class='ident'>x4</span>, <span class='ident'>x5</span>, <span class='ident'>x6</span>, <span class='ident'>x7</span>)
}
}
<span class='kw'>impl</span> <span class='op'><</span><span class='ident'>T</span>: <span class='ident'>Not</span><span class='op'><</span><span class='ident'>Output</span> <span class='op'>=</span> <span class='ident'>T</span><span class='op'>></span> <span class='op'>+</span> <span class='ident'>Copy</span><span class='op'>></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='comment'>// The special value "x63" is used as part of the sub_bytes and inv_sub_bytes</span>
<span class='comment'>// steps. It is conceptually a Bs8State value where the 0th, 1st, 5th, and 6th</span>
<span class='comment'>// elements are all 1s and the other elements are all 0s. The only thing that</span>
<span class='comment'>// we do with the "x63" value is to XOR a Bs8State with it. We optimize that XOR</span>
<span class='comment'>// below into just inverting 4 of the elements and leaving the other 4 elements</span>
<span class='comment'>// untouched.</span>
<span class='kw'>fn</span> <span class='ident'>xor_x63</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='ident'>Bs8State</span> (
<span class='op'>!</span><span class='self'>self</span>.<span class='number'>0</span>,
<span class='op'>!</span><span class='self'>self</span>.<span class='number'>1</span>,
<span class='self'>self</span>.<span class='number'>2</span>,
<span class='self'>self</span>.<span class='number'>3</span>,
<span class='self'>self</span>.<span class='number'>4</span>,
<span class='op'>!</span><span class='self'>self</span>.<span class='number'>5</span>,
<span class='op'>!</span><span class='self'>self</span>.<span class='number'>6</span>,
<span class='self'>self</span>.<span class='number'>7</span>)
}
}
<span class='attribute'>#[<span class='ident'>derive</span>(<span class='ident'>Clone</span>, <span class='ident'>Copy</span>)]</span>
<span class='kw'>struct</span> <span class='ident'>Bs4State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span>(<span class='ident'>T</span>, <span class='ident'>T</span>, <span class='ident'>T</span>, <span class='ident'>T</span>);
<span class='kw'>impl</span> <span class='op'><</span><span class='ident'>T</span>: <span class='ident'>Copy</span><span class='op'>></span> <span class='ident'>Bs4State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>fn</span> <span class='ident'>split</span>(<span class='self'>self</span>) <span class='op'>-></span> (<span class='ident'>Bs2State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span>, <span class='ident'>Bs2State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span>) {
<span class='kw'>let</span> <span class='ident'>Bs4State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>, <span class='ident'>x2</span>, <span class='ident'>x3</span>) <span class='op'>=</span> <span class='self'>self</span>;
(<span class='ident'>Bs2State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>), <span class='ident'>Bs2State</span>(<span class='ident'>x2</span>, <span class='ident'>x3</span>))
}
<span class='kw'>fn</span> <span class='ident'>join</span>(<span class='self'>self</span>, <span class='ident'>rhs</span>: <span class='ident'>Bs4State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>Bs4State</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span>, <span class='ident'>a2</span>, <span class='ident'>a3</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='kw'>let</span> <span class='ident'>Bs4State</span>(<span class='ident'>b0</span>, <span class='ident'>b1</span>, <span class='ident'>b2</span>, <span class='ident'>b3</span>) <span class='op'>=</span> <span class='ident'>rhs</span>;
<span class='ident'>Bs8State</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span>, <span class='ident'>a2</span>, <span class='ident'>a3</span>, <span class='ident'>b0</span>, <span class='ident'>b1</span>, <span class='ident'>b2</span>, <span class='ident'>b3</span>)
}
}
<span class='kw'>impl</span> <span class='op'><</span><span class='ident'>T</span>: <span class='ident'>BitXor</span><span class='op'><</span><span class='ident'>Output</span> <span class='op'>=</span> <span class='ident'>T</span><span class='op'>></span> <span class='op'>+</span> <span class='ident'>Copy</span><span class='op'>></span> <span class='ident'>Bs4State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>fn</span> <span class='ident'>xor</span>(<span class='self'>self</span>, <span class='ident'>rhs</span>: <span class='ident'>Bs4State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span>) <span class='op'>-></span> <span class='ident'>Bs4State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>Bs4State</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span>, <span class='ident'>a2</span>, <span class='ident'>a3</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='kw'>let</span> <span class='ident'>Bs4State</span>(<span class='ident'>b0</span>, <span class='ident'>b1</span>, <span class='ident'>b2</span>, <span class='ident'>b3</span>) <span class='op'>=</span> <span class='ident'>rhs</span>;
<span class='ident'>Bs4State</span>(<span class='ident'>a0</span> <span class='op'>^</span> <span class='ident'>b0</span>, <span class='ident'>a1</span> <span class='op'>^</span> <span class='ident'>b1</span>, <span class='ident'>a2</span> <span class='op'>^</span> <span class='ident'>b2</span>, <span class='ident'>a3</span> <span class='op'>^</span> <span class='ident'>b3</span>)
}
}
<span class='attribute'>#[<span class='ident'>derive</span>(<span class='ident'>Clone</span>, <span class='ident'>Copy</span>)]</span>
<span class='kw'>struct</span> <span class='ident'>Bs2State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span>(<span class='ident'>T</span>, <span class='ident'>T</span>);
<span class='kw'>impl</span> <span class='op'><</span><span class='ident'>T</span><span class='op'>></span> <span class='ident'>Bs2State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>fn</span> <span class='ident'>split</span>(<span class='self'>self</span>) <span class='op'>-></span> (<span class='ident'>T</span>, <span class='ident'>T</span>) {
<span class='kw'>let</span> <span class='ident'>Bs2State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>) <span class='op'>=</span> <span class='self'>self</span>;
(<span class='ident'>x0</span>, <span class='ident'>x1</span>)
}
<span class='kw'>fn</span> <span class='ident'>join</span>(<span class='self'>self</span>, <span class='ident'>rhs</span>: <span class='ident'>Bs2State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span>) <span class='op'>-></span> <span class='ident'>Bs4State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>Bs2State</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='kw'>let</span> <span class='ident'>Bs2State</span>(<span class='ident'>b0</span>, <span class='ident'>b1</span>) <span class='op'>=</span> <span class='ident'>rhs</span>;
<span class='ident'>Bs4State</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span>, <span class='ident'>b0</span>, <span class='ident'>b1</span>)
}
}
<span class='kw'>impl</span> <span class='op'><</span><span class='ident'>T</span>: <span class='ident'>BitXor</span><span class='op'><</span><span class='ident'>Output</span> <span class='op'>=</span> <span class='ident'>T</span><span class='op'>></span> <span class='op'>+</span> <span class='ident'>Copy</span><span class='op'>></span> <span class='ident'>Bs2State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>fn</span> <span class='ident'>xor</span>(<span class='self'>self</span>, <span class='ident'>rhs</span>: <span class='ident'>Bs2State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span>) <span class='op'>-></span> <span class='ident'>Bs2State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>Bs2State</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='kw'>let</span> <span class='ident'>Bs2State</span>(<span class='ident'>b0</span>, <span class='ident'>b1</span>) <span class='op'>=</span> <span class='ident'>rhs</span>;
<span class='ident'>Bs2State</span>(<span class='ident'>a0</span> <span class='op'>^</span> <span class='ident'>b0</span>, <span class='ident'>a1</span> <span class='op'>^</span> <span class='ident'>b1</span>)
}
}
<span class='comment'>// Bit Slice data in the form of 4 u32s in column-major order</span>
<span class='kw'>fn</span> <span class='ident'>bit_slice_4x4_with_u16</span>(<span class='ident'>a</span>: <span class='ident'>u32</span>, <span class='ident'>b</span>: <span class='ident'>u32</span>, <span class='ident'>c</span>: <span class='ident'>u32</span>, <span class='ident'>d</span>: <span class='ident'>u32</span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>u16</span><span class='op'>></span> {
<span class='kw'>fn</span> <span class='ident'>pb</span>(<span class='ident'>x</span>: <span class='ident'>u32</span>, <span class='ident'>bit</span>: <span class='ident'>u32</span>, <span class='ident'>shift</span>: <span class='ident'>u32</span>) <span class='op'>-></span> <span class='ident'>u16</span> {
(((<span class='ident'>x</span> <span class='op'>>></span> <span class='ident'>bit</span>) <span class='op'>&</span> <span class='number'>1</span>) <span class='kw'>as</span> <span class='ident'>u16</span>) <span class='op'><<</span> <span class='ident'>shift</span>
}
<span class='kw'>fn</span> <span class='ident'>construct</span>(<span class='ident'>a</span>: <span class='ident'>u32</span>, <span class='ident'>b</span>: <span class='ident'>u32</span>, <span class='ident'>c</span>: <span class='ident'>u32</span>, <span class='ident'>d</span>: <span class='ident'>u32</span>, <span class='ident'>bit</span>: <span class='ident'>u32</span>) <span class='op'>-></span> <span class='ident'>u16</span> {
<span class='ident'>pb</span>(<span class='ident'>a</span>, <span class='ident'>bit</span>, <span class='number'>0</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>b</span>, <span class='ident'>bit</span>, <span class='number'>1</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>c</span>, <span class='ident'>bit</span>, <span class='number'>2</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>d</span>, <span class='ident'>bit</span>, <span class='number'>3</span>) <span class='op'>|</span>
<span class='ident'>pb</span>(<span class='ident'>a</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>8</span>, <span class='number'>4</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>b</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>8</span>, <span class='number'>5</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>c</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>8</span>, <span class='number'>6</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>d</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>8</span>, <span class='number'>7</span>) <span class='op'>|</span>
<span class='ident'>pb</span>(<span class='ident'>a</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>16</span>, <span class='number'>8</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>b</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>16</span>, <span class='number'>9</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>c</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>16</span>, <span class='number'>10</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>d</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>16</span>, <span class='number'>11</span>) <span class='op'>|</span>
<span class='ident'>pb</span>(<span class='ident'>a</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>24</span>, <span class='number'>12</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>b</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>24</span>, <span class='number'>13</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>c</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>24</span>, <span class='number'>14</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>d</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>24</span>, <span class='number'>15</span>)
}
<span class='kw'>let</span> <span class='ident'>x0</span> <span class='op'>=</span> <span class='ident'>construct</span>(<span class='ident'>a</span>, <span class='ident'>b</span>, <span class='ident'>c</span>, <span class='ident'>d</span>, <span class='number'>0</span>);
<span class='kw'>let</span> <span class='ident'>x1</span> <span class='op'>=</span> <span class='ident'>construct</span>(<span class='ident'>a</span>, <span class='ident'>b</span>, <span class='ident'>c</span>, <span class='ident'>d</span>, <span class='number'>1</span>);
<span class='kw'>let</span> <span class='ident'>x2</span> <span class='op'>=</span> <span class='ident'>construct</span>(<span class='ident'>a</span>, <span class='ident'>b</span>, <span class='ident'>c</span>, <span class='ident'>d</span>, <span class='number'>2</span>);
<span class='kw'>let</span> <span class='ident'>x3</span> <span class='op'>=</span> <span class='ident'>construct</span>(<span class='ident'>a</span>, <span class='ident'>b</span>, <span class='ident'>c</span>, <span class='ident'>d</span>, <span class='number'>3</span>);
<span class='kw'>let</span> <span class='ident'>x4</span> <span class='op'>=</span> <span class='ident'>construct</span>(<span class='ident'>a</span>, <span class='ident'>b</span>, <span class='ident'>c</span>, <span class='ident'>d</span>, <span class='number'>4</span>);
<span class='kw'>let</span> <span class='ident'>x5</span> <span class='op'>=</span> <span class='ident'>construct</span>(<span class='ident'>a</span>, <span class='ident'>b</span>, <span class='ident'>c</span>, <span class='ident'>d</span>, <span class='number'>5</span>);
<span class='kw'>let</span> <span class='ident'>x6</span> <span class='op'>=</span> <span class='ident'>construct</span>(<span class='ident'>a</span>, <span class='ident'>b</span>, <span class='ident'>c</span>, <span class='ident'>d</span>, <span class='number'>6</span>);
<span class='kw'>let</span> <span class='ident'>x7</span> <span class='op'>=</span> <span class='ident'>construct</span>(<span class='ident'>a</span>, <span class='ident'>b</span>, <span class='ident'>c</span>, <span class='ident'>d</span>, <span class='number'>7</span>);
<span class='ident'>Bs8State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>, <span class='ident'>x2</span>, <span class='ident'>x3</span>, <span class='ident'>x4</span>, <span class='ident'>x5</span>, <span class='ident'>x6</span>, <span class='ident'>x7</span>)
}
<span class='comment'>// Bit slice a single u32 value - this is used to calculate the SubBytes step when creating the</span>
<span class='comment'>// round keys.</span>
<span class='kw'>fn</span> <span class='ident'>bit_slice_4x1_with_u16</span>(<span class='ident'>a</span>: <span class='ident'>u32</span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>u16</span><span class='op'>></span> {
<span class='ident'>bit_slice_4x4_with_u16</span>(<span class='ident'>a</span>, <span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>)
}
<span class='comment'>// Bit slice a 16 byte array in column major order</span>
<span class='kw'>fn</span> <span class='ident'>bit_slice_1x16_with_u16</span>(<span class='ident'>data</span>: <span class='kw-2'>&</span>[<span class='ident'>u8</span>]) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>u16</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>n</span> <span class='op'>=</span> [<span class='number'>0u32</span>; <span class='number'>4</span>];
<span class='ident'>read_u32v_le</span>(<span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>n</span>, <span class='ident'>data</span>);
<span class='kw'>let</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='ident'>n</span>[<span class='number'>0</span>];
<span class='kw'>let</span> <span class='ident'>b</span> <span class='op'>=</span> <span class='ident'>n</span>[<span class='number'>1</span>];
<span class='kw'>let</span> <span class='ident'>c</span> <span class='op'>=</span> <span class='ident'>n</span>[<span class='number'>2</span>];
<span class='kw'>let</span> <span class='ident'>d</span> <span class='op'>=</span> <span class='ident'>n</span>[<span class='number'>3</span>];
<span class='ident'>bit_slice_4x4_with_u16</span>(<span class='ident'>a</span>, <span class='ident'>b</span>, <span class='ident'>c</span>, <span class='ident'>d</span>)
}
<span class='comment'>// Un Bit Slice into a set of 4 u32s</span>
<span class='kw'>fn</span> <span class='ident'>un_bit_slice_4x4_with_u16</span>(<span class='ident'>bs</span>: <span class='kw-2'>&</span><span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>u16</span><span class='op'>></span>) <span class='op'>-></span> (<span class='ident'>u32</span>, <span class='ident'>u32</span>, <span class='ident'>u32</span>, <span class='ident'>u32</span>) {
<span class='kw'>fn</span> <span class='ident'>pb</span>(<span class='ident'>x</span>: <span class='ident'>u16</span>, <span class='ident'>bit</span>: <span class='ident'>u32</span>, <span class='ident'>shift</span>: <span class='ident'>u32</span>) <span class='op'>-></span> <span class='ident'>u32</span> {
(((<span class='ident'>x</span> <span class='op'>>></span> <span class='ident'>bit</span>) <span class='op'>&</span> <span class='number'>1</span>) <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='ident'>shift</span>
}
<span class='kw'>fn</span> <span class='ident'>deconstruct</span>(<span class='ident'>bs</span>: <span class='kw-2'>&</span><span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>u16</span><span class='op'>></span>, <span class='ident'>bit</span>: <span class='ident'>u32</span>) <span class='op'>-></span> <span class='ident'>u32</span> {
<span class='kw'>let</span> <span class='ident'>Bs8State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>, <span class='ident'>x2</span>, <span class='ident'>x3</span>, <span class='ident'>x4</span>, <span class='ident'>x5</span>, <span class='ident'>x6</span>, <span class='ident'>x7</span>) <span class='op'>=</span> <span class='kw-2'>*</span><span class='ident'>bs</span>;
<span class='ident'>pb</span>(<span class='ident'>x0</span>, <span class='ident'>bit</span>, <span class='number'>0</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x1</span>, <span class='ident'>bit</span>, <span class='number'>1</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x2</span>, <span class='ident'>bit</span>, <span class='number'>2</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x3</span>, <span class='ident'>bit</span>, <span class='number'>3</span>) <span class='op'>|</span>
<span class='ident'>pb</span>(<span class='ident'>x4</span>, <span class='ident'>bit</span>, <span class='number'>4</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x5</span>, <span class='ident'>bit</span>, <span class='number'>5</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x6</span>, <span class='ident'>bit</span>, <span class='number'>6</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x7</span>, <span class='ident'>bit</span>, <span class='number'>7</span>) <span class='op'>|</span>
<span class='ident'>pb</span>(<span class='ident'>x0</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>4</span>, <span class='number'>8</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x1</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>4</span>, <span class='number'>9</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x2</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>4</span>, <span class='number'>10</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x3</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>4</span>, <span class='number'>11</span>) <span class='op'>|</span>
<span class='ident'>pb</span>(<span class='ident'>x4</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>4</span>, <span class='number'>12</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x5</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>4</span>, <span class='number'>13</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x6</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>4</span>, <span class='number'>14</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x7</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>4</span>, <span class='number'>15</span>) <span class='op'>|</span>
<span class='ident'>pb</span>(<span class='ident'>x0</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>8</span>, <span class='number'>16</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x1</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>8</span>, <span class='number'>17</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x2</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>8</span>, <span class='number'>18</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x3</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>8</span>, <span class='number'>19</span>) <span class='op'>|</span>
<span class='ident'>pb</span>(<span class='ident'>x4</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>8</span>, <span class='number'>20</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x5</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>8</span>, <span class='number'>21</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x6</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>8</span>, <span class='number'>22</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x7</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>8</span>, <span class='number'>23</span>) <span class='op'>|</span>
<span class='ident'>pb</span>(<span class='ident'>x0</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>12</span>, <span class='number'>24</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x1</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>12</span>, <span class='number'>25</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x2</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>12</span>, <span class='number'>26</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x3</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>12</span>, <span class='number'>27</span>) <span class='op'>|</span>
<span class='ident'>pb</span>(<span class='ident'>x4</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>12</span>, <span class='number'>28</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x5</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>12</span>, <span class='number'>29</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x6</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>12</span>, <span class='number'>30</span>) <span class='op'>|</span> <span class='ident'>pb</span>(<span class='ident'>x7</span>, <span class='ident'>bit</span> <span class='op'>+</span> <span class='number'>12</span>, <span class='number'>31</span>)
}
<span class='kw'>let</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='ident'>deconstruct</span>(<span class='ident'>bs</span>, <span class='number'>0</span>);
<span class='kw'>let</span> <span class='ident'>b</span> <span class='op'>=</span> <span class='ident'>deconstruct</span>(<span class='ident'>bs</span>, <span class='number'>1</span>);
<span class='kw'>let</span> <span class='ident'>c</span> <span class='op'>=</span> <span class='ident'>deconstruct</span>(<span class='ident'>bs</span>, <span class='number'>2</span>);
<span class='kw'>let</span> <span class='ident'>d</span> <span class='op'>=</span> <span class='ident'>deconstruct</span>(<span class='ident'>bs</span>, <span class='number'>3</span>);
(<span class='ident'>a</span>, <span class='ident'>b</span>, <span class='ident'>c</span>, <span class='ident'>d</span>)
}
<span class='comment'>// Un Bit Slice into a single u32. This is used when creating the round keys.</span>
<span class='kw'>fn</span> <span class='ident'>un_bit_slice_4x1_with_u16</span>(<span class='ident'>bs</span>: <span class='kw-2'>&</span><span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>u16</span><span class='op'>></span>) <span class='op'>-></span> <span class='ident'>u32</span> {
<span class='kw'>let</span> (<span class='ident'>a</span>, _, _, _) <span class='op'>=</span> <span class='ident'>un_bit_slice_4x4_with_u16</span>(<span class='ident'>bs</span>);
<span class='ident'>a</span>
}
<span class='comment'>// Un Bit Slice into a 16 byte array</span>
<span class='kw'>fn</span> <span class='ident'>un_bit_slice_1x16_with_u16</span>(<span class='ident'>bs</span>: <span class='kw-2'>&</span><span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>u16</span><span class='op'>></span>, <span class='ident'>output</span>: <span class='kw-2'>&</span><span class='kw-2'>mut</span> [<span class='ident'>u8</span>]) {
<span class='kw'>let</span> (<span class='ident'>a</span>, <span class='ident'>b</span>, <span class='ident'>c</span>, <span class='ident'>d</span>) <span class='op'>=</span> <span class='ident'>un_bit_slice_4x4_with_u16</span>(<span class='ident'>bs</span>);
<span class='ident'>write_u32_le</span>(<span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>output</span>[<span class='number'>0</span>..<span class='number'>4</span>], <span class='ident'>a</span>);
<span class='ident'>write_u32_le</span>(<span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>output</span>[<span class='number'>4</span>..<span class='number'>8</span>], <span class='ident'>b</span>);
<span class='ident'>write_u32_le</span>(<span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>output</span>[<span class='number'>8</span>..<span class='number'>12</span>], <span class='ident'>c</span>);
<span class='ident'>write_u32_le</span>(<span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>output</span>[<span class='number'>12</span>..<span class='number'>16</span>], <span class='ident'>d</span>);
}
<span class='comment'>// Bit Slice a 128 byte array of eight 16 byte blocks. Each block is in column major order.</span>
<span class='kw'>fn</span> <span class='ident'>bit_slice_1x128_with_u32x4</span>(<span class='ident'>data</span>: <span class='kw-2'>&</span>[<span class='ident'>u8</span>]) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>u32x4</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>bit0</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x01010101</span>, <span class='number'>0x01010101</span>, <span class='number'>0x01010101</span>, <span class='number'>0x01010101</span>);
<span class='kw'>let</span> <span class='ident'>bit1</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x02020202</span>, <span class='number'>0x02020202</span>, <span class='number'>0x02020202</span>, <span class='number'>0x02020202</span>);
<span class='kw'>let</span> <span class='ident'>bit2</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x04040404</span>, <span class='number'>0x04040404</span>, <span class='number'>0x04040404</span>, <span class='number'>0x04040404</span>);
<span class='kw'>let</span> <span class='ident'>bit3</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x08080808</span>, <span class='number'>0x08080808</span>, <span class='number'>0x08080808</span>, <span class='number'>0x08080808</span>);
<span class='kw'>let</span> <span class='ident'>bit4</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x10101010</span>, <span class='number'>0x10101010</span>, <span class='number'>0x10101010</span>, <span class='number'>0x10101010</span>);
<span class='kw'>let</span> <span class='ident'>bit5</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x20202020</span>, <span class='number'>0x20202020</span>, <span class='number'>0x20202020</span>, <span class='number'>0x20202020</span>);
<span class='kw'>let</span> <span class='ident'>bit6</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x40404040</span>, <span class='number'>0x40404040</span>, <span class='number'>0x40404040</span>, <span class='number'>0x40404040</span>);
<span class='kw'>let</span> <span class='ident'>bit7</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x80808080</span>, <span class='number'>0x80808080</span>, <span class='number'>0x80808080</span>, <span class='number'>0x80808080</span>);
<span class='kw'>fn</span> <span class='ident'>read_row_major</span>(<span class='ident'>data</span>: <span class='kw-2'>&</span>[<span class='ident'>u8</span>]) <span class='op'>-></span> <span class='ident'>u32x4</span> {
<span class='ident'>u32x4</span>(
(<span class='ident'>data</span>[<span class='number'>0</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'>|</span>
((<span class='ident'>data</span>[<span class='number'>4</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='number'>8</span>) <span class='op'>|</span>
((<span class='ident'>data</span>[<span class='number'>8</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='number'>16</span>) <span class='op'>|</span>
((<span class='ident'>data</span>[<span class='number'>12</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='number'>24</span>),
(<span class='ident'>data</span>[<span class='number'>1</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'>|</span>
((<span class='ident'>data</span>[<span class='number'>5</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='number'>8</span>) <span class='op'>|</span>
((<span class='ident'>data</span>[<span class='number'>9</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='number'>16</span>) <span class='op'>|</span>
((<span class='ident'>data</span>[<span class='number'>13</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='number'>24</span>),
(<span class='ident'>data</span>[<span class='number'>2</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'>|</span>
((<span class='ident'>data</span>[<span class='number'>6</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='number'>8</span>) <span class='op'>|</span>
((<span class='ident'>data</span>[<span class='number'>10</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='number'>16</span>) <span class='op'>|</span>
((<span class='ident'>data</span>[<span class='number'>14</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='number'>24</span>),
(<span class='ident'>data</span>[<span class='number'>3</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'>|</span>
((<span class='ident'>data</span>[<span class='number'>7</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='number'>8</span>) <span class='op'>|</span>
((<span class='ident'>data</span>[<span class='number'>11</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='number'>16</span>) <span class='op'>|</span>
((<span class='ident'>data</span>[<span class='number'>15</span>] <span class='kw'>as</span> <span class='ident'>u32</span>) <span class='op'><<</span> <span class='number'>24</span>))
}
<span class='kw'>let</span> <span class='ident'>t0</span> <span class='op'>=</span> <span class='ident'>read_row_major</span>(<span class='kw-2'>&</span><span class='ident'>data</span>[<span class='number'>0</span>..<span class='number'>16</span>]);
<span class='kw'>let</span> <span class='ident'>t1</span> <span class='op'>=</span> <span class='ident'>read_row_major</span>(<span class='kw-2'>&</span><span class='ident'>data</span>[<span class='number'>16</span>..<span class='number'>32</span>]);
<span class='kw'>let</span> <span class='ident'>t2</span> <span class='op'>=</span> <span class='ident'>read_row_major</span>(<span class='kw-2'>&</span><span class='ident'>data</span>[<span class='number'>32</span>..<span class='number'>48</span>]);
<span class='kw'>let</span> <span class='ident'>t3</span> <span class='op'>=</span> <span class='ident'>read_row_major</span>(<span class='kw-2'>&</span><span class='ident'>data</span>[<span class='number'>48</span>..<span class='number'>64</span>]);
<span class='kw'>let</span> <span class='ident'>t4</span> <span class='op'>=</span> <span class='ident'>read_row_major</span>(<span class='kw-2'>&</span><span class='ident'>data</span>[<span class='number'>64</span>..<span class='number'>80</span>]);
<span class='kw'>let</span> <span class='ident'>t5</span> <span class='op'>=</span> <span class='ident'>read_row_major</span>(<span class='kw-2'>&</span><span class='ident'>data</span>[<span class='number'>80</span>..<span class='number'>96</span>]);
<span class='kw'>let</span> <span class='ident'>t6</span> <span class='op'>=</span> <span class='ident'>read_row_major</span>(<span class='kw-2'>&</span><span class='ident'>data</span>[<span class='number'>96</span>..<span class='number'>112</span>]);
<span class='kw'>let</span> <span class='ident'>t7</span> <span class='op'>=</span> <span class='ident'>read_row_major</span>(<span class='kw-2'>&</span><span class='ident'>data</span>[<span class='number'>112</span>..<span class='number'>128</span>]);
<span class='kw'>let</span> <span class='ident'>x0</span> <span class='op'>=</span> (<span class='ident'>t0</span> <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span>.<span class='ident'>lsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span>.<span class='ident'>lsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span>.<span class='ident'>lsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span>.<span class='ident'>lsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span>.<span class='ident'>lsh</span>(<span class='number'>5</span>) <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span>.<span class='ident'>lsh</span>(<span class='number'>6</span>) <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span>.<span class='ident'>lsh</span>(<span class='number'>7</span>) <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='kw'>let</span> <span class='ident'>x1</span> <span class='op'>=</span> (<span class='ident'>t0</span>.<span class='ident'>rsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span> <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span>.<span class='ident'>lsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span>.<span class='ident'>lsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span>.<span class='ident'>lsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span>.<span class='ident'>lsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span>.<span class='ident'>lsh</span>(<span class='number'>5</span>) <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span>.<span class='ident'>lsh</span>(<span class='number'>6</span>) <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='kw'>let</span> <span class='ident'>x2</span> <span class='op'>=</span> (<span class='ident'>t0</span>.<span class='ident'>rsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span>.<span class='ident'>rsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span> <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span>.<span class='ident'>lsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span>.<span class='ident'>lsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span>.<span class='ident'>lsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span>.<span class='ident'>lsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span>.<span class='ident'>lsh</span>(<span class='number'>5</span>) <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='kw'>let</span> <span class='ident'>x3</span> <span class='op'>=</span> (<span class='ident'>t0</span>.<span class='ident'>rsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span>.<span class='ident'>rsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span>.<span class='ident'>rsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span> <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span>.<span class='ident'>lsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span>.<span class='ident'>lsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span>.<span class='ident'>lsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span>.<span class='ident'>lsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='kw'>let</span> <span class='ident'>x4</span> <span class='op'>=</span> (<span class='ident'>t0</span>.<span class='ident'>rsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span>.<span class='ident'>rsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span>.<span class='ident'>rsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span>.<span class='ident'>rsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span> <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span>.<span class='ident'>lsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span>.<span class='ident'>lsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span>.<span class='ident'>lsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='kw'>let</span> <span class='ident'>x5</span> <span class='op'>=</span> (<span class='ident'>t0</span>.<span class='ident'>rsh</span>(<span class='number'>5</span>) <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span>.<span class='ident'>rsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span>.<span class='ident'>rsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span>.<span class='ident'>rsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span>.<span class='ident'>rsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span> <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span>.<span class='ident'>lsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span>.<span class='ident'>lsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='kw'>let</span> <span class='ident'>x6</span> <span class='op'>=</span> (<span class='ident'>t0</span>.<span class='ident'>rsh</span>(<span class='number'>6</span>) <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span>.<span class='ident'>rsh</span>(<span class='number'>5</span>) <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span>.<span class='ident'>rsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span>.<span class='ident'>rsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span>.<span class='ident'>rsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span>.<span class='ident'>rsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span> <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span>.<span class='ident'>lsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='kw'>let</span> <span class='ident'>x7</span> <span class='op'>=</span> (<span class='ident'>t0</span>.<span class='ident'>rsh</span>(<span class='number'>7</span>) <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span>.<span class='ident'>rsh</span>(<span class='number'>6</span>) <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span>.<span class='ident'>rsh</span>(<span class='number'>5</span>) <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span>.<span class='ident'>rsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span>.<span class='ident'>rsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span>.<span class='ident'>rsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span>.<span class='ident'>rsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span> <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='ident'>Bs8State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>, <span class='ident'>x2</span>, <span class='ident'>x3</span>, <span class='ident'>x4</span>, <span class='ident'>x5</span>, <span class='ident'>x6</span>, <span class='ident'>x7</span>)
}
<span class='comment'>// Bit slice a set of 4 u32s by filling a full 128 byte data block with those repeated values. This</span>
<span class='comment'>// is used as part of bit slicing the round keys.</span>
<span class='kw'>fn</span> <span class='ident'>bit_slice_fill_4x4_with_u32x4</span>(<span class='ident'>a</span>: <span class='ident'>u32</span>, <span class='ident'>b</span>: <span class='ident'>u32</span>, <span class='ident'>c</span>: <span class='ident'>u32</span>, <span class='ident'>d</span>: <span class='ident'>u32</span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>u32x4</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>tmp</span> <span class='op'>=</span> [<span class='number'>0u8</span>; <span class='number'>128</span>];
<span class='kw'>for</span> <span class='ident'>i</span> <span class='kw'>in</span> <span class='number'>0</span>..<span class='number'>8</span> {
<span class='ident'>write_u32_le</span>(<span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>tmp</span>[<span class='ident'>i</span> <span class='op'>*</span> <span class='number'>16</span>..<span class='ident'>i</span> <span class='op'>*</span> <span class='number'>16</span> <span class='op'>+</span> <span class='number'>4</span>], <span class='ident'>a</span>);
<span class='ident'>write_u32_le</span>(<span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>tmp</span>[<span class='ident'>i</span> <span class='op'>*</span> <span class='number'>16</span> <span class='op'>+</span> <span class='number'>4</span>..<span class='ident'>i</span> <span class='op'>*</span> <span class='number'>16</span> <span class='op'>+</span> <span class='number'>8</span>], <span class='ident'>b</span>);
<span class='ident'>write_u32_le</span>(<span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>tmp</span>[<span class='ident'>i</span> <span class='op'>*</span> <span class='number'>16</span> <span class='op'>+</span> <span class='number'>8</span>..<span class='ident'>i</span> <span class='op'>*</span> <span class='number'>16</span> <span class='op'>+</span> <span class='number'>12</span>], <span class='ident'>c</span>);
<span class='ident'>write_u32_le</span>(<span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>tmp</span>[<span class='ident'>i</span> <span class='op'>*</span> <span class='number'>16</span> <span class='op'>+</span> <span class='number'>12</span>..<span class='ident'>i</span> <span class='op'>*</span> <span class='number'>16</span> <span class='op'>+</span> <span class='number'>16</span>], <span class='ident'>d</span>);
}
<span class='ident'>bit_slice_1x128_with_u32x4</span>(<span class='kw-2'>&</span><span class='ident'>tmp</span>)
}
<span class='comment'>// Un bit slice into a 128 byte buffer.</span>
<span class='kw'>fn</span> <span class='ident'>un_bit_slice_1x128_with_u32x4</span>(<span class='ident'>bs</span>: <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>u32x4</span><span class='op'>></span>, <span class='ident'>output</span>: <span class='kw-2'>&</span><span class='kw-2'>mut</span> [<span class='ident'>u8</span>]) {
<span class='kw'>let</span> <span class='ident'>Bs8State</span>(<span class='ident'>t0</span>, <span class='ident'>t1</span>, <span class='ident'>t2</span>, <span class='ident'>t3</span>, <span class='ident'>t4</span>, <span class='ident'>t5</span>, <span class='ident'>t6</span>, <span class='ident'>t7</span>) <span class='op'>=</span> <span class='ident'>bs</span>;
<span class='kw'>let</span> <span class='ident'>bit0</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x01010101</span>, <span class='number'>0x01010101</span>, <span class='number'>0x01010101</span>, <span class='number'>0x01010101</span>);
<span class='kw'>let</span> <span class='ident'>bit1</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x02020202</span>, <span class='number'>0x02020202</span>, <span class='number'>0x02020202</span>, <span class='number'>0x02020202</span>);
<span class='kw'>let</span> <span class='ident'>bit2</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x04040404</span>, <span class='number'>0x04040404</span>, <span class='number'>0x04040404</span>, <span class='number'>0x04040404</span>);
<span class='kw'>let</span> <span class='ident'>bit3</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x08080808</span>, <span class='number'>0x08080808</span>, <span class='number'>0x08080808</span>, <span class='number'>0x08080808</span>);
<span class='kw'>let</span> <span class='ident'>bit4</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x10101010</span>, <span class='number'>0x10101010</span>, <span class='number'>0x10101010</span>, <span class='number'>0x10101010</span>);
<span class='kw'>let</span> <span class='ident'>bit5</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x20202020</span>, <span class='number'>0x20202020</span>, <span class='number'>0x20202020</span>, <span class='number'>0x20202020</span>);
<span class='kw'>let</span> <span class='ident'>bit6</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x40404040</span>, <span class='number'>0x40404040</span>, <span class='number'>0x40404040</span>, <span class='number'>0x40404040</span>);
<span class='kw'>let</span> <span class='ident'>bit7</span> <span class='op'>=</span> <span class='ident'>u32x4</span>(<span class='number'>0x80808080</span>, <span class='number'>0x80808080</span>, <span class='number'>0x80808080</span>, <span class='number'>0x80808080</span>);
<span class='comment'>// decode the individual blocks, in row-major order</span>
<span class='comment'>// TODO: this is identical to the same block in bit_slice_1x128_with_u32x4</span>
<span class='kw'>let</span> <span class='ident'>x0</span> <span class='op'>=</span> (<span class='ident'>t0</span> <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span>.<span class='ident'>lsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span>.<span class='ident'>lsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span>.<span class='ident'>lsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span>.<span class='ident'>lsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span>.<span class='ident'>lsh</span>(<span class='number'>5</span>) <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span>.<span class='ident'>lsh</span>(<span class='number'>6</span>) <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span>.<span class='ident'>lsh</span>(<span class='number'>7</span>) <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='kw'>let</span> <span class='ident'>x1</span> <span class='op'>=</span> (<span class='ident'>t0</span>.<span class='ident'>rsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span> <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span>.<span class='ident'>lsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span>.<span class='ident'>lsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span>.<span class='ident'>lsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span>.<span class='ident'>lsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span>.<span class='ident'>lsh</span>(<span class='number'>5</span>) <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span>.<span class='ident'>lsh</span>(<span class='number'>6</span>) <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='kw'>let</span> <span class='ident'>x2</span> <span class='op'>=</span> (<span class='ident'>t0</span>.<span class='ident'>rsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span>.<span class='ident'>rsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span> <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span>.<span class='ident'>lsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span>.<span class='ident'>lsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span>.<span class='ident'>lsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span>.<span class='ident'>lsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span>.<span class='ident'>lsh</span>(<span class='number'>5</span>) <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='kw'>let</span> <span class='ident'>x3</span> <span class='op'>=</span> (<span class='ident'>t0</span>.<span class='ident'>rsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span>.<span class='ident'>rsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span>.<span class='ident'>rsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span> <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span>.<span class='ident'>lsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span>.<span class='ident'>lsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span>.<span class='ident'>lsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span>.<span class='ident'>lsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='kw'>let</span> <span class='ident'>x4</span> <span class='op'>=</span> (<span class='ident'>t0</span>.<span class='ident'>rsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span>.<span class='ident'>rsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span>.<span class='ident'>rsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span>.<span class='ident'>rsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span> <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span>.<span class='ident'>lsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span>.<span class='ident'>lsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span>.<span class='ident'>lsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='kw'>let</span> <span class='ident'>x5</span> <span class='op'>=</span> (<span class='ident'>t0</span>.<span class='ident'>rsh</span>(<span class='number'>5</span>) <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span>.<span class='ident'>rsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span>.<span class='ident'>rsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span>.<span class='ident'>rsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span>.<span class='ident'>rsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span> <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span>.<span class='ident'>lsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span>.<span class='ident'>lsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='kw'>let</span> <span class='ident'>x6</span> <span class='op'>=</span> (<span class='ident'>t0</span>.<span class='ident'>rsh</span>(<span class='number'>6</span>) <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span>.<span class='ident'>rsh</span>(<span class='number'>5</span>) <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span>.<span class='ident'>rsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span>.<span class='ident'>rsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span>.<span class='ident'>rsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span>.<span class='ident'>rsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span> <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span>.<span class='ident'>lsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='kw'>let</span> <span class='ident'>x7</span> <span class='op'>=</span> (<span class='ident'>t0</span>.<span class='ident'>rsh</span>(<span class='number'>7</span>) <span class='op'>&</span> <span class='ident'>bit0</span>) <span class='op'>|</span> (<span class='ident'>t1</span>.<span class='ident'>rsh</span>(<span class='number'>6</span>) <span class='op'>&</span> <span class='ident'>bit1</span>) <span class='op'>|</span> (<span class='ident'>t2</span>.<span class='ident'>rsh</span>(<span class='number'>5</span>) <span class='op'>&</span> <span class='ident'>bit2</span>) <span class='op'>|</span> (<span class='ident'>t3</span>.<span class='ident'>rsh</span>(<span class='number'>4</span>) <span class='op'>&</span> <span class='ident'>bit3</span>) <span class='op'>|</span>
(<span class='ident'>t4</span>.<span class='ident'>rsh</span>(<span class='number'>3</span>) <span class='op'>&</span> <span class='ident'>bit4</span>) <span class='op'>|</span> (<span class='ident'>t5</span>.<span class='ident'>rsh</span>(<span class='number'>2</span>) <span class='op'>&</span> <span class='ident'>bit5</span>) <span class='op'>|</span> (<span class='ident'>t6</span>.<span class='ident'>rsh</span>(<span class='number'>1</span>) <span class='op'>&</span> <span class='ident'>bit6</span>) <span class='op'>|</span> (<span class='ident'>t7</span> <span class='op'>&</span> <span class='ident'>bit7</span>);
<span class='kw'>fn</span> <span class='ident'>write_row_major</span>(<span class='ident'>block</span>: <span class='ident'>u32x4</span>, <span class='ident'>output</span>: <span class='kw-2'>&</span><span class='kw-2'>mut</span> [<span class='ident'>u8</span>]) {
<span class='kw'>let</span> <span class='ident'>u32x4</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span>, <span class='ident'>a2</span>, <span class='ident'>a3</span>) <span class='op'>=</span> <span class='ident'>block</span>;
<span class='ident'>output</span>[<span class='number'>0</span>] <span class='op'>=</span> <span class='ident'>a0</span> <span class='kw'>as</span> <span class='ident'>u8</span>;
<span class='ident'>output</span>[<span class='number'>1</span>] <span class='op'>=</span> <span class='ident'>a1</span> <span class='kw'>as</span> <span class='ident'>u8</span>;
<span class='ident'>output</span>[<span class='number'>2</span>] <span class='op'>=</span> <span class='ident'>a2</span> <span class='kw'>as</span> <span class='ident'>u8</span>;
<span class='ident'>output</span>[<span class='number'>3</span>] <span class='op'>=</span> <span class='ident'>a3</span> <span class='kw'>as</span> <span class='ident'>u8</span>;
<span class='ident'>output</span>[<span class='number'>4</span>] <span class='op'>=</span> (<span class='ident'>a0</span> <span class='op'>>></span> <span class='number'>8</span>) <span class='kw'>as</span> <span class='ident'>u8</span>;
<span class='ident'>output</span>[<span class='number'>5</span>] <span class='op'>=</span> (<span class='ident'>a1</span> <span class='op'>>></span> <span class='number'>8</span>) <span class='kw'>as</span> <span class='ident'>u8</span>;
<span class='ident'>output</span>[<span class='number'>6</span>] <span class='op'>=</span> (<span class='ident'>a2</span> <span class='op'>>></span> <span class='number'>8</span>) <span class='kw'>as</span> <span class='ident'>u8</span>;
<span class='ident'>output</span>[<span class='number'>7</span>] <span class='op'>=</span> (<span class='ident'>a3</span> <span class='op'>>></span> <span class='number'>8</span>) <span class='kw'>as</span> <span class='ident'>u8</span>;
<span class='ident'>output</span>[<span class='number'>8</span>] <span class='op'>=</span> (<span class='ident'>a0</span> <span class='op'>>></span> <span class='number'>16</span>) <span class='kw'>as</span> <span class='ident'>u8</span>;
<span class='ident'>output</span>[<span class='number'>9</span>] <span class='op'>=</span> (<span class='ident'>a1</span> <span class='op'>>></span> <span class='number'>16</span>) <span class='kw'>as</span> <span class='ident'>u8</span>;
<span class='ident'>output</span>[<span class='number'>10</span>] <span class='op'>=</span> (<span class='ident'>a2</span> <span class='op'>>></span> <span class='number'>16</span>) <span class='kw'>as</span> <span class='ident'>u8</span>;
<span class='ident'>output</span>[<span class='number'>11</span>] <span class='op'>=</span> (<span class='ident'>a3</span> <span class='op'>>></span> <span class='number'>16</span>) <span class='kw'>as</span> <span class='ident'>u8</span>;
<span class='ident'>output</span>[<span class='number'>12</span>] <span class='op'>=</span> (<span class='ident'>a0</span> <span class='op'>>></span> <span class='number'>24</span>) <span class='kw'>as</span> <span class='ident'>u8</span>;
<span class='ident'>output</span>[<span class='number'>13</span>] <span class='op'>=</span> (<span class='ident'>a1</span> <span class='op'>>></span> <span class='number'>24</span>) <span class='kw'>as</span> <span class='ident'>u8</span>;
<span class='ident'>output</span>[<span class='number'>14</span>] <span class='op'>=</span> (<span class='ident'>a2</span> <span class='op'>>></span> <span class='number'>24</span>) <span class='kw'>as</span> <span class='ident'>u8</span>;
<span class='ident'>output</span>[<span class='number'>15</span>] <span class='op'>=</span> (<span class='ident'>a3</span> <span class='op'>>></span> <span class='number'>24</span>) <span class='kw'>as</span> <span class='ident'>u8</span>;
}
<span class='ident'>write_row_major</span>(<span class='ident'>x0</span>, <span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>output</span>[<span class='number'>0</span>..<span class='number'>16</span>]);
<span class='ident'>write_row_major</span>(<span class='ident'>x1</span>, <span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>output</span>[<span class='number'>16</span>..<span class='number'>32</span>]);
<span class='ident'>write_row_major</span>(<span class='ident'>x2</span>, <span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>output</span>[<span class='number'>32</span>..<span class='number'>48</span>]);
<span class='ident'>write_row_major</span>(<span class='ident'>x3</span>, <span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>output</span>[<span class='number'>48</span>..<span class='number'>64</span>]);
<span class='ident'>write_row_major</span>(<span class='ident'>x4</span>, <span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>output</span>[<span class='number'>64</span>..<span class='number'>80</span>]);
<span class='ident'>write_row_major</span>(<span class='ident'>x5</span>, <span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>output</span>[<span class='number'>80</span>..<span class='number'>96</span>]);
<span class='ident'>write_row_major</span>(<span class='ident'>x6</span>, <span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>output</span>[<span class='number'>96</span>..<span class='number'>112</span>]);
<span class='ident'>write_row_major</span>(<span class='ident'>x7</span>, <span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>output</span>[<span class='number'>112</span>..<span class='number'>128</span>])
}
<span class='comment'>// The Gf2Ops, Gf4Ops, and Gf8Ops traits specify the functions needed to calculate the AES S-Box</span>
<span class='comment'>// values. This particuar implementation of those S-Box values is taken from [7], so that is where</span>
<span class='comment'>// to look for details on how all that all works. This includes the transformations matrices defined</span>
<span class='comment'>// below for the change_basis operation on the u32 and u32x4 types.</span>
<span class='comment'>// Operations in GF(2^2) using normal basis (Omega^2,Omega)</span>
<span class='kw'>trait</span> <span class='ident'>Gf2Ops</span> {
<span class='comment'>// multiply</span>
<span class='kw'>fn</span> <span class='ident'>mul</span>(<span class='self'>self</span>, <span class='ident'>y</span>: <span class='self'>Self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='comment'>// scale by N = Omega^2</span>
<span class='kw'>fn</span> <span class='ident'>scl_n</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='comment'>// scale by N^2 = Omega</span>
<span class='kw'>fn</span> <span class='ident'>scl_n2</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='comment'>// square</span>
<span class='kw'>fn</span> <span class='ident'>sq</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='comment'>// Same as sqaure</span>
<span class='kw'>fn</span> <span class='ident'>inv</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
}
<span class='kw'>impl</span> <span class='op'><</span><span class='ident'>T</span>: <span class='ident'>BitXor</span><span class='op'><</span><span class='ident'>Output</span> <span class='op'>=</span> <span class='ident'>T</span><span class='op'>></span> <span class='op'>+</span> <span class='ident'>BitAnd</span><span class='op'><</span><span class='ident'>Output</span> <span class='op'>=</span> <span class='ident'>T</span><span class='op'>></span> <span class='op'>+</span> <span class='ident'>Copy</span><span class='op'>></span> <span class='ident'>Gf2Ops</span> <span class='kw'>for</span> <span class='ident'>Bs2State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>fn</span> <span class='ident'>mul</span>(<span class='self'>self</span>, <span class='ident'>y</span>: <span class='ident'>Bs2State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span>) <span class='op'>-></span> <span class='ident'>Bs2State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> (<span class='ident'>b</span>, <span class='ident'>a</span>) <span class='op'>=</span> <span class='self'>self</span>.<span class='ident'>split</span>();
<span class='kw'>let</span> (<span class='ident'>d</span>, <span class='ident'>c</span>) <span class='op'>=</span> <span class='ident'>y</span>.<span class='ident'>split</span>();
<span class='kw'>let</span> <span class='ident'>e</span> <span class='op'>=</span> (<span class='ident'>a</span> <span class='op'>^</span> <span class='ident'>b</span>) <span class='op'>&</span> (<span class='ident'>c</span> <span class='op'>^</span> <span class='ident'>d</span>);
<span class='kw'>let</span> <span class='ident'>p</span> <span class='op'>=</span> (<span class='ident'>a</span> <span class='op'>&</span> <span class='ident'>c</span>) <span class='op'>^</span> <span class='ident'>e</span>;
<span class='kw'>let</span> <span class='ident'>q</span> <span class='op'>=</span> (<span class='ident'>b</span> <span class='op'>&</span> <span class='ident'>d</span>) <span class='op'>^</span> <span class='ident'>e</span>;
<span class='ident'>Bs2State</span>(<span class='ident'>q</span>, <span class='ident'>p</span>)
}
<span class='kw'>fn</span> <span class='ident'>scl_n</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs2State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> (<span class='ident'>b</span>, <span class='ident'>a</span>) <span class='op'>=</span> <span class='self'>self</span>.<span class='ident'>split</span>();
<span class='kw'>let</span> <span class='ident'>q</span> <span class='op'>=</span> <span class='ident'>a</span> <span class='op'>^</span> <span class='ident'>b</span>;
<span class='ident'>Bs2State</span>(<span class='ident'>q</span>, <span class='ident'>b</span>)
}
<span class='kw'>fn</span> <span class='ident'>scl_n2</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs2State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> (<span class='ident'>b</span>, <span class='ident'>a</span>) <span class='op'>=</span> <span class='self'>self</span>.<span class='ident'>split</span>();
<span class='kw'>let</span> <span class='ident'>p</span> <span class='op'>=</span> <span class='ident'>a</span> <span class='op'>^</span> <span class='ident'>b</span>;
<span class='kw'>let</span> <span class='ident'>q</span> <span class='op'>=</span> <span class='ident'>a</span>;
<span class='ident'>Bs2State</span>(<span class='ident'>q</span>, <span class='ident'>p</span>)
}
<span class='kw'>fn</span> <span class='ident'>sq</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs2State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> (<span class='ident'>b</span>, <span class='ident'>a</span>) <span class='op'>=</span> <span class='self'>self</span>.<span class='ident'>split</span>();
<span class='ident'>Bs2State</span>(<span class='ident'>a</span>, <span class='ident'>b</span>)
}
<span class='kw'>fn</span> <span class='ident'>inv</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs2State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='self'>self</span>.<span class='ident'>sq</span>()
}
}
<span class='comment'>// Operations in GF(2^4) using normal basis (alpha^8,alpha^2)</span>
<span class='kw'>trait</span> <span class='ident'>Gf4Ops</span> {
<span class='comment'>// multiply</span>
<span class='kw'>fn</span> <span class='ident'>mul</span>(<span class='self'>self</span>, <span class='ident'>y</span>: <span class='self'>Self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='comment'>// square & scale by nu</span>
<span class='comment'>// nu = beta^8 = N^2*alpha^2, N = w^2</span>
<span class='kw'>fn</span> <span class='ident'>sq_scl</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='comment'>// inverse</span>
<span class='kw'>fn</span> <span class='ident'>inv</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
}
<span class='kw'>impl</span> <span class='op'><</span><span class='ident'>T</span>: <span class='ident'>BitXor</span><span class='op'><</span><span class='ident'>Output</span> <span class='op'>=</span> <span class='ident'>T</span><span class='op'>></span> <span class='op'>+</span> <span class='ident'>BitAnd</span><span class='op'><</span><span class='ident'>Output</span> <span class='op'>=</span> <span class='ident'>T</span><span class='op'>></span> <span class='op'>+</span> <span class='ident'>Copy</span><span class='op'>></span> <span class='ident'>Gf4Ops</span> <span class='kw'>for</span> <span class='ident'>Bs4State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>fn</span> <span class='ident'>mul</span>(<span class='self'>self</span>, <span class='ident'>y</span>: <span class='ident'>Bs4State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span>) <span class='op'>-></span> <span class='ident'>Bs4State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> (<span class='ident'>b</span>, <span class='ident'>a</span>) <span class='op'>=</span> <span class='self'>self</span>.<span class='ident'>split</span>();
<span class='kw'>let</span> (<span class='ident'>d</span>, <span class='ident'>c</span>) <span class='op'>=</span> <span class='ident'>y</span>.<span class='ident'>split</span>();
<span class='kw'>let</span> <span class='ident'>f</span> <span class='op'>=</span> <span class='ident'>c</span>.<span class='ident'>xor</span>(<span class='ident'>d</span>);
<span class='kw'>let</span> <span class='ident'>e</span> <span class='op'>=</span> <span class='ident'>a</span>.<span class='ident'>xor</span>(<span class='ident'>b</span>).<span class='ident'>mul</span>(<span class='ident'>f</span>).<span class='ident'>scl_n</span>();
<span class='kw'>let</span> <span class='ident'>p</span> <span class='op'>=</span> <span class='ident'>a</span>.<span class='ident'>mul</span>(<span class='ident'>c</span>).<span class='ident'>xor</span>(<span class='ident'>e</span>);
<span class='kw'>let</span> <span class='ident'>q</span> <span class='op'>=</span> <span class='ident'>b</span>.<span class='ident'>mul</span>(<span class='ident'>d</span>).<span class='ident'>xor</span>(<span class='ident'>e</span>);
<span class='ident'>q</span>.<span class='ident'>join</span>(<span class='ident'>p</span>)
}
<span class='kw'>fn</span> <span class='ident'>sq_scl</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs4State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> (<span class='ident'>b</span>, <span class='ident'>a</span>) <span class='op'>=</span> <span class='self'>self</span>.<span class='ident'>split</span>();
<span class='kw'>let</span> <span class='ident'>p</span> <span class='op'>=</span> <span class='ident'>a</span>.<span class='ident'>xor</span>(<span class='ident'>b</span>).<span class='ident'>sq</span>();
<span class='kw'>let</span> <span class='ident'>q</span> <span class='op'>=</span> <span class='ident'>b</span>.<span class='ident'>sq</span>().<span class='ident'>scl_n2</span>();
<span class='ident'>q</span>.<span class='ident'>join</span>(<span class='ident'>p</span>)
}
<span class='kw'>fn</span> <span class='ident'>inv</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs4State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> (<span class='ident'>b</span>, <span class='ident'>a</span>) <span class='op'>=</span> <span class='self'>self</span>.<span class='ident'>split</span>();
<span class='kw'>let</span> <span class='ident'>c</span> <span class='op'>=</span> <span class='ident'>a</span>.<span class='ident'>xor</span>(<span class='ident'>b</span>).<span class='ident'>sq</span>().<span class='ident'>scl_n</span>();
<span class='kw'>let</span> <span class='ident'>d</span> <span class='op'>=</span> <span class='ident'>a</span>.<span class='ident'>mul</span>(<span class='ident'>b</span>);
<span class='kw'>let</span> <span class='ident'>e</span> <span class='op'>=</span> <span class='ident'>c</span>.<span class='ident'>xor</span>(<span class='ident'>d</span>).<span class='ident'>inv</span>();
<span class='kw'>let</span> <span class='ident'>p</span> <span class='op'>=</span> <span class='ident'>e</span>.<span class='ident'>mul</span>(<span class='ident'>b</span>);
<span class='kw'>let</span> <span class='ident'>q</span> <span class='op'>=</span> <span class='ident'>e</span>.<span class='ident'>mul</span>(<span class='ident'>a</span>);
<span class='ident'>q</span>.<span class='ident'>join</span>(<span class='ident'>p</span>)
}
}
<span class='comment'>// Operations in GF(2^8) using normal basis (d^16,d)</span>
<span class='kw'>trait</span> <span class='ident'>Gf8Ops</span> {
<span class='comment'>// inverse</span>
<span class='kw'>fn</span> <span class='ident'>inv</span>(<span class='kw-2'>&</span><span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
}
<span class='kw'>impl</span> <span class='op'><</span><span class='ident'>T</span>: <span class='ident'>BitXor</span><span class='op'><</span><span class='ident'>Output</span> <span class='op'>=</span> <span class='ident'>T</span><span class='op'>></span> <span class='op'>+</span> <span class='ident'>BitAnd</span><span class='op'><</span><span class='ident'>Output</span> <span class='op'>=</span> <span class='ident'>T</span><span class='op'>></span> <span class='op'>+</span> <span class='ident'>Copy</span> <span class='op'>+</span> <span class='ident'>Default</span><span class='op'>></span> <span class='ident'>Gf8Ops</span> <span class='kw'>for</span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>fn</span> <span class='ident'>inv</span>(<span class='kw-2'>&</span><span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> (<span class='ident'>b</span>, <span class='ident'>a</span>) <span class='op'>=</span> <span class='self'>self</span>.<span class='ident'>split</span>();
<span class='kw'>let</span> <span class='ident'>c</span> <span class='op'>=</span> <span class='ident'>a</span>.<span class='ident'>xor</span>(<span class='ident'>b</span>).<span class='ident'>sq_scl</span>();
<span class='kw'>let</span> <span class='ident'>d</span> <span class='op'>=</span> <span class='ident'>a</span>.<span class='ident'>mul</span>(<span class='ident'>b</span>);
<span class='kw'>let</span> <span class='ident'>e</span> <span class='op'>=</span> <span class='ident'>c</span>.<span class='ident'>xor</span>(<span class='ident'>d</span>).<span class='ident'>inv</span>();
<span class='kw'>let</span> <span class='ident'>p</span> <span class='op'>=</span> <span class='ident'>e</span>.<span class='ident'>mul</span>(<span class='ident'>b</span>);
<span class='kw'>let</span> <span class='ident'>q</span> <span class='op'>=</span> <span class='ident'>e</span>.<span class='ident'>mul</span>(<span class='ident'>a</span>);
<span class='ident'>q</span>.<span class='ident'>join</span>(<span class='ident'>p</span>)
}
}
<span class='kw'>impl</span> <span class='op'><</span><span class='ident'>T</span>: <span class='ident'>AesBitValueOps</span> <span class='op'>+</span> <span class='ident'>Copy</span> <span class='op'>+</span> <span class='lifetime'>'static</span><span class='op'>></span> <span class='ident'>AesOps</span> <span class='kw'>for</span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>fn</span> <span class='ident'>sub_bytes</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>nb</span>: <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> <span class='op'>=</span> <span class='self'>self</span>.<span class='ident'>change_basis_a2x</span>();
<span class='kw'>let</span> <span class='ident'>inv</span> <span class='op'>=</span> <span class='ident'>nb</span>.<span class='ident'>inv</span>();
<span class='kw'>let</span> <span class='ident'>nb2</span>: <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> <span class='op'>=</span> <span class='ident'>inv</span>.<span class='ident'>change_basis_x2s</span>();
<span class='ident'>nb2</span>.<span class='ident'>xor_x63</span>()
}
<span class='kw'>fn</span> <span class='ident'>inv_sub_bytes</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>t</span> <span class='op'>=</span> <span class='self'>self</span>.<span class='ident'>xor_x63</span>();
<span class='kw'>let</span> <span class='ident'>nb</span>: <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> <span class='op'>=</span> <span class='ident'>t</span>.<span class='ident'>change_basis_s2x</span>();
<span class='kw'>let</span> <span class='ident'>inv</span> <span class='op'>=</span> <span class='ident'>nb</span>.<span class='ident'>inv</span>();
<span class='ident'>inv</span>.<span class='ident'>change_basis_x2a</span>()
}
<span class='kw'>fn</span> <span class='ident'>shift_rows</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>Bs8State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>, <span class='ident'>x2</span>, <span class='ident'>x3</span>, <span class='ident'>x4</span>, <span class='ident'>x5</span>, <span class='ident'>x6</span>, <span class='ident'>x7</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='ident'>Bs8State</span>(
<span class='ident'>x0</span>.<span class='ident'>shift_row</span>(),
<span class='ident'>x1</span>.<span class='ident'>shift_row</span>(),
<span class='ident'>x2</span>.<span class='ident'>shift_row</span>(),
<span class='ident'>x3</span>.<span class='ident'>shift_row</span>(),
<span class='ident'>x4</span>.<span class='ident'>shift_row</span>(),
<span class='ident'>x5</span>.<span class='ident'>shift_row</span>(),
<span class='ident'>x6</span>.<span class='ident'>shift_row</span>(),
<span class='ident'>x7</span>.<span class='ident'>shift_row</span>())
}
<span class='kw'>fn</span> <span class='ident'>inv_shift_rows</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>Bs8State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>, <span class='ident'>x2</span>, <span class='ident'>x3</span>, <span class='ident'>x4</span>, <span class='ident'>x5</span>, <span class='ident'>x6</span>, <span class='ident'>x7</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='ident'>Bs8State</span>(
<span class='ident'>x0</span>.<span class='ident'>inv_shift_row</span>(),
<span class='ident'>x1</span>.<span class='ident'>inv_shift_row</span>(),
<span class='ident'>x2</span>.<span class='ident'>inv_shift_row</span>(),
<span class='ident'>x3</span>.<span class='ident'>inv_shift_row</span>(),
<span class='ident'>x4</span>.<span class='ident'>inv_shift_row</span>(),
<span class='ident'>x5</span>.<span class='ident'>inv_shift_row</span>(),
<span class='ident'>x6</span>.<span class='ident'>inv_shift_row</span>(),
<span class='ident'>x7</span>.<span class='ident'>inv_shift_row</span>())
}
<span class='comment'>// Formula from [5]</span>
<span class='kw'>fn</span> <span class='ident'>mix_columns</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>Bs8State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>, <span class='ident'>x2</span>, <span class='ident'>x3</span>, <span class='ident'>x4</span>, <span class='ident'>x5</span>, <span class='ident'>x6</span>, <span class='ident'>x7</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='kw'>let</span> <span class='ident'>x0out</span> <span class='op'>=</span> <span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x7</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> <span class='ident'>x0</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> (<span class='ident'>x0</span> <span class='op'>^</span> <span class='ident'>x0</span>.<span class='ident'>ror1</span>()).<span class='ident'>ror2</span>();
<span class='kw'>let</span> <span class='ident'>x1out</span> <span class='op'>=</span> <span class='ident'>x0</span> <span class='op'>^</span> <span class='ident'>x0</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> <span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x7</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> <span class='ident'>x1</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> (<span class='ident'>x1</span> <span class='op'>^</span> <span class='ident'>x1</span>.<span class='ident'>ror1</span>()).<span class='ident'>ror2</span>();
<span class='kw'>let</span> <span class='ident'>x2out</span> <span class='op'>=</span> <span class='ident'>x1</span> <span class='op'>^</span> <span class='ident'>x1</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> <span class='ident'>x2</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> (<span class='ident'>x2</span> <span class='op'>^</span> <span class='ident'>x2</span>.<span class='ident'>ror1</span>()).<span class='ident'>ror2</span>();
<span class='kw'>let</span> <span class='ident'>x3out</span> <span class='op'>=</span> <span class='ident'>x2</span> <span class='op'>^</span> <span class='ident'>x2</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> <span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x7</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> <span class='ident'>x3</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> (<span class='ident'>x3</span> <span class='op'>^</span> <span class='ident'>x3</span>.<span class='ident'>ror1</span>()).<span class='ident'>ror2</span>();
<span class='kw'>let</span> <span class='ident'>x4out</span> <span class='op'>=</span> <span class='ident'>x3</span> <span class='op'>^</span> <span class='ident'>x3</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> <span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x7</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> <span class='ident'>x4</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> (<span class='ident'>x4</span> <span class='op'>^</span> <span class='ident'>x4</span>.<span class='ident'>ror1</span>()).<span class='ident'>ror2</span>();
<span class='kw'>let</span> <span class='ident'>x5out</span> <span class='op'>=</span> <span class='ident'>x4</span> <span class='op'>^</span> <span class='ident'>x4</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> <span class='ident'>x5</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> (<span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x5</span>.<span class='ident'>ror1</span>()).<span class='ident'>ror2</span>();
<span class='kw'>let</span> <span class='ident'>x6out</span> <span class='op'>=</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x5</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> <span class='ident'>x6</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> (<span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x6</span>.<span class='ident'>ror1</span>()).<span class='ident'>ror2</span>();
<span class='kw'>let</span> <span class='ident'>x7out</span> <span class='op'>=</span> <span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x6</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> <span class='ident'>x7</span>.<span class='ident'>ror1</span>() <span class='op'>^</span> (<span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x7</span>.<span class='ident'>ror1</span>()).<span class='ident'>ror2</span>();
<span class='ident'>Bs8State</span>(<span class='ident'>x0out</span>, <span class='ident'>x1out</span>, <span class='ident'>x2out</span>, <span class='ident'>x3out</span>, <span class='ident'>x4out</span>, <span class='ident'>x5out</span>, <span class='ident'>x6out</span>, <span class='ident'>x7out</span>)
}
<span class='comment'>// Formula from [6]</span>
<span class='kw'>fn</span> <span class='ident'>inv_mix_columns</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='kw'>let</span> <span class='ident'>Bs8State</span>(<span class='ident'>x0</span>, <span class='ident'>x1</span>, <span class='ident'>x2</span>, <span class='ident'>x3</span>, <span class='ident'>x4</span>, <span class='ident'>x5</span>, <span class='ident'>x6</span>, <span class='ident'>x7</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='kw'>let</span> <span class='ident'>x0out</span> <span class='op'>=</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x7</span> <span class='op'>^</span>
(<span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x0</span>).<span class='ident'>ror1</span>() <span class='op'>^</span>
(<span class='ident'>x0</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x6</span>).<span class='ident'>ror2</span>() <span class='op'>^</span>
(<span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x0</span>).<span class='ident'>ror3</span>();
<span class='kw'>let</span> <span class='ident'>x1out</span> <span class='op'>=</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x0</span> <span class='op'>^</span>
(<span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x0</span> <span class='op'>^</span> <span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x1</span>).<span class='ident'>ror1</span>() <span class='op'>^</span>
(<span class='ident'>x1</span> <span class='op'>^</span> <span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x5</span>).<span class='ident'>ror2</span>() <span class='op'>^</span>
(<span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x1</span>).<span class='ident'>ror3</span>();
<span class='kw'>let</span> <span class='ident'>x2out</span> <span class='op'>=</span> <span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x0</span> <span class='op'>^</span> <span class='ident'>x1</span> <span class='op'>^</span>
(<span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x1</span> <span class='op'>^</span> <span class='ident'>x2</span>).<span class='ident'>ror1</span>() <span class='op'>^</span>
(<span class='ident'>x0</span> <span class='op'>^</span> <span class='ident'>x2</span> <span class='op'>^</span> <span class='ident'>x6</span>).<span class='ident'>ror2</span>() <span class='op'>^</span>
(<span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x2</span>).<span class='ident'>ror3</span>();
<span class='kw'>let</span> <span class='ident'>x3out</span> <span class='op'>=</span> <span class='ident'>x0</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x1</span> <span class='op'>^</span> <span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x2</span> <span class='op'>^</span>
(<span class='ident'>x0</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x2</span> <span class='op'>^</span> <span class='ident'>x3</span>).<span class='ident'>ror1</span>() <span class='op'>^</span>
(<span class='ident'>x0</span> <span class='op'>^</span> <span class='ident'>x1</span> <span class='op'>^</span> <span class='ident'>x3</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x7</span>).<span class='ident'>ror2</span>() <span class='op'>^</span>
(<span class='ident'>x0</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x3</span>).<span class='ident'>ror3</span>();
<span class='kw'>let</span> <span class='ident'>x4out</span> <span class='op'>=</span> <span class='ident'>x1</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x2</span> <span class='op'>^</span> <span class='ident'>x3</span> <span class='op'>^</span>
(<span class='ident'>x1</span> <span class='op'>^</span> <span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x3</span> <span class='op'>^</span> <span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x4</span>).<span class='ident'>ror1</span>() <span class='op'>^</span>
(<span class='ident'>x1</span> <span class='op'>^</span> <span class='ident'>x2</span> <span class='op'>^</span> <span class='ident'>x4</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x7</span>).<span class='ident'>ror2</span>() <span class='op'>^</span>
(<span class='ident'>x1</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x4</span>).<span class='ident'>ror3</span>();
<span class='kw'>let</span> <span class='ident'>x5out</span> <span class='op'>=</span> <span class='ident'>x2</span> <span class='op'>^</span> <span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x3</span> <span class='op'>^</span> <span class='ident'>x4</span> <span class='op'>^</span>
(<span class='ident'>x2</span> <span class='op'>^</span> <span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x4</span> <span class='op'>^</span> <span class='ident'>x5</span>).<span class='ident'>ror1</span>() <span class='op'>^</span>
(<span class='ident'>x2</span> <span class='op'>^</span> <span class='ident'>x3</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x6</span>).<span class='ident'>ror2</span>() <span class='op'>^</span>
(<span class='ident'>x2</span> <span class='op'>^</span> <span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x5</span>).<span class='ident'>ror3</span>();
<span class='kw'>let</span> <span class='ident'>x6out</span> <span class='op'>=</span> <span class='ident'>x3</span> <span class='op'>^</span> <span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x4</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span>
(<span class='ident'>x3</span> <span class='op'>^</span> <span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x6</span>).<span class='ident'>ror1</span>() <span class='op'>^</span>
(<span class='ident'>x3</span> <span class='op'>^</span> <span class='ident'>x4</span> <span class='op'>^</span> <span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x7</span>).<span class='ident'>ror2</span>() <span class='op'>^</span>
(<span class='ident'>x3</span> <span class='op'>^</span> <span class='ident'>x7</span> <span class='op'>^</span> <span class='ident'>x6</span>).<span class='ident'>ror3</span>();
<span class='kw'>let</span> <span class='ident'>x7out</span> <span class='op'>=</span> <span class='ident'>x4</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x6</span> <span class='op'>^</span>
(<span class='ident'>x4</span> <span class='op'>^</span> <span class='ident'>x6</span> <span class='op'>^</span> <span class='ident'>x7</span>).<span class='ident'>ror1</span>() <span class='op'>^</span>
(<span class='ident'>x4</span> <span class='op'>^</span> <span class='ident'>x5</span> <span class='op'>^</span> <span class='ident'>x7</span>).<span class='ident'>ror2</span>() <span class='op'>^</span>
(<span class='ident'>x4</span> <span class='op'>^</span> <span class='ident'>x7</span>).<span class='ident'>ror3</span>();
<span class='ident'>Bs8State</span>(<span class='ident'>x0out</span>, <span class='ident'>x1out</span>, <span class='ident'>x2out</span>, <span class='ident'>x3out</span>, <span class='ident'>x4out</span>, <span class='ident'>x5out</span>, <span class='ident'>x6out</span>, <span class='ident'>x7out</span>)
}
<span class='kw'>fn</span> <span class='ident'>add_round_key</span>(<span class='self'>self</span>, <span class='ident'>rk</span>: <span class='kw-2'>&</span><span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span>) <span class='op'>-></span> <span class='ident'>Bs8State</span><span class='op'><</span><span class='ident'>T</span><span class='op'>></span> {
<span class='self'>self</span>.<span class='ident'>xor</span>(<span class='kw-2'>*</span><span class='ident'>rk</span>)
}
}
<span class='kw'>trait</span> <span class='ident'>AesBitValueOps</span>: <span class='ident'>BitXor</span><span class='op'><</span><span class='ident'>Output</span> <span class='op'>=</span> <span class='self'>Self</span><span class='op'>></span> <span class='op'>+</span> <span class='ident'>BitAnd</span><span class='op'><</span><span class='ident'>Output</span> <span class='op'>=</span> <span class='self'>Self</span><span class='op'>></span> <span class='op'>+</span> <span class='ident'>Not</span><span class='op'><</span><span class='ident'>Output</span> <span class='op'>=</span> <span class='self'>Self</span><span class='op'>></span> <span class='op'>+</span> <span class='ident'>Default</span> <span class='op'>+</span> <span class='ident'>Sized</span> {
<span class='kw'>fn</span> <span class='ident'>shift_row</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='kw'>fn</span> <span class='ident'>inv_shift_row</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='kw'>fn</span> <span class='ident'>ror1</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='kw'>fn</span> <span class='ident'>ror2</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
<span class='kw'>fn</span> <span class='ident'>ror3</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='self'>Self</span>;
}
<span class='kw'>impl</span> <span class='ident'>AesBitValueOps</span> <span class='kw'>for</span> <span class='ident'>u16</span> {
<span class='kw'>fn</span> <span class='ident'>shift_row</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>u16</span> {
<span class='comment'>// first 4 bits represent first row - don't shift</span>
(<span class='self'>self</span> <span class='op'>&</span> <span class='number'>0x000f</span>) <span class='op'>|</span>
<span class='comment'>// next 4 bits represent 2nd row - left rotate 1 bit</span>
((<span class='self'>self</span> <span class='op'>&</span> <span class='number'>0x00e0</span>) <span class='op'>>></span> <span class='number'>1</span>) <span class='op'>|</span> ((<span class='self'>self</span> <span class='op'>&</span> <span class='number'>0x0010</span>) <span class='op'><<</span> <span class='number'>3</span>) <span class='op'>|</span>
<span class='comment'>// next 4 bits represent 3rd row - left rotate 2 bits</span>
((<span class='self'>self</span> <span class='op'>&</span> <span class='number'>0x0c00</span>) <span class='op'>>></span> <span class='number'>2</span>) <span class='op'>|</span> ((<span class='self'>self</span> <span class='op'>&</span> <span class='number'>0x0300</span>) <span class='op'><<</span> <span class='number'>2</span>) <span class='op'>|</span>
<span class='comment'>// next 4 bits represent 4th row - left rotate 3 bits</span>
((<span class='self'>self</span> <span class='op'>&</span> <span class='number'>0x8000</span>) <span class='op'>>></span> <span class='number'>3</span>) <span class='op'>|</span> ((<span class='self'>self</span> <span class='op'>&</span> <span class='number'>0x7000</span>) <span class='op'><<</span> <span class='number'>1</span>)
}
<span class='kw'>fn</span> <span class='ident'>inv_shift_row</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>u16</span> {
<span class='comment'>// first 4 bits represent first row - don't shift</span>
(<span class='self'>self</span> <span class='op'>&</span> <span class='number'>0x000f</span>) <span class='op'>|</span>
<span class='comment'>// next 4 bits represent 2nd row - right rotate 1 bit</span>
((<span class='self'>self</span> <span class='op'>&</span> <span class='number'>0x0080</span>) <span class='op'>>></span> <span class='number'>3</span>) <span class='op'>|</span> ((<span class='self'>self</span> <span class='op'>&</span> <span class='number'>0x0070</span>) <span class='op'><<</span> <span class='number'>1</span>) <span class='op'>|</span>
<span class='comment'>// next 4 bits represent 3rd row - right rotate 2 bits</span>
((<span class='self'>self</span> <span class='op'>&</span> <span class='number'>0x0c00</span>) <span class='op'>>></span> <span class='number'>2</span>) <span class='op'>|</span> ((<span class='self'>self</span> <span class='op'>&</span> <span class='number'>0x0300</span>) <span class='op'><<</span> <span class='number'>2</span>) <span class='op'>|</span>
<span class='comment'>// next 4 bits represent 4th row - right rotate 3 bits</span>
((<span class='self'>self</span> <span class='op'>&</span> <span class='number'>0xe000</span>) <span class='op'>>></span> <span class='number'>1</span>) <span class='op'>|</span> ((<span class='self'>self</span> <span class='op'>&</span> <span class='number'>0x1000</span>) <span class='op'><<</span> <span class='number'>3</span>)
}
<span class='kw'>fn</span> <span class='ident'>ror1</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>u16</span> {
<span class='self'>self</span> <span class='op'>>></span> <span class='number'>4</span> <span class='op'>|</span> <span class='self'>self</span> <span class='op'><<</span> <span class='number'>12</span>
}
<span class='kw'>fn</span> <span class='ident'>ror2</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>u16</span> {
<span class='self'>self</span> <span class='op'>>></span> <span class='number'>8</span> <span class='op'>|</span> <span class='self'>self</span> <span class='op'><<</span> <span class='number'>8</span>
}
<span class='kw'>fn</span> <span class='ident'>ror3</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>u16</span> {
<span class='self'>self</span> <span class='op'>>></span> <span class='number'>12</span> <span class='op'>|</span> <span class='self'>self</span> <span class='op'><<</span> <span class='number'>4</span>
}
}
<span class='kw'>impl</span> <span class='ident'>u32x4</span> {
<span class='kw'>fn</span> <span class='ident'>lsh</span>(<span class='self'>self</span>, <span class='ident'>s</span>: <span class='ident'>u32</span>) <span class='op'>-></span> <span class='ident'>u32x4</span> {
<span class='kw'>let</span> <span class='ident'>u32x4</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span>, <span class='ident'>a2</span>, <span class='ident'>a3</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='ident'>u32x4</span>(
<span class='ident'>a0</span> <span class='op'><<</span> <span class='ident'>s</span>,
(<span class='ident'>a1</span> <span class='op'><<</span> <span class='ident'>s</span>) <span class='op'>|</span> (<span class='ident'>a0</span> <span class='op'>>></span> (<span class='number'>32</span> <span class='op'>-</span> <span class='ident'>s</span>)),
(<span class='ident'>a2</span> <span class='op'><<</span> <span class='ident'>s</span>) <span class='op'>|</span> (<span class='ident'>a1</span> <span class='op'>>></span> (<span class='number'>32</span> <span class='op'>-</span> <span class='ident'>s</span>)),
(<span class='ident'>a3</span> <span class='op'><<</span> <span class='ident'>s</span>) <span class='op'>|</span> (<span class='ident'>a2</span> <span class='op'>>></span> (<span class='number'>32</span> <span class='op'>-</span> <span class='ident'>s</span>)))
}
<span class='kw'>fn</span> <span class='ident'>rsh</span>(<span class='self'>self</span>, <span class='ident'>s</span>: <span class='ident'>u32</span>) <span class='op'>-></span> <span class='ident'>u32x4</span> {
<span class='kw'>let</span> <span class='ident'>u32x4</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span>, <span class='ident'>a2</span>, <span class='ident'>a3</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='ident'>u32x4</span>(
(<span class='ident'>a0</span> <span class='op'>>></span> <span class='ident'>s</span>) <span class='op'>|</span> (<span class='ident'>a1</span> <span class='op'><<</span> (<span class='number'>32</span> <span class='op'>-</span> <span class='ident'>s</span>)),
(<span class='ident'>a1</span> <span class='op'>>></span> <span class='ident'>s</span>) <span class='op'>|</span> (<span class='ident'>a2</span> <span class='op'><<</span> (<span class='number'>32</span> <span class='op'>-</span> <span class='ident'>s</span>)),
(<span class='ident'>a2</span> <span class='op'>>></span> <span class='ident'>s</span>) <span class='op'>|</span> (<span class='ident'>a3</span> <span class='op'><<</span> (<span class='number'>32</span> <span class='op'>-</span> <span class='ident'>s</span>)),
<span class='ident'>a3</span> <span class='op'>>></span> <span class='ident'>s</span>)
}
}
<span class='kw'>impl</span> <span class='ident'>Not</span> <span class='kw'>for</span> <span class='ident'>u32x4</span> {
<span class='kw'>type</span> <span class='ident'>Output</span> <span class='op'>=</span> <span class='ident'>u32x4</span>;
<span class='kw'>fn</span> <span class='ident'>not</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>u32x4</span> {
<span class='self'>self</span> <span class='op'>^</span> <span class='ident'>U32X4_1</span>
}
}
<span class='kw'>impl</span> <span class='ident'>Default</span> <span class='kw'>for</span> <span class='ident'>u32x4</span> {
<span class='kw'>fn</span> <span class='ident'>default</span>() <span class='op'>-></span> <span class='ident'>u32x4</span> {
<span class='ident'>u32x4</span>(<span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>)
}
}
<span class='kw'>impl</span> <span class='ident'>AesBitValueOps</span> <span class='kw'>for</span> <span class='ident'>u32x4</span> {
<span class='kw'>fn</span> <span class='ident'>shift_row</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>u32x4</span> {
<span class='kw'>let</span> <span class='ident'>u32x4</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span>, <span class='ident'>a2</span>, <span class='ident'>a3</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='ident'>u32x4</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span> <span class='op'>>></span> <span class='number'>8</span> <span class='op'>|</span> <span class='ident'>a1</span> <span class='op'><<</span> <span class='number'>24</span>, <span class='ident'>a2</span> <span class='op'>>></span> <span class='number'>16</span> <span class='op'>|</span> <span class='ident'>a2</span> <span class='op'><<</span> <span class='number'>16</span>, <span class='ident'>a3</span> <span class='op'>>></span> <span class='number'>24</span> <span class='op'>|</span> <span class='ident'>a3</span> <span class='op'><<</span> <span class='number'>8</span>)
}
<span class='kw'>fn</span> <span class='ident'>inv_shift_row</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>u32x4</span> {
<span class='kw'>let</span> <span class='ident'>u32x4</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span>, <span class='ident'>a2</span>, <span class='ident'>a3</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='ident'>u32x4</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span> <span class='op'>>></span> <span class='number'>24</span> <span class='op'>|</span> <span class='ident'>a1</span> <span class='op'><<</span> <span class='number'>8</span>, <span class='ident'>a2</span> <span class='op'>>></span> <span class='number'>16</span> <span class='op'>|</span> <span class='ident'>a2</span> <span class='op'><<</span> <span class='number'>16</span>, <span class='ident'>a3</span> <span class='op'>>></span> <span class='number'>8</span> <span class='op'>|</span> <span class='ident'>a3</span> <span class='op'><<</span> <span class='number'>24</span>)
}
<span class='kw'>fn</span> <span class='ident'>ror1</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>u32x4</span> {
<span class='kw'>let</span> <span class='ident'>u32x4</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span>, <span class='ident'>a2</span>, <span class='ident'>a3</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='ident'>u32x4</span>(<span class='ident'>a1</span>, <span class='ident'>a2</span>, <span class='ident'>a3</span>, <span class='ident'>a0</span>)
}
<span class='kw'>fn</span> <span class='ident'>ror2</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>u32x4</span> {
<span class='kw'>let</span> <span class='ident'>u32x4</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span>, <span class='ident'>a2</span>, <span class='ident'>a3</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='ident'>u32x4</span>(<span class='ident'>a2</span>, <span class='ident'>a3</span>, <span class='ident'>a0</span>, <span class='ident'>a1</span>)
}
<span class='kw'>fn</span> <span class='ident'>ror3</span>(<span class='self'>self</span>) <span class='op'>-></span> <span class='ident'>u32x4</span> {
<span class='kw'>let</span> <span class='ident'>u32x4</span>(<span class='ident'>a0</span>, <span class='ident'>a1</span>, <span class='ident'>a2</span>, <span class='ident'>a3</span>) <span class='op'>=</span> <span class='self'>self</span>;
<span class='ident'>u32x4</span>(<span class='ident'>a3</span>, <span class='ident'>a0</span>, <span class='ident'>a1</span>, <span class='ident'>a2</span>)
}
}
</pre>
</section>
<section id='search' class="content hidden"></section>
<section class="footer"></section>
<aside id="help" class="hidden">
<div>
<h1 class="hidden">Help</h1>
<div class="shortcuts">
<h2>Keyboard Shortcuts</h2>
<dl>
<dt>?</dt>
<dd>Show this help dialog</dd>
<dt>S</dt>
<dd>Focus the search field</dd>
<dt>⇤</dt>
<dd>Move up in search results</dd>
<dt>⇥</dt>
<dd>Move down in search results</dd>
<dt>⏎</dt>
<dd>Go to active search result</dd>
<dt>+</dt>
<dd>Collapse/expand all sections</dd>
</dl>
</div>
<div class="infos">
<h2>Search Tricks</h2>
<p>
Prefix searches with a type followed by a colon (e.g.
<code>fn:</code>) to restrict the search to a given type.
</p>
<p>
Accepted types are: <code>fn</code>, <code>mod</code>,
<code>struct</code>, <code>enum</code>,
<code>trait</code>, <code>type</code>, <code>macro</code>,
and <code>const</code>.
</p>
<p>
Search functions by type signature (e.g.
<code>vec -> usize</code> or <code>* -> vec</code>)
</p>
</div>
</div>
</aside>
<script>
window.rootPath = "../../";
window.currentCrate = "crypto";
</script>
<script src="../../jquery.js"></script>
<script src="../../main.js"></script>
<script defer src="../../search-index.js"></script>
</body>
</html>