gem5  v21.0.0.0
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
qarma.cc
Go to the documentation of this file.
1 // -*- mode:c++ -*-
2 
3 // Copyright (c) 2020 Metempsy Technology Consulting
4 // All rights reserved
5 //
6 // The license below extends only to copyright in the software and shall
7 // not be construed as granting a license to any other intellectual
8 // property including but not limited to intellectual property relating
9 // to a hardware implementation of the functionality of the software
10 // licensed hereunder. You may use the software subject to the license
11 // terms below provided that you ensure that this notice is replicated
12 // unmodified and in its entirety in all distributions of the software,
13 // modified or unmodified, in source code or in binary form.
14 //
15 // Redistribution and use in source and binary forms, with or without
16 // modification, are permitted provided that the following conditions are
17 // met: redistributions of source code must retain the above copyright
18 // notice, this list of conditions and the following disclaimer;
19 // redistributions in binary form must reproduce the above copyright
20 // notice, this list of conditions and the following disclaimer in the
21 // documentation and/or other materials provided with the distribution;
22 // neither the name of the copyright holders nor the names of its
23 // contributors may be used to endorse or promote products derived from
24 // this software without specific prior written permission.
25 //
26 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
27 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
28 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
29 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
30 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
31 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
32 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
33 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
34 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
35 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
36 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 
38 #include "arch/arm/qarma.hh"
39 
40 #include <array>
41 
42 #include "base/bitfield.hh"
43 
44 using namespace QARMA;
45 
46 
47 uint8_t
48 QARMA::rotCell(uint8_t incell, int amount)
49 {
50  uint8_t res = ((incell << amount) | (incell >> (4-amount)))& 0xF;
51  return res;
52 }
53 
54 uint8_t
55 QARMA::tweakCellInvRot(uint8_t incell)
56 {
57  uint8_t outcell = 0x0;
58  outcell = incell << 1;
59  uint8_t t = 0x1 & (incell ^ (incell>>3));
60  outcell |= t;
61  return outcell & 0xF;
62 }
63 
64 uint8_t
65 QARMA::tweakCellRot(uint8_t incell)
66 {
67  uint8_t outcell = 0x0;
68  outcell = incell >> 1;
69  uint8_t t = 0x1 & (incell ^ (incell>>1));
70  outcell |= t<<3;
71  return outcell & 0xF;
72 }
73 
74 BIT64
75 QARMA::tweakInvShuffle(BIT64 indata)
76 {
77  BIT64 outdata = 0x0;
78  outdata.b0 = tweakCellInvRot(indata.b12);
79  outdata.b1 = indata.b13;
80  outdata.b2 = indata.b5;
81  outdata.b3 = indata.b6;
82  outdata.b4 = indata.b0;
83  outdata.b5 = indata.b1;
84  outdata.b6 = tweakCellInvRot(indata.b2);
85  outdata.b7 = indata.b3;
86  outdata.b8 = tweakCellInvRot(indata.b7);
87  outdata.b9 = tweakCellInvRot(indata.b15);
88  outdata.b10 = tweakCellInvRot(indata.b14);
89  outdata.b11 = tweakCellInvRot(indata.b4);
90  outdata.b12 = indata.b8;
91  outdata.b13 = indata.b9;
92  outdata.b14 = indata.b10;
93  outdata.b15 = tweakCellInvRot(indata.b11);
94  return outdata;
95 }
96 
97 BIT64
98 QARMA::tweakShuffle(BIT64 indata)
99 {
100  BIT64 outdata = 0x0;
101  outdata.b0 = indata.b4;
102  outdata.b1 = indata.b5;
103  outdata.b2 = tweakCellRot(indata.b6);
104  outdata.b3 = indata.b7;
105  outdata.b4 = tweakCellRot(indata.b11);
106  outdata.b5 = indata.b2;
107  outdata.b6 = indata.b3;
108  outdata.b7 = tweakCellRot(indata.b8);
109  outdata.b8 = indata.b12;
110  outdata.b9 = indata.b13;
111  outdata.b10 = indata.b14;
112  outdata.b11 = tweakCellRot(indata.b15);
113  outdata.b12 = tweakCellRot(indata.b0);
114  outdata.b13 = indata.b1;
115  outdata.b14 = tweakCellRot(indata.b10);
116  outdata.b15 = tweakCellRot(indata.b9);
117  return outdata;
118 }
119 
120 
121 BIT64
122 QARMA::PACCellInvShuffle(BIT64 indata)
123 {
124  BIT64 outdata = 0x0;
125  outdata.b0 = indata.b3;
126  outdata.b1 = indata.b6;
127  outdata.b2 = indata.b12;
128  outdata.b3 = indata.b9;
129  outdata.b4 = indata.b14;
130  outdata.b5 = indata.b11;
131  outdata.b6 = indata.b1;
132  outdata.b7 = indata.b4;
133  outdata.b8 = indata.b8;
134  outdata.b9 = indata.b13;
135  outdata.b10 = indata.b7;
136  outdata.b11 = indata.b2;
137  outdata.b12 = indata.b5;
138  outdata.b13 = indata.b0;
139  outdata.b14 = indata.b10;
140  outdata.b15 = indata.b15;
141  return outdata;
142 }
143 
144 BIT64
145 QARMA::PACCellShuffle(BIT64 indata)
146 {
147  BIT64 outdata = 0x0;
148  outdata.b0 = indata.b13;
149  outdata.b1 = indata.b6;
150  outdata.b2 = indata.b11;
151  outdata.b3 = indata.b0;
152  outdata.b4 = indata.b7;
153  outdata.b5 = indata.b12;
154  outdata.b6 = indata.b1;
155  outdata.b7 = indata.b10;
156  outdata.b8 = indata.b8;
157  outdata.b9 = indata.b3;
158  outdata.b10 = indata.b14;
159  outdata.b11 = indata.b5;
160  outdata.b12 = indata.b2;
161  outdata.b13 = indata.b9;
162  outdata.b14 = indata.b4;
163  outdata.b15 = indata.b15;
164  return outdata;
165 }
166 
167 
168 uint64_t
169 QARMA::PACInvSub(uint64_t tInput)
170 {
171  // This is a 4-bit substitution from the PRINCE-family cipher
172  uint64_t t_output = 0x0;
173  for (int i=15; i>=0; i--) {
174  t_output = t_output << 4;
175  uint8_t b = (tInput >> i*4 ) & 0xF;
176  switch ( b ) {
177  case 0x0:
178  t_output |= 0x5;
179  break;
180  case 0x1:
181  t_output |= 0xe;
182  break;
183  case 0x2:
184  t_output |= 0xd;
185  break;
186  case 0x3:
187  t_output |= 0x8;
188  break;
189  case 0x4:
190  t_output |= 0xa;
191  break;
192  case 0x5:
193  t_output |= 0xb;
194  break;
195  case 0x6:
196  t_output |= 0x1;
197  break;
198  case 0x7:
199  t_output |= 0x9;
200  break;
201  case 0x8:
202  t_output |= 0x2;
203  break;
204  case 0x9:
205  t_output |= 0x6;
206  break;
207  case 0xa:
208  t_output |= 0xf;
209  break;
210  case 0xb:
211  t_output |= 0x0;
212  break;
213  case 0xc:
214  t_output |= 0x4;
215  break;
216  case 0xd:
217  t_output |= 0xc;
218  break;
219  case 0xe:
220  t_output |= 0x7;
221  break;
222  case 0xf:
223  t_output |= 0x3;
224  break;
225  default:
226  //unreachable
227  break;
228  }
229  }
230  return t_output;
231 }
232 
233 uint64_t
234 QARMA::PACSub(uint64_t tInput){
235  // This is a 4-bit substitution from the PRINCE-family cipher
236  uint64_t t_output = 0x0;
237  for (int i=15; i>=0; i--) {
238  t_output = t_output << 4;
239  uint8_t b = (tInput >> i*4 ) & 0xF;
240  switch ( b ) {
241  case 0x0:
242  t_output |= 0xb;
243  break;
244  case 0x1:
245  t_output |= 0x6;
246  break;
247  case 0x2:
248  t_output |= 0x8;
249  break;
250  case 0x3:
251  t_output |= 0xf;
252  break;
253  case 0x4:
254  t_output |= 0xc;
255  break;
256  case 0x5:
257  t_output |= 0x0;
258  break;
259  case 0x6:
260  t_output |= 0x9;
261  break;
262  case 0x7:
263  t_output |= 0xe;
264  break;
265  case 0x8:
266  t_output |= 0x3;
267  break;
268  case 0x9:
269  t_output |= 0x7;
270  break;
271  case 0xa:
272  t_output |= 0x4;
273  break;
274  case 0xb:
275  t_output |= 0x5;
276  break;
277  case 0xc:
278  t_output |= 0xd;
279  break;
280  case 0xd:
281  t_output |= 0x2;
282  break;
283  case 0xe:
284  t_output |= 0x1;
285  break;
286  case 0xf:
287  t_output |= 0xa;
288  break;
289  default:
290  //unreachable
291  break;
292  }
293  }
294  return t_output;
295 }
296 
297 uint64_t
298 QARMA::PACMult(uint64_t tInput)
299 {
300  uint64_t t_output = 0;
301 
302  for (int i=0;i<=3; i++) {
303  uint8_t b8 = (tInput >> (4*(i+8))) & 0xF;
304  uint8_t b4 = (tInput >> (4*(i+4))) & 0xF;
305  uint8_t b12 = (tInput >> (4*(i+12))) & 0xF;
306  uint8_t b0 = (tInput >> (4*(i))) & 0xF;
307 
308  uint64_t t0 = rotCell(b8, 1) ^ rotCell(b4, 2);
309  t0 = t0 ^ rotCell(b0, 1);
310 
311  uint64_t t1 = rotCell(b12, 1) ^ rotCell(b4, 1);
312  t1 = t1 ^ rotCell(b0, 2);
313 
314  uint64_t t2 = rotCell(b12, 2) ^ rotCell(b8, 1);
315  t2 = t2 ^ rotCell(b0, 1);
316 
317  uint64_t t3 = rotCell(b12, 1) ^ rotCell(b8, 2);
318  t3 = t3 ^ rotCell(b4, 1);
319 
320  t_output |= (t3 << (4*i));
321  t_output |= (t2 << (4*(i+4)));
322  t_output |= (t1 << (4*(i+8)));
323  t_output |= (t0 << (4*(i+12)));
324  }
325  return t_output;
326 }
327 
328 BIT64
329 QARMA::computePAC(BIT64 data, BIT64 modifier, BIT64 key0, BIT64 key1)
330 {
331  BIT64 workingval;
332  BIT64 runningmod;
333  BIT64 roundkey;
334  BIT64 modk0;
335  std::array<BIT64, 5> RC;
336  RC[0] = (BIT64) 0x0000000000000000;
337  RC[1] = (BIT64) 0x13198A2E03707344;
338  RC[2] = (BIT64) 0xA4093822299F31D0;
339  RC[3] = (BIT64) 0x082EFA98EC4E6C89;
340  RC[4] = (BIT64) 0x452821E638D01377;
341 
342  const BIT64 alpha = 0xC0AC29B7C97C50DD;
343  //modk0 = key0<0>:key0<63:2>:
344 
345  modk0 = (key0 & 0x1) << 63;
346  modk0 = modk0 | ((key0 & ~0x3) >> 1);
347  modk0 = modk0 | ((key0.b15>>3) ^ ((key0.b0 & 0x2)>>1));
348 
349  runningmod = modifier;
350  workingval = data^key0;
351  for (int i=0; i<=4; i++) {
352  roundkey = key1 ^ runningmod;
353  workingval = workingval ^ roundkey;
354  workingval = workingval ^ RC[i];
355 
356  if (i > 0) {
357  workingval = PACCellShuffle(workingval);
358  workingval = PACMult(workingval);
359  }
360  workingval = PACSub(workingval);
361  runningmod = tweakShuffle(runningmod);
362  }
363  roundkey = modk0 ^ runningmod;
364  workingval = workingval ^ roundkey;
365 
366  workingval = PACCellShuffle(workingval);
367  workingval = PACMult(workingval);
368  workingval = PACSub(workingval);
369  workingval = PACCellShuffle(workingval);
370  workingval = PACMult(workingval);
371  workingval = key1 ^ workingval;
372 
373  workingval = PACCellInvShuffle(workingval);
374  workingval = PACInvSub(workingval);
375  workingval = PACMult(workingval);
376  workingval = PACCellInvShuffle(workingval);
377  workingval = workingval ^ key0;
378  workingval = workingval ^ runningmod;
379 
380  for (int i=0; i<=4; i++) {
381  workingval = PACInvSub(workingval);
382  if (i < 4) {
383  workingval = PACMult(workingval);
384  workingval = PACCellInvShuffle(workingval);
385  }
386  runningmod = tweakInvShuffle(runningmod);
387  roundkey = key1 ^ runningmod;
388  workingval = workingval ^ RC[4-i];
389  workingval = workingval ^ roundkey;
390  workingval = workingval ^ alpha;
391  }
392  workingval = workingval ^ modk0;
393  return workingval;
394 }
395 
data
const char data[]
Definition: circlebuf.test.cc:47
ArmISA::t2
Bitfield< 2 > t2
Definition: miscregs_types.hh:228
ArmISA::i
Bitfield< 7 > i
Definition: miscregs_types.hh:63
ArmISA::t3
Bitfield< 3 > t3
Definition: miscregs_types.hh:227
ArmISA::t0
Bitfield< 0 > t0
Definition: miscregs_types.hh:230
QARMA::tweakCellInvRot
uint8_t tweakCellInvRot(uint8_t incell)
Definition: qarma.cc:55
QARMA::amount
int amount
Definition: qarma.hh:67
qarma.hh
bitfield.hh
QARMA
Definition: qarma.hh:44
QARMA::PACSub
uint64_t PACSub(uint64_t tInput)
Definition: qarma.cc:234
QARMA::tweakShuffle
BIT64 tweakShuffle(BIT64 indata)
Definition: qarma.cc:98
QARMA::PACCellInvShuffle
BIT64 PACCellInvShuffle(BIT64 indata)
Definition: qarma.cc:122
QARMA::computePAC
BIT64 computePAC(BIT64 data, BIT64 modifier, BIT64 key0, BIT64 key1)
Definition: qarma.cc:329
QARMA::b8
Bitfield< 35, 32 > b8
Definition: qarma.hh:55
ArmISA::b
Bitfield< 7 > b
Definition: miscregs_types.hh:376
QARMA::tweakInvShuffle
BIT64 tweakInvShuffle(BIT64 indata)
Definition: qarma.cc:75
ArmISA::t
Bitfield< 5 > t
Definition: miscregs_types.hh:67
ArmISA::t1
Bitfield< 1 > t1
Definition: miscregs_types.hh:229
QARMA::b4
Bitfield< 19, 16 > b4
Definition: qarma.hh:59
QARMA::PACInvSub
uint64_t PACInvSub(uint64_t tInput)
Definition: qarma.cc:169
QARMA::PACCellShuffle
BIT64 PACCellShuffle(BIT64 indata)
Definition: qarma.cc:145
QARMA::PACMult
uint64_t PACMult(uint64_t tInput)
Definition: qarma.cc:298
QARMA::b0
Bitfield< 3, 0 > b0
Definition: qarma.hh:63
QARMA::b12
Bitfield< 51, 48 > b12
Definition: qarma.hh:51
QARMA::tweakCellRot
uint8_t tweakCellRot(uint8_t incell)
Definition: qarma.cc:65
Generated on Tue Mar 23 2021 19:41:20 for gem5 by doxygen 1.8.17