randombit/botan | Build 5111374265 | source/src/lib/block/serpent/serpent.cpp | Coveralls

23

void Serpent::encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const {

25,700✔

24

   using namespace Botan::Serpent_F;

25,700✔

26

   assert_key_material_set();

25,700✔

29

   if(CPUID::has_avx512()) {

19,412✔

40

   if(CPUID::has_avx2()) {

19,412✔

41

      while(blocks >= 8) {

16,782✔

42

         avx2_encrypt_8(in, out);

3,646✔

43

         in += 8 * BLOCK_SIZE;

3,646✔

44

         out += 8 * BLOCK_SIZE;

3,646✔

45

         blocks -= 8;

3,646✔

51

   if(CPUID::has_simd_32()) {

19,412✔

52

      while(blocks >= 4) {

16,780✔

53

         simd_encrypt_4(in, out);

506✔

54

         in += 4 * BLOCK_SIZE;

506✔

55

         out += 4 * BLOCK_SIZE;

506✔

56

         blocks -= 4;

506✔

61

   const Key_Inserter key_xor(m_round_key.data());

19,412✔

63

   BOTAN_PARALLEL_SIMD_FOR(size_t i = 0; i < blocks; ++i) {

37,859✔

64

      uint32_t B0, B1, B2, B3;

18,447✔

65

      load_le(in + 16 * i, B0, B1, B2, B3);

18,447✔

67

      key_xor(0, B0, B1, B2, B3);

18,447✔

68

      SBoxE0(B0, B1, B2, B3);

18,447✔

69

      transform(B0, B1, B2, B3);

18,447✔

70

      key_xor(1, B0, B1, B2, B3);

18,447✔

71

      SBoxE1(B0, B1, B2, B3);

18,447✔

72

      transform(B0, B1, B2, B3);

18,447✔

73

      key_xor(2, B0, B1, B2, B3);

18,447✔

74

      SBoxE2(B0, B1, B2, B3);

18,447✔

75

      transform(B0, B1, B2, B3);

18,447✔

76

      key_xor(3, B0, B1, B2, B3);

18,447✔

77

      SBoxE3(B0, B1, B2, B3);

18,447✔

78

      transform(B0, B1, B2, B3);

18,447✔

79

      key_xor(4, B0, B1, B2, B3);

18,447✔

80

      SBoxE4(B0, B1, B2, B3);

18,447✔

81

      transform(B0, B1, B2, B3);

18,447✔

82

      key_xor(5, B0, B1, B2, B3);

18,447✔

83

      SBoxE5(B0, B1, B2, B3);

18,447✔

84

      transform(B0, B1, B2, B3);

18,447✔

85

      key_xor(6, B0, B1, B2, B3);

18,447✔

86

      SBoxE6(B0, B1, B2, B3);

18,447✔

87

      transform(B0, B1, B2, B3);

18,447✔

88

      key_xor(7, B0, B1, B2, B3);

18,447✔

89

      SBoxE7(B0, B1, B2, B3);

18,447✔

90

      transform(B0, B1, B2, B3);

18,447✔

91

      key_xor(8, B0, B1, B2, B3);

18,447✔

92

      SBoxE0(B0, B1, B2, B3);

18,447✔

93

      transform(B0, B1, B2, B3);

18,447✔

94

      key_xor(9, B0, B1, B2, B3);

18,447✔

95

      SBoxE1(B0, B1, B2, B3);

18,447✔

96

      transform(B0, B1, B2, B3);

18,447✔

97

      key_xor(10, B0, B1, B2, B3);

18,447✔

98

      SBoxE2(B0, B1, B2, B3);

18,447✔

99

      transform(B0, B1, B2, B3);

18,447✔

100

      key_xor(11, B0, B1, B2, B3);

18,447✔

101

      SBoxE3(B0, B1, B2, B3);

18,447✔

102

      transform(B0, B1, B2, B3);

18,447✔

103

      key_xor(12, B0, B1, B2, B3);

18,447✔

104

      SBoxE4(B0, B1, B2, B3);

18,447✔

105

      transform(B0, B1, B2, B3);

18,447✔

106

      key_xor(13, B0, B1, B2, B3);

18,447✔

107

      SBoxE5(B0, B1, B2, B3);

18,447✔

108

      transform(B0, B1, B2, B3);

18,447✔

109

      key_xor(14, B0, B1, B2, B3);

18,447✔

110

      SBoxE6(B0, B1, B2, B3);

18,447✔

111

      transform(B0, B1, B2, B3);

18,447✔

112

      key_xor(15, B0, B1, B2, B3);

18,447✔

113

      SBoxE7(B0, B1, B2, B3);

18,447✔

114

      transform(B0, B1, B2, B3);

18,447✔

115

      key_xor(16, B0, B1, B2, B3);

18,447✔

116

      SBoxE0(B0, B1, B2, B3);

18,447✔

117

      transform(B0, B1, B2, B3);

18,447✔

118

      key_xor(17, B0, B1, B2, B3);

18,447✔

119

      SBoxE1(B0, B1, B2, B3);

18,447✔

120

      transform(B0, B1, B2, B3);

18,447✔

121

      key_xor(18, B0, B1, B2, B3);

18,447✔

122

      SBoxE2(B0, B1, B2, B3);

18,447✔

123

      transform(B0, B1, B2, B3);

18,447✔

124

      key_xor(19, B0, B1, B2, B3);

18,447✔

125

      SBoxE3(B0, B1, B2, B3);

18,447✔

126

      transform(B0, B1, B2, B3);

18,447✔

127

      key_xor(20, B0, B1, B2, B3);

18,447✔

128

      SBoxE4(B0, B1, B2, B3);

18,447✔

129

      transform(B0, B1, B2, B3);

18,447✔

130

      key_xor(21, B0, B1, B2, B3);

18,447✔

131

      SBoxE5(B0, B1, B2, B3);

18,447✔

132

      transform(B0, B1, B2, B3);

18,447✔

133

      key_xor(22, B0, B1, B2, B3);

18,447✔

134

      SBoxE6(B0, B1, B2, B3);

18,447✔

135

      transform(B0, B1, B2, B3);

18,447✔

136

      key_xor(23, B0, B1, B2, B3);

18,447✔

137

      SBoxE7(B0, B1, B2, B3);

18,447✔

138

      transform(B0, B1, B2, B3);

18,447✔

139

      key_xor(24, B0, B1, B2, B3);

18,447✔

140

      SBoxE0(B0, B1, B2, B3);

18,447✔

141

      transform(B0, B1, B2, B3);

18,447✔

142

      key_xor(25, B0, B1, B2, B3);

18,447✔

143

      SBoxE1(B0, B1, B2, B3);

18,447✔

144

      transform(B0, B1, B2, B3);

18,447✔

145

      key_xor(26, B0, B1, B2, B3);

18,447✔

146

      SBoxE2(B0, B1, B2, B3);

18,447✔

147

      transform(B0, B1, B2, B3);

18,447✔

148

      key_xor(27, B0, B1, B2, B3);

18,447✔

149

      SBoxE3(B0, B1, B2, B3);

18,447✔

150

      transform(B0, B1, B2, B3);

18,447✔

151

      key_xor(28, B0, B1, B2, B3);

18,447✔

152

      SBoxE4(B0, B1, B2, B3);

18,447✔

153

      transform(B0, B1, B2, B3);

18,447✔

154

      key_xor(29, B0, B1, B2, B3);

18,447✔

155

      SBoxE5(B0, B1, B2, B3);

18,447✔

156

      transform(B0, B1, B2, B3);

18,447✔

157

      key_xor(30, B0, B1, B2, B3);

18,447✔

158

      SBoxE6(B0, B1, B2, B3);

18,447✔

159

      transform(B0, B1, B2, B3);

18,447✔

160

      key_xor(31, B0, B1, B2, B3);

18,447✔

161

      SBoxE7(B0, B1, B2, B3);

18,447✔

162

      key_xor(32, B0, B1, B2, B3);

18,447✔

164

      store_le(out + 16 * i, B0, B1, B2, B3);

18,447✔

166

19,412✔

171

void Serpent::decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const {

17,723✔

172

   using namespace Botan::Serpent_F;

17,723✔

174

   assert_key_material_set();

17,723✔

177

   if(CPUID::has_avx512()) {

11,447✔

188

   if(CPUID::has_avx2()) {

11,447✔

189

      while(blocks >= 8) {

7,799✔

190

         avx2_decrypt_8(in, out);

536✔

191

         in += 8 * BLOCK_SIZE;

536✔

192

         out += 8 * BLOCK_SIZE;

536✔

193

         blocks -= 8;

536✔

199

   if(CPUID::has_simd_32()) {

11,447✔

200

      while(blocks >= 4) {

9,861✔

201

         simd_decrypt_4(in, out);

506✔

202

         in += 4 * BLOCK_SIZE;

506✔

203

         out += 4 * BLOCK_SIZE;

506✔

204

         blocks -= 4;

506✔

209

   const Key_Inserter key_xor(m_round_key.data());

11,447✔

211

   BOTAN_PARALLEL_SIMD_FOR(size_t i = 0; i < blocks; ++i) {

23,484✔

212

      uint32_t B0, B1, B2, B3;

12,037✔

213

      load_le(in + 16 * i, B0, B1, B2, B3);

12,037✔

215

      key_xor(32, B0, B1, B2, B3);

12,037✔

216

      SBoxD7(B0, B1, B2, B3);

12,037✔

217

      key_xor(31, B0, B1, B2, B3);

12,037✔

218

      i_transform(B0, B1, B2, B3);

12,037✔

219

      SBoxD6(B0, B1, B2, B3);

12,037✔

220

      key_xor(30, B0, B1, B2, B3);

12,037✔

221

      i_transform(B0, B1, B2, B3);

12,037✔

222

      SBoxD5(B0, B1, B2, B3);

12,037✔

223

      key_xor(29, B0, B1, B2, B3);

12,037✔

224

      i_transform(B0, B1, B2, B3);

12,037✔

225

      SBoxD4(B0, B1, B2, B3);

12,037✔

226

      key_xor(28, B0, B1, B2, B3);

12,037✔

227

      i_transform(B0, B1, B2, B3);

12,037✔

228

      SBoxD3(B0, B1, B2, B3);

12,037✔

229

      key_xor(27, B0, B1, B2, B3);

12,037✔

230

      i_transform(B0, B1, B2, B3);

12,037✔

231

      SBoxD2(B0, B1, B2, B3);

12,037✔

232

      key_xor(26, B0, B1, B2, B3);

12,037✔

233

      i_transform(B0, B1, B2, B3);

12,037✔

234

      SBoxD1(B0, B1, B2, B3);

12,037✔

235

      key_xor(25, B0, B1, B2, B3);

12,037✔

236

      i_transform(B0, B1, B2, B3);

12,037✔

237

      SBoxD0(B0, B1, B2, B3);

12,037✔

238

      key_xor(24, B0, B1, B2, B3);

12,037✔

239

      i_transform(B0, B1, B2, B3);

12,037✔

240

      SBoxD7(B0, B1, B2, B3);

12,037✔

241

      key_xor(23, B0, B1, B2, B3);

12,037✔

242

      i_transform(B0, B1, B2, B3);

12,037✔

243

      SBoxD6(B0, B1, B2, B3);

12,037✔

244

      key_xor(22, B0, B1, B2, B3);

12,037✔

245

      i_transform(B0, B1, B2, B3);

12,037✔

246

      SBoxD5(B0, B1, B2, B3);

12,037✔

247

      key_xor(21, B0, B1, B2, B3);

12,037✔

248

      i_transform(B0, B1, B2, B3);

12,037✔

249

      SBoxD4(B0, B1, B2, B3);

12,037✔

250

      key_xor(20, B0, B1, B2, B3);

12,037✔

251

      i_transform(B0, B1, B2, B3);

12,037✔

252

      SBoxD3(B0, B1, B2, B3);

12,037✔

253

      key_xor(19, B0, B1, B2, B3);

12,037✔

254

      i_transform(B0, B1, B2, B3);

12,037✔

255

      SBoxD2(B0, B1, B2, B3);

12,037✔

256

      key_xor(18, B0, B1, B2, B3);

12,037✔

257

      i_transform(B0, B1, B2, B3);

12,037✔

258

      SBoxD1(B0, B1, B2, B3);

12,037✔

259

      key_xor(17, B0, B1, B2, B3);

12,037✔

260

      i_transform(B0, B1, B2, B3);

12,037✔

261

      SBoxD0(B0, B1, B2, B3);

12,037✔

262

      key_xor(16, B0, B1, B2, B3);

12,037✔

263

      i_transform(B0, B1, B2, B3);

12,037✔

264

      SBoxD7(B0, B1, B2, B3);

12,037✔

265

      key_xor(15, B0, B1, B2, B3);

12,037✔

266

      i_transform(B0, B1, B2, B3);

12,037✔

267

      SBoxD6(B0, B1, B2, B3);

12,037✔

268

      key_xor(14, B0, B1, B2, B3);

12,037✔

269

      i_transform(B0, B1, B2, B3);

12,037✔

270

      SBoxD5(B0, B1, B2, B3);

12,037✔

271

      key_xor(13, B0, B1, B2, B3);

12,037✔

272

      i_transform(B0, B1, B2, B3);

12,037✔

273

      SBoxD4(B0, B1, B2, B3);

12,037✔

274

      key_xor(12, B0, B1, B2, B3);

12,037✔

275

      i_transform(B0, B1, B2, B3);

12,037✔

276

      SBoxD3(B0, B1, B2, B3);

12,037✔

277

      key_xor(11, B0, B1, B2, B3);

12,037✔

278

      i_transform(B0, B1, B2, B3);

12,037✔

279

      SBoxD2(B0, B1, B2, B3);

12,037✔

280

      key_xor(10, B0, B1, B2, B3);

12,037✔

281

      i_transform(B0, B1, B2, B3);

12,037✔

282

      SBoxD1(B0, B1, B2, B3);

12,037✔

283

      key_xor(9, B0, B1, B2, B3);

12,037✔

284

      i_transform(B0, B1, B2, B3);

12,037✔

285

      SBoxD0(B0, B1, B2, B3);

12,037✔

286

      key_xor(8, B0, B1, B2, B3);

12,037✔

287

      i_transform(B0, B1, B2, B3);

12,037✔

288

      SBoxD7(B0, B1, B2, B3);

12,037✔

289

      key_xor(7, B0, B1, B2, B3);

12,037✔

290

      i_transform(B0, B1, B2, B3);

12,037✔

291

      SBoxD6(B0, B1, B2, B3);

12,037✔

292

      key_xor(6, B0, B1, B2, B3);

12,037✔

293

      i_transform(B0, B1, B2, B3);

12,037✔

294

      SBoxD5(B0, B1, B2, B3);

12,037✔

295

      key_xor(5, B0, B1, B2, B3);

12,037✔

296

      i_transform(B0, B1, B2, B3);

12,037✔

297

      SBoxD4(B0, B1, B2, B3);

12,037✔

298

      key_xor(4, B0, B1, B2, B3);

12,037✔

299

      i_transform(B0, B1, B2, B3);

12,037✔

300

      SBoxD3(B0, B1, B2, B3);

12,037✔

301

      key_xor(3, B0, B1, B2, B3);

12,037✔

302

      i_transform(B0, B1, B2, B3);

12,037✔

303

      SBoxD2(B0, B1, B2, B3);

12,037✔

304

      key_xor(2, B0, B1, B2, B3);

12,037✔

305

      i_transform(B0, B1, B2, B3);

12,037✔

306

      SBoxD1(B0, B1, B2, B3);

12,037✔

307

      key_xor(1, B0, B1, B2, B3);

12,037✔

308

      i_transform(B0, B1, B2, B3);

12,037✔

309

      SBoxD0(B0, B1, B2, B3);

12,037✔

310

      key_xor(0, B0, B1, B2, B3);

12,037✔

312

      store_le(out + 16 * i, B0, B1, B2, B3);

12,037✔

314

11,447✔

316

bool Serpent::has_keying_material() const { return !m_round_key.empty(); }

61,689✔

321

void Serpent::key_schedule(const uint8_t key[], size_t length) {

12,899✔

322

   using namespace Botan::Serpent_F;

12,899✔

324

   const uint32_t PHI = 0x9E3779B9;

12,899✔

326

   secure_vector<uint32_t> W(140);

12,899✔

327

   for(size_t i = 0; i != length / 4; ++i)

110,913✔

328

      W[i] = load_le<uint32_t>(key, i);

98,014✔

330

   W[length / 4] |= uint32_t(1) << ((length % 4) * 8);

12,899✔

332

   for(size_t i = 8; i != 140; ++i) {

1,715,567✔

333

      uint32_t wi = W[i - 8] ^ W[i - 5] ^ W[i - 3] ^ W[i - 1] ^ PHI ^ uint32_t(i - 8);

1,702,668✔

334

      W[i] = rotl<11>(wi);

1,702,668✔

337

   SBoxE0(W[20], W[21], W[22], W[23]);

12,899✔

338

   SBoxE0(W[52], W[53], W[54], W[55]);

12,899✔

339

   SBoxE0(W[84], W[85], W[86], W[87]);

12,899✔

340

   SBoxE0(W[116], W[117], W[118], W[119]);

12,899✔

342

   SBoxE1(W[16], W[17], W[18], W[19]);

12,899✔

343

   SBoxE1(W[48], W[49], W[50], W[51]);

12,899✔

344

   SBoxE1(W[80], W[81], W[82], W[83]);

12,899✔

345

   SBoxE1(W[112], W[113], W[114], W[115]);

12,899✔

347

   SBoxE2(W[12], W[13], W[14], W[15]);

12,899✔

348

   SBoxE2(W[44], W[45], W[46], W[47]);

12,899✔

349

   SBoxE2(W[76], W[77], W[78], W[79]);

12,899✔

350

   SBoxE2(W[108], W[109], W[110], W[111]);

12,899✔

352

   SBoxE3(W[8], W[9], W[10], W[11]);

12,899✔

353

   SBoxE3(W[40], W[41], W[42], W[43]);

12,899✔

354

   SBoxE3(W[72], W[73], W[74], W[75]);

12,899✔

355

   SBoxE3(W[104], W[105], W[106], W[107]);

12,899✔

356

   SBoxE3(W[136], W[137], W[138], W[139]);

12,899✔

358

   SBoxE4(W[36], W[37], W[38], W[39]);

12,899✔

359

   SBoxE4(W[68], W[69], W[70], W[71]);

12,899✔

360

   SBoxE4(W[100], W[101], W[102], W[103]);

12,899✔

361

   SBoxE4(W[132], W[133], W[134], W[135]);

12,899✔

363

   SBoxE5(W[32], W[33], W[34], W[35]);

12,899✔

364

   SBoxE5(W[64], W[65], W[66], W[67]);

12,899✔

365

   SBoxE5(W[96], W[97], W[98], W[99]);

12,899✔

366

   SBoxE5(W[128], W[129], W[130], W[131]);

12,899✔

368

   SBoxE6(W[28], W[29], W[30], W[31]);

12,899✔

369

   SBoxE6(W[60], W[61], W[62], W[63]);

12,899✔

370

   SBoxE6(W[92], W[93], W[94], W[95]);

12,899✔

371

   SBoxE6(W[124], W[125], W[126], W[127]);

12,899✔

373

   SBoxE7(W[24], W[25], W[26], W[27]);

12,899✔

374

   SBoxE7(W[56], W[57], W[58], W[59]);

12,899✔

375

   SBoxE7(W[88], W[89], W[90], W[91]);

12,899✔

376

   SBoxE7(W[120], W[121], W[122], W[123]);

12,899✔

378

   m_round_key.assign(W.begin() + 8, W.end());

12,899✔

379

12,899✔

381

void Serpent::clear() { zap(m_round_key); }

7,431✔

383

std::string Serpent::provider() const {

3,138✔

385

   if(CPUID::has_avx512()) {

3,138✔

391

   if(CPUID::has_avx2()) {

3,138✔

392

      return "avx2";

1,046✔

397

   if(CPUID::has_simd_32()) {

2,092✔

398

      return "simd";

1,046✔

402

   return "base";

1,046✔

randombit / botan / 5111374265

Source File
Press 'n' to go to next uncovered line, 'b' for previous

1	/*
2	* Serpent
3	* (C) 1999-2007 Jack Lloyd
4	*
5	* Botan is released under the Simplified BSD License (see license.txt)
6	*/
7
8	#include <botan/internal/serpent.h>
9
10	#include <botan/internal/loadstor.h>
11	#include <botan/internal/rotate.h>
12	#include <botan/internal/serpent_sbox.h>
13
14	#if defined(BOTAN_HAS_SERPENT_SIMD) \|\| defined(BOTAN_HAS_SERPENT_AVX2) \|\| defined(BOTAN_HAS_SERPENT_AVX512)
15	#include <botan/internal/cpuid.h>
16	#endif
17
18	namespace Botan {
19
20	/*
21	* Serpent Encryption
22	*/
23	void Serpent::encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const {	25,700✔
24	using namespace Botan::Serpent_F;	25,700✔
25
26	assert_key_material_set();	25,700✔
27
28	#if defined(BOTAN_HAS_SERPENT_AVX512)
29	if(CPUID::has_avx512()) {	19,412✔
30	while(blocks >= 16) {	×
31	avx512_encrypt_16(in, out);	×
32	in += 16 * BLOCK_SIZE;	×
33	out += 16 * BLOCK_SIZE;	×
34	blocks -= 16;	×
35	}
36	}
37	#endif
38
39	#if defined(BOTAN_HAS_SERPENT_AVX2)
40	if(CPUID::has_avx2()) {	19,412✔
41	while(blocks >= 8) {	16,782✔
42	avx2_encrypt_8(in, out);	3,646✔
43	in += 8 * BLOCK_SIZE;	3,646✔
44	out += 8 * BLOCK_SIZE;	3,646✔
45	blocks -= 8;	3,646✔
46	}
47	}
48	#endif
49
50	#if defined(BOTAN_HAS_SERPENT_SIMD)
51	if(CPUID::has_simd_32()) {	19,412✔
52	while(blocks >= 4) {	16,780✔
53	simd_encrypt_4(in, out);	506✔
54	in += 4 * BLOCK_SIZE;	506✔
55	out += 4 * BLOCK_SIZE;	506✔
56	blocks -= 4;	506✔
57	}
58	}
59	#endif
60
61	const Key_Inserter key_xor(m_round_key.data());	19,412✔
62
63	BOTAN_PARALLEL_SIMD_FOR(size_t i = 0; i < blocks; ++i) {	37,859✔
64	uint32_t B0, B1, B2, B3;	18,447✔
65	load_le(in + 16 * i, B0, B1, B2, B3);	18,447✔
66
67	key_xor(0, B0, B1, B2, B3);	18,447✔
68	SBoxE0(B0, B1, B2, B3);	18,447✔
69	transform(B0, B1, B2, B3);	18,447✔
70	key_xor(1, B0, B1, B2, B3);	18,447✔
71	SBoxE1(B0, B1, B2, B3);	18,447✔
72	transform(B0, B1, B2, B3);	18,447✔
73	key_xor(2, B0, B1, B2, B3);	18,447✔
74	SBoxE2(B0, B1, B2, B3);	18,447✔
75	transform(B0, B1, B2, B3);	18,447✔
76	key_xor(3, B0, B1, B2, B3);	18,447✔
77	SBoxE3(B0, B1, B2, B3);	18,447✔
78	transform(B0, B1, B2, B3);	18,447✔
79	key_xor(4, B0, B1, B2, B3);	18,447✔
80	SBoxE4(B0, B1, B2, B3);	18,447✔
81	transform(B0, B1, B2, B3);	18,447✔
82	key_xor(5, B0, B1, B2, B3);	18,447✔
83	SBoxE5(B0, B1, B2, B3);	18,447✔
84	transform(B0, B1, B2, B3);	18,447✔
85	key_xor(6, B0, B1, B2, B3);	18,447✔
86	SBoxE6(B0, B1, B2, B3);	18,447✔
87	transform(B0, B1, B2, B3);	18,447✔
88	key_xor(7, B0, B1, B2, B3);	18,447✔
89	SBoxE7(B0, B1, B2, B3);	18,447✔
90	transform(B0, B1, B2, B3);	18,447✔
91	key_xor(8, B0, B1, B2, B3);	18,447✔
92	SBoxE0(B0, B1, B2, B3);	18,447✔
93	transform(B0, B1, B2, B3);	18,447✔
94	key_xor(9, B0, B1, B2, B3);	18,447✔
95	SBoxE1(B0, B1, B2, B3);	18,447✔
96	transform(B0, B1, B2, B3);	18,447✔
97	key_xor(10, B0, B1, B2, B3);	18,447✔
98	SBoxE2(B0, B1, B2, B3);	18,447✔
99	transform(B0, B1, B2, B3);	18,447✔
100	key_xor(11, B0, B1, B2, B3);	18,447✔
101	SBoxE3(B0, B1, B2, B3);	18,447✔
102	transform(B0, B1, B2, B3);	18,447✔
103	key_xor(12, B0, B1, B2, B3);	18,447✔
104	SBoxE4(B0, B1, B2, B3);	18,447✔
105	transform(B0, B1, B2, B3);	18,447✔
106	key_xor(13, B0, B1, B2, B3);	18,447✔
107	SBoxE5(B0, B1, B2, B3);	18,447✔
108	transform(B0, B1, B2, B3);	18,447✔
109	key_xor(14, B0, B1, B2, B3);	18,447✔
110	SBoxE6(B0, B1, B2, B3);	18,447✔
111	transform(B0, B1, B2, B3);	18,447✔
112	key_xor(15, B0, B1, B2, B3);	18,447✔
113	SBoxE7(B0, B1, B2, B3);	18,447✔
114	transform(B0, B1, B2, B3);	18,447✔
115	key_xor(16, B0, B1, B2, B3);	18,447✔
116	SBoxE0(B0, B1, B2, B3);	18,447✔
117	transform(B0, B1, B2, B3);	18,447✔
118	key_xor(17, B0, B1, B2, B3);	18,447✔
119	SBoxE1(B0, B1, B2, B3);	18,447✔
120	transform(B0, B1, B2, B3);	18,447✔
121	key_xor(18, B0, B1, B2, B3);	18,447✔
122	SBoxE2(B0, B1, B2, B3);	18,447✔
123	transform(B0, B1, B2, B3);	18,447✔
124	key_xor(19, B0, B1, B2, B3);	18,447✔
125	SBoxE3(B0, B1, B2, B3);	18,447✔
126	transform(B0, B1, B2, B3);	18,447✔
127	key_xor(20, B0, B1, B2, B3);	18,447✔
128	SBoxE4(B0, B1, B2, B3);	18,447✔
129	transform(B0, B1, B2, B3);	18,447✔
130	key_xor(21, B0, B1, B2, B3);	18,447✔
131	SBoxE5(B0, B1, B2, B3);	18,447✔
132	transform(B0, B1, B2, B3);	18,447✔
133	key_xor(22, B0, B1, B2, B3);	18,447✔
134	SBoxE6(B0, B1, B2, B3);	18,447✔
135	transform(B0, B1, B2, B3);	18,447✔
136	key_xor(23, B0, B1, B2, B3);	18,447✔
137	SBoxE7(B0, B1, B2, B3);	18,447✔
138	transform(B0, B1, B2, B3);	18,447✔
139	key_xor(24, B0, B1, B2, B3);	18,447✔
140	SBoxE0(B0, B1, B2, B3);	18,447✔
141	transform(B0, B1, B2, B3);	18,447✔
142	key_xor(25, B0, B1, B2, B3);	18,447✔
143	SBoxE1(B0, B1, B2, B3);	18,447✔
144	transform(B0, B1, B2, B3);	18,447✔
145	key_xor(26, B0, B1, B2, B3);	18,447✔
146	SBoxE2(B0, B1, B2, B3);	18,447✔
147	transform(B0, B1, B2, B3);	18,447✔
148	key_xor(27, B0, B1, B2, B3);	18,447✔
149	SBoxE3(B0, B1, B2, B3);	18,447✔
150	transform(B0, B1, B2, B3);	18,447✔
151	key_xor(28, B0, B1, B2, B3);	18,447✔
152	SBoxE4(B0, B1, B2, B3);	18,447✔
153	transform(B0, B1, B2, B3);	18,447✔
154	key_xor(29, B0, B1, B2, B3);	18,447✔
155	SBoxE5(B0, B1, B2, B3);	18,447✔
156	transform(B0, B1, B2, B3);	18,447✔
157	key_xor(30, B0, B1, B2, B3);	18,447✔
158	SBoxE6(B0, B1, B2, B3);	18,447✔
159	transform(B0, B1, B2, B3);	18,447✔
160	key_xor(31, B0, B1, B2, B3);	18,447✔
161	SBoxE7(B0, B1, B2, B3);	18,447✔
162	key_xor(32, B0, B1, B2, B3);	18,447✔
163
164	store_le(out + 16 * i, B0, B1, B2, B3);	18,447✔
165	}
166	}	19,412✔
167
168	/*
169	* Serpent Decryption
170	*/
171	void Serpent::decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const {	17,723✔
172	using namespace Botan::Serpent_F;	17,723✔
173
174	assert_key_material_set();	17,723✔
175
176	#if defined(BOTAN_HAS_SERPENT_AVX512)
177	if(CPUID::has_avx512()) {	11,447✔
178	while(blocks >= 16) {	×
179	avx512_decrypt_16(in, out);	×
180	in += 16 * BLOCK_SIZE;	×
181	out += 16 * BLOCK_SIZE;	×
182	blocks -= 16;	×
183	}
184	}
185	#endif
186
187	#if defined(BOTAN_HAS_SERPENT_AVX2)
188	if(CPUID::has_avx2()) {	11,447✔
189	while(blocks >= 8) {	7,799✔
190	avx2_decrypt_8(in, out);	536✔
191	in += 8 * BLOCK_SIZE;	536✔
192	out += 8 * BLOCK_SIZE;	536✔
193	blocks -= 8;	536✔
194	}
195	}
196	#endif
197
198	#if defined(BOTAN_HAS_SERPENT_SIMD)
199	if(CPUID::has_simd_32()) {	11,447✔
200	while(blocks >= 4) {	9,861✔
201	simd_decrypt_4(in, out);	506✔
202	in += 4 * BLOCK_SIZE;	506✔
203	out += 4 * BLOCK_SIZE;	506✔
204	blocks -= 4;	506✔
205	}
206	}
207	#endif
208
209	const Key_Inserter key_xor(m_round_key.data());	11,447✔
210
211	BOTAN_PARALLEL_SIMD_FOR(size_t i = 0; i < blocks; ++i) {	23,484✔
212	uint32_t B0, B1, B2, B3;	12,037✔
213	load_le(in + 16 * i, B0, B1, B2, B3);	12,037✔
214
215	key_xor(32, B0, B1, B2, B3);	12,037✔
216	SBoxD7(B0, B1, B2, B3);	12,037✔
217	key_xor(31, B0, B1, B2, B3);	12,037✔
218	i_transform(B0, B1, B2, B3);	12,037✔
219	SBoxD6(B0, B1, B2, B3);	12,037✔
220	key_xor(30, B0, B1, B2, B3);	12,037✔
221	i_transform(B0, B1, B2, B3);	12,037✔
222	SBoxD5(B0, B1, B2, B3);	12,037✔
223	key_xor(29, B0, B1, B2, B3);	12,037✔
224	i_transform(B0, B1, B2, B3);	12,037✔
225	SBoxD4(B0, B1, B2, B3);	12,037✔
226	key_xor(28, B0, B1, B2, B3);	12,037✔
227	i_transform(B0, B1, B2, B3);	12,037✔
228	SBoxD3(B0, B1, B2, B3);	12,037✔
229	key_xor(27, B0, B1, B2, B3);	12,037✔
230	i_transform(B0, B1, B2, B3);	12,037✔
231	SBoxD2(B0, B1, B2, B3);	12,037✔
232	key_xor(26, B0, B1, B2, B3);	12,037✔
233	i_transform(B0, B1, B2, B3);	12,037✔
234	SBoxD1(B0, B1, B2, B3);	12,037✔
235	key_xor(25, B0, B1, B2, B3);	12,037✔
236	i_transform(B0, B1, B2, B3);	12,037✔
237	SBoxD0(B0, B1, B2, B3);	12,037✔
238	key_xor(24, B0, B1, B2, B3);	12,037✔
239	i_transform(B0, B1, B2, B3);	12,037✔
240	SBoxD7(B0, B1, B2, B3);	12,037✔
241	key_xor(23, B0, B1, B2, B3);	12,037✔
242	i_transform(B0, B1, B2, B3);	12,037✔
243	SBoxD6(B0, B1, B2, B3);	12,037✔
244	key_xor(22, B0, B1, B2, B3);	12,037✔
245	i_transform(B0, B1, B2, B3);	12,037✔
246	SBoxD5(B0, B1, B2, B3);	12,037✔
247	key_xor(21, B0, B1, B2, B3);	12,037✔
248	i_transform(B0, B1, B2, B3);	12,037✔
249	SBoxD4(B0, B1, B2, B3);	12,037✔
250	key_xor(20, B0, B1, B2, B3);	12,037✔
251	i_transform(B0, B1, B2, B3);	12,037✔
252	SBoxD3(B0, B1, B2, B3);	12,037✔
253	key_xor(19, B0, B1, B2, B3);	12,037✔
254	i_transform(B0, B1, B2, B3);	12,037✔
255	SBoxD2(B0, B1, B2, B3);	12,037✔
256	key_xor(18, B0, B1, B2, B3);	12,037✔
257	i_transform(B0, B1, B2, B3);	12,037✔
258	SBoxD1(B0, B1, B2, B3);	12,037✔
259	key_xor(17, B0, B1, B2, B3);	12,037✔
260	i_transform(B0, B1, B2, B3);	12,037✔
261	SBoxD0(B0, B1, B2, B3);	12,037✔
262	key_xor(16, B0, B1, B2, B3);	12,037✔
263	i_transform(B0, B1, B2, B3);	12,037✔
264	SBoxD7(B0, B1, B2, B3);	12,037✔
265	key_xor(15, B0, B1, B2, B3);	12,037✔
266	i_transform(B0, B1, B2, B3);	12,037✔
267	SBoxD6(B0, B1, B2, B3);	12,037✔
268	key_xor(14, B0, B1, B2, B3);	12,037✔
269	i_transform(B0, B1, B2, B3);	12,037✔
270	SBoxD5(B0, B1, B2, B3);	12,037✔
271	key_xor(13, B0, B1, B2, B3);	12,037✔
272	i_transform(B0, B1, B2, B3);	12,037✔
273	SBoxD4(B0, B1, B2, B3);	12,037✔
274	key_xor(12, B0, B1, B2, B3);	12,037✔
275	i_transform(B0, B1, B2, B3);	12,037✔
276	SBoxD3(B0, B1, B2, B3);	12,037✔
277	key_xor(11, B0, B1, B2, B3);	12,037✔
278	i_transform(B0, B1, B2, B3);	12,037✔
279	SBoxD2(B0, B1, B2, B3);	12,037✔
280	key_xor(10, B0, B1, B2, B3);	12,037✔
281	i_transform(B0, B1, B2, B3);	12,037✔
282	SBoxD1(B0, B1, B2, B3);	12,037✔
283	key_xor(9, B0, B1, B2, B3);	12,037✔
284	i_transform(B0, B1, B2, B3);	12,037✔
285	SBoxD0(B0, B1, B2, B3);	12,037✔
286	key_xor(8, B0, B1, B2, B3);	12,037✔
287	i_transform(B0, B1, B2, B3);	12,037✔
288	SBoxD7(B0, B1, B2, B3);	12,037✔
289	key_xor(7, B0, B1, B2, B3);	12,037✔
290	i_transform(B0, B1, B2, B3);	12,037✔
291	SBoxD6(B0, B1, B2, B3);	12,037✔
292	key_xor(6, B0, B1, B2, B3);	12,037✔
293	i_transform(B0, B1, B2, B3);	12,037✔
294	SBoxD5(B0, B1, B2, B3);	12,037✔
295	key_xor(5, B0, B1, B2, B3);	12,037✔
296	i_transform(B0, B1, B2, B3);	12,037✔
297	SBoxD4(B0, B1, B2, B3);	12,037✔
298	key_xor(4, B0, B1, B2, B3);	12,037✔
299	i_transform(B0, B1, B2, B3);	12,037✔
300	SBoxD3(B0, B1, B2, B3);	12,037✔
301	key_xor(3, B0, B1, B2, B3);	12,037✔
302	i_transform(B0, B1, B2, B3);	12,037✔
303	SBoxD2(B0, B1, B2, B3);	12,037✔
304	key_xor(2, B0, B1, B2, B3);	12,037✔
305	i_transform(B0, B1, B2, B3);	12,037✔
306	SBoxD1(B0, B1, B2, B3);	12,037✔
307	key_xor(1, B0, B1, B2, B3);	12,037✔
308	i_transform(B0, B1, B2, B3);	12,037✔
309	SBoxD0(B0, B1, B2, B3);	12,037✔
310	key_xor(0, B0, B1, B2, B3);	12,037✔
311
312	store_le(out + 16 * i, B0, B1, B2, B3);	12,037✔
313	}
314	}	11,447✔
315
316	bool Serpent::has_keying_material() const { return !m_round_key.empty(); }	61,689✔
317
318	/*
319	* Serpent Key Schedule
320	*/
321	void Serpent::key_schedule(const uint8_t key[], size_t length) {	12,899✔
322	using namespace Botan::Serpent_F;	12,899✔
323
324	const uint32_t PHI = 0x9E3779B9;	12,899✔
325
326	secure_vector<uint32_t> W(140);	12,899✔
327	for(size_t i = 0; i != length / 4; ++i)	110,913✔
328	W[i] = load_le<uint32_t>(key, i);	98,014✔
329
330	W[length / 4] \|= uint32_t(1) << ((length % 4) * 8);	12,899✔
331
332	for(size_t i = 8; i != 140; ++i) {	1,715,567✔
333	uint32_t wi = W[i - 8] ^ W[i - 5] ^ W[i - 3] ^ W[i - 1] ^ PHI ^ uint32_t(i - 8);	1,702,668✔
334	W[i] = rotl<11>(wi);	1,702,668✔
335	}
336
337	SBoxE0(W[20], W[21], W[22], W[23]);	12,899✔
338	SBoxE0(W[52], W[53], W[54], W[55]);	12,899✔
339	SBoxE0(W[84], W[85], W[86], W[87]);	12,899✔
340	SBoxE0(W[116], W[117], W[118], W[119]);	12,899✔
341
342	SBoxE1(W[16], W[17], W[18], W[19]);	12,899✔
343	SBoxE1(W[48], W[49], W[50], W[51]);	12,899✔
344	SBoxE1(W[80], W[81], W[82], W[83]);	12,899✔
345	SBoxE1(W[112], W[113], W[114], W[115]);	12,899✔
346
347	SBoxE2(W[12], W[13], W[14], W[15]);	12,899✔
348	SBoxE2(W[44], W[45], W[46], W[47]);	12,899✔
349	SBoxE2(W[76], W[77], W[78], W[79]);	12,899✔
350	SBoxE2(W[108], W[109], W[110], W[111]);	12,899✔
351
352	SBoxE3(W[8], W[9], W[10], W[11]);	12,899✔
353	SBoxE3(W[40], W[41], W[42], W[43]);	12,899✔
354	SBoxE3(W[72], W[73], W[74], W[75]);	12,899✔
355	SBoxE3(W[104], W[105], W[106], W[107]);	12,899✔
356	SBoxE3(W[136], W[137], W[138], W[139]);	12,899✔
357
358	SBoxE4(W[36], W[37], W[38], W[39]);	12,899✔
359	SBoxE4(W[68], W[69], W[70], W[71]);	12,899✔
360	SBoxE4(W[100], W[101], W[102], W[103]);	12,899✔
361	SBoxE4(W[132], W[133], W[134], W[135]);	12,899✔
362
363	SBoxE5(W[32], W[33], W[34], W[35]);	12,899✔
364	SBoxE5(W[64], W[65], W[66], W[67]);	12,899✔
365	SBoxE5(W[96], W[97], W[98], W[99]);	12,899✔
366	SBoxE5(W[128], W[129], W[130], W[131]);	12,899✔
367
368	SBoxE6(W[28], W[29], W[30], W[31]);	12,899✔
369	SBoxE6(W[60], W[61], W[62], W[63]);	12,899✔
370	SBoxE6(W[92], W[93], W[94], W[95]);	12,899✔
371	SBoxE6(W[124], W[125], W[126], W[127]);	12,899✔
372
373	SBoxE7(W[24], W[25], W[26], W[27]);	12,899✔
374	SBoxE7(W[56], W[57], W[58], W[59]);	12,899✔
375	SBoxE7(W[88], W[89], W[90], W[91]);	12,899✔
376	SBoxE7(W[120], W[121], W[122], W[123]);	12,899✔
377
378	m_round_key.assign(W.begin() + 8, W.end());	12,899✔
379	}	12,899✔
380
381	void Serpent::clear() { zap(m_round_key); }	7,431✔
382
383	std::string Serpent::provider() const {	3,138✔
384	#if defined(BOTAN_HAS_SERPENT_AVX512)
385	if(CPUID::has_avx512()) {	3,138✔
386	return "avx512";	×
387	}
388	#endif
389
390	#if defined(BOTAN_HAS_SERPENT_AVX2)
391	if(CPUID::has_avx2()) {	3,138✔
392	return "avx2";	1,046✔
393	}
394	#endif
395
396	#if defined(BOTAN_HAS_SERPENT_SIMD)
397	if(CPUID::has_simd_32()) {	2,092✔
398	return "simd";	1,046✔
399	}
400	#endif
401
402	return "base";	1,046✔
403	}
404
405	} // namespace Botan

randombit / botan / 5111374265

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous