Crypto++  5.6.3
Free C++ class library of cryptographic schemes
shark.cpp
1 // shark.cpp - written and placed in the public domain by Wei Dai
2 
3 #include "pch.h"
4 #include "shark.h"
5 #include "misc.h"
6 #include "modes.h"
7 #include "gf256.h"
8 
9 #if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
10 # pragma GCC diagnostic ignored "-Wmissing-braces"
11 #endif
12 
13 NAMESPACE_BEGIN(CryptoPP)
14 
15 static word64 SHARKTransform(word64 a)
16 {
17  static const byte iG[8][8] = {
18  0xe7, 0x30, 0x90, 0x85, 0xd0, 0x4b, 0x91, 0x41,
19  0x53, 0x95, 0x9b, 0xa5, 0x96, 0xbc, 0xa1, 0x68,
20  0x02, 0x45, 0xf7, 0x65, 0x5c, 0x1f, 0xb6, 0x52,
21  0xa2, 0xca, 0x22, 0x94, 0x44, 0x63, 0x2a, 0xa2,
22  0xfc, 0x67, 0x8e, 0x10, 0x29, 0x75, 0x85, 0x71,
23  0x24, 0x45, 0xa2, 0xcf, 0x2f, 0x22, 0xc1, 0x0e,
24  0xa1, 0xf1, 0x71, 0x40, 0x91, 0x27, 0x18, 0xa5,
25  0x56, 0xf4, 0xaf, 0x32, 0xd2, 0xa4, 0xdc, 0x71,
26  };
27 
28  word64 result=0;
29  GF256 gf256(0xf5);
30  for (unsigned int i=0; i<8; i++)
31  for(unsigned int j=0; j<8; j++)
32  result ^= word64(gf256.Multiply(iG[i][j], GF256::Element(a>>(56-8*j)))) << (56-8*i);
33  return result;
34 }
35 
36 void SHARK::Base::UncheckedSetKey(const byte *key, unsigned int keyLen, const NameValuePairs &params)
37 {
38  AssertValidKeyLength(keyLen);
39 
40  m_rounds = GetRoundsAndThrowIfInvalid(params, this);
41  m_roundKeys.New(m_rounds+1);
42 
43  // concatenate key enought times to fill a
44  for (unsigned int i=0; i<(m_rounds+1)*8; i++)
45  ((byte *)m_roundKeys.begin())[i] = key[i%keyLen];
46 
48  e.InitForKeySetup();
49  byte IV[8] = {0,0,0,0,0,0,0,0};
51 
52  cfb.ProcessString((byte *)m_roundKeys.begin(), (m_rounds+1)*8);
53 
54  ConditionalByteReverse(BIG_ENDIAN_ORDER, m_roundKeys.begin(), m_roundKeys.begin(), (m_rounds+1)*8);
55 
56  m_roundKeys[m_rounds] = SHARKTransform(m_roundKeys[m_rounds]);
57 
58  if (!IsForwardTransformation())
59  {
60  unsigned int i;
61 
62  // transform encryption round keys into decryption round keys
63  for (i=0; i<m_rounds/2; i++)
64  std::swap(m_roundKeys[i], m_roundKeys[m_rounds-i]);
65 
66  for (i=1; i<m_rounds; i++)
67  m_roundKeys[i] = SHARKTransform(m_roundKeys[i]);
68  }
69 
70 #ifdef IS_LITTLE_ENDIAN
71  m_roundKeys[0] = ByteReverse(m_roundKeys[0]);
72  m_roundKeys[m_rounds] = ByteReverse(m_roundKeys[m_rounds]);
73 #endif
74 }
75 
76 // construct an SHARK_Enc object with fixed round keys, to be used to initialize actual round keys
77 void SHARK::Enc::InitForKeySetup()
78 {
79  m_rounds = DEFAULT_ROUNDS;
80  m_roundKeys.New(DEFAULT_ROUNDS+1);
81 
82  for (unsigned int i=0; i<DEFAULT_ROUNDS; i++)
83  m_roundKeys[i] = cbox[0][i];
84 
85  m_roundKeys[DEFAULT_ROUNDS] = SHARKTransform(cbox[0][DEFAULT_ROUNDS]);
86 
87 #ifdef IS_LITTLE_ENDIAN
88  m_roundKeys[0] = ByteReverse(m_roundKeys[0]);
89  m_roundKeys[m_rounds] = ByteReverse(m_roundKeys[m_rounds]);
90 #endif
91 }
92 
93 typedef word64 ArrayOf256Word64s[256];
94 
95 template <const byte *sbox, const ArrayOf256Word64s *cbox>
96 struct SharkProcessAndXorBlock{ // VC60 workaround: problem with template functions
97 inline SharkProcessAndXorBlock(const word64 *roundKeys, unsigned int rounds, const byte *inBlock, const byte *xorBlock, byte *outBlock)
98 {
99  assert(IsAlignedOn(inBlock,GetAlignmentOf<word64>()));
100  word64 tmp = *(word64 *)(void *)inBlock ^ roundKeys[0];
101 
102  ByteOrder order = GetNativeByteOrder();
103  tmp = cbox[0][GetByte(order, tmp, 0)] ^ cbox[1][GetByte(order, tmp, 1)]
104  ^ cbox[2][GetByte(order, tmp, 2)] ^ cbox[3][GetByte(order, tmp, 3)]
105  ^ cbox[4][GetByte(order, tmp, 4)] ^ cbox[5][GetByte(order, tmp, 5)]
106  ^ cbox[6][GetByte(order, tmp, 6)] ^ cbox[7][GetByte(order, tmp, 7)]
107  ^ roundKeys[1];
108 
109  for(unsigned int i=2; i<rounds; i++)
110  {
111  tmp = cbox[0][GETBYTE(tmp, 7)] ^ cbox[1][GETBYTE(tmp, 6)]
112  ^ cbox[2][GETBYTE(tmp, 5)] ^ cbox[3][GETBYTE(tmp, 4)]
113  ^ cbox[4][GETBYTE(tmp, 3)] ^ cbox[5][GETBYTE(tmp, 2)]
114  ^ cbox[6][GETBYTE(tmp, 1)] ^ cbox[7][GETBYTE(tmp, 0)]
115  ^ roundKeys[i];
116  }
117 
118  PutBlock<byte, BigEndian>(xorBlock, outBlock)
119  (sbox[GETBYTE(tmp, 7)])
120  (sbox[GETBYTE(tmp, 6)])
121  (sbox[GETBYTE(tmp, 5)])
122  (sbox[GETBYTE(tmp, 4)])
123  (sbox[GETBYTE(tmp, 3)])
124  (sbox[GETBYTE(tmp, 2)])
125  (sbox[GETBYTE(tmp, 1)])
126  (sbox[GETBYTE(tmp, 0)]);
127 
128  assert(IsAlignedOn(outBlock,GetAlignmentOf<word64>()));
129  *(word64 *)(void *)outBlock ^= roundKeys[rounds];
130 }};
131 
132 void SHARK::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
133 {
134  SharkProcessAndXorBlock<sbox, cbox>(m_roundKeys, m_rounds, inBlock, xorBlock, outBlock);
135 }
136 
137 void SHARK::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
138 {
139  SharkProcessAndXorBlock<sbox, cbox>(m_roundKeys, m_rounds, inBlock, xorBlock, outBlock);
140 }
141 
142 NAMESPACE_END
OFB block cipher mode of operation.
Definition: modes.h:302
Utility functions for the Crypto++ library.
ByteOrder
Provides the byte ordering.
Definition: cryptlib.h:123
Class file for modes of operation.
GF(256) with polynomial basis.
Definition: gf256.h:10
bool IsAlignedOn(const void *ptr, unsigned int alignment)
Determines whether ptr is aligned to a minimum value.
Definition: misc.h:811
T ConditionalByteReverse(ByteOrder order, T value)
Reverses bytes in a value depending upon endianess.
Definition: misc.h:1705
byte order is big-endian
Definition: cryptlib.h:127
const char * IV()
ConstByteArrayParameter, also accepts const byte * for backwards compatibility.
Definition: argnames.h:21
ByteOrder GetNativeByteOrder()
Returns NativeByteOrder as an enumerated ByteOrder value.
Definition: misc.h:844
Crypto++ library namespace.
Classes for the SHARK block cipher.
unsigned int GetByte(ByteOrder order, T value, unsigned int index)
Gets a byte from a value.
Definition: misc.h:1550
byte ByteReverse(byte value)
Reverses bytes in a 8-bit value.
Definition: misc.h:1561
Interface for retrieving values given their names.
Definition: cryptlib.h:277