randombit/botan | Build 5230455705 | 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,715✔

24

   using namespace Botan::Serpent_F;

25,715✔

26

   assert_key_material_set();

25,715✔

29

   if(CPUID::has_avx512()) {

19,421✔

40

   if(CPUID::has_avx2()) {

19,421✔

41

      while(blocks >= 8) {

16,793✔

42

         avx2_encrypt_8(in, out);

3,654✔

43

         in += 8 * BLOCK_SIZE;

3,654✔

44

         out += 8 * BLOCK_SIZE;

3,654✔

45

         blocks -= 8;

3,654✔

51

   if(CPUID::has_simd_32()) {

19,421✔

52

      while(blocks >= 4) {

16,802✔

53

         simd_encrypt_4(in, out);

522✔

54

         in += 4 * BLOCK_SIZE;

522✔

55

         out += 4 * BLOCK_SIZE;

522✔

56

         blocks -= 4;

522✔

61

   const Key_Inserter key_xor(m_round_key.data());

19,421✔

63

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

37,935✔

64

      uint32_t B0, B1, B2, B3;

18,514✔

65

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

18,514✔

67

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

18,514✔

68

      SBoxE0(B0, B1, B2, B3);

18,514✔

69

      transform(B0, B1, B2, B3);

18,514✔

70

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

18,514✔

71

      SBoxE1(B0, B1, B2, B3);

18,514✔

72

      transform(B0, B1, B2, B3);

18,514✔

73

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

18,514✔

74

      SBoxE2(B0, B1, B2, B3);

18,514✔

75

      transform(B0, B1, B2, B3);

18,514✔

76

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

18,514✔

77

      SBoxE3(B0, B1, B2, B3);

18,514✔

78

      transform(B0, B1, B2, B3);

18,514✔

79

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

18,514✔

80

      SBoxE4(B0, B1, B2, B3);

18,514✔

81

      transform(B0, B1, B2, B3);

18,514✔

82

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

18,514✔

83

      SBoxE5(B0, B1, B2, B3);

18,514✔

84

      transform(B0, B1, B2, B3);

18,514✔

85

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

18,514✔

86

      SBoxE6(B0, B1, B2, B3);

18,514✔

87

      transform(B0, B1, B2, B3);

18,514✔

88

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

18,514✔

89

      SBoxE7(B0, B1, B2, B3);

18,514✔

90

      transform(B0, B1, B2, B3);

18,514✔

91

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

18,514✔

92

      SBoxE0(B0, B1, B2, B3);

18,514✔

93

      transform(B0, B1, B2, B3);

18,514✔

94

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

18,514✔

95

      SBoxE1(B0, B1, B2, B3);

18,514✔

96

      transform(B0, B1, B2, B3);

18,514✔

97

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

18,514✔

98

      SBoxE2(B0, B1, B2, B3);

18,514✔

99

      transform(B0, B1, B2, B3);

18,514✔

100

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

18,514✔

101

      SBoxE3(B0, B1, B2, B3);

18,514✔

102

      transform(B0, B1, B2, B3);

18,514✔

103

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

18,514✔

104

      SBoxE4(B0, B1, B2, B3);

18,514✔

105

      transform(B0, B1, B2, B3);

18,514✔

106

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

18,514✔

107

      SBoxE5(B0, B1, B2, B3);

18,514✔

108

      transform(B0, B1, B2, B3);

18,514✔

109

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

18,514✔

110

      SBoxE6(B0, B1, B2, B3);

18,514✔

111

      transform(B0, B1, B2, B3);

18,514✔

112

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

18,514✔

113

      SBoxE7(B0, B1, B2, B3);

18,514✔

114

      transform(B0, B1, B2, B3);

18,514✔

115

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

18,514✔

116

      SBoxE0(B0, B1, B2, B3);

18,514✔

117

      transform(B0, B1, B2, B3);

18,514✔

118

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

18,514✔

119

      SBoxE1(B0, B1, B2, B3);

18,514✔

120

      transform(B0, B1, B2, B3);

18,514✔

121

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

18,514✔

122

      SBoxE2(B0, B1, B2, B3);

18,514✔

123

      transform(B0, B1, B2, B3);

18,514✔

124

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

18,514✔

125

      SBoxE3(B0, B1, B2, B3);

18,514✔

126

      transform(B0, B1, B2, B3);

18,514✔

127

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

18,514✔

128

      SBoxE4(B0, B1, B2, B3);

18,514✔

129

      transform(B0, B1, B2, B3);

18,514✔

130

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

18,514✔

131

      SBoxE5(B0, B1, B2, B3);

18,514✔

132

      transform(B0, B1, B2, B3);

18,514✔

133

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

18,514✔

134

      SBoxE6(B0, B1, B2, B3);

18,514✔

135

      transform(B0, B1, B2, B3);

18,514✔

136

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

18,514✔

137

      SBoxE7(B0, B1, B2, B3);

18,514✔

138

      transform(B0, B1, B2, B3);

18,514✔

139

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

18,514✔

140

      SBoxE0(B0, B1, B2, B3);

18,514✔

141

      transform(B0, B1, B2, B3);

18,514✔

142

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

18,514✔

143

      SBoxE1(B0, B1, B2, B3);

18,514✔

144

      transform(B0, B1, B2, B3);

18,514✔

145

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

18,514✔

146

      SBoxE2(B0, B1, B2, B3);

18,514✔

147

      transform(B0, B1, B2, B3);

18,514✔

148

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

18,514✔

149

      SBoxE3(B0, B1, B2, B3);

18,514✔

150

      transform(B0, B1, B2, B3);

18,514✔

151

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

18,514✔

152

      SBoxE4(B0, B1, B2, B3);

18,514✔

153

      transform(B0, B1, B2, B3);

18,514✔

154

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

18,514✔

155

      SBoxE5(B0, B1, B2, B3);

18,514✔

156

      transform(B0, B1, B2, B3);

18,514✔

157

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

18,514✔

158

      SBoxE6(B0, B1, B2, B3);

18,514✔

159

      transform(B0, B1, B2, B3);

18,514✔

160

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

18,514✔

161

      SBoxE7(B0, B1, B2, B3);

18,514✔

162

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

18,514✔

164

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

18,514✔

166

19,421✔

171

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

17,735✔

172

   using namespace Botan::Serpent_F;

17,735✔

174

   assert_key_material_set();

17,735✔

177

   if(CPUID::has_avx512()) {

11,453✔

188

   if(CPUID::has_avx2()) {

11,453✔

189

      while(blocks >= 8) {

7,809✔

190

         avx2_decrypt_8(in, out);

544✔

191

         in += 8 * BLOCK_SIZE;

544✔

192

         out += 8 * BLOCK_SIZE;

544✔

193

         blocks -= 8;

544✔

199

   if(CPUID::has_simd_32()) {

11,453✔

200

      while(blocks >= 4) {

9,881✔

201

         simd_decrypt_4(in, out);

522✔

202

         in += 4 * BLOCK_SIZE;

522✔

203

         out += 4 * BLOCK_SIZE;

522✔

204

         blocks -= 4;

522✔

209

   const Key_Inserter key_xor(m_round_key.data());

11,453✔

211

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

23,554✔

212

      uint32_t B0, B1, B2, B3;

12,101✔

213

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

12,101✔

215

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

12,101✔

216

      SBoxD7(B0, B1, B2, B3);

12,101✔

217

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

12,101✔

218

      i_transform(B0, B1, B2, B3);

12,101✔

219

      SBoxD6(B0, B1, B2, B3);

12,101✔

220

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

12,101✔

221

      i_transform(B0, B1, B2, B3);

12,101✔

222

      SBoxD5(B0, B1, B2, B3);

12,101✔

223

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

12,101✔

224

      i_transform(B0, B1, B2, B3);

12,101✔

225

      SBoxD4(B0, B1, B2, B3);

12,101✔

226

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

12,101✔

227

      i_transform(B0, B1, B2, B3);

12,101✔

228

      SBoxD3(B0, B1, B2, B3);

12,101✔

229

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

12,101✔

230

      i_transform(B0, B1, B2, B3);

12,101✔

231

      SBoxD2(B0, B1, B2, B3);

12,101✔

232

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

12,101✔

233

      i_transform(B0, B1, B2, B3);

12,101✔

234

      SBoxD1(B0, B1, B2, B3);

12,101✔

235

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

12,101✔

236

      i_transform(B0, B1, B2, B3);

12,101✔

237

      SBoxD0(B0, B1, B2, B3);

12,101✔

238

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

12,101✔

239

      i_transform(B0, B1, B2, B3);

12,101✔

240

      SBoxD7(B0, B1, B2, B3);

12,101✔

241

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

12,101✔

242

      i_transform(B0, B1, B2, B3);

12,101✔

243

      SBoxD6(B0, B1, B2, B3);

12,101✔

244

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

12,101✔

245

      i_transform(B0, B1, B2, B3);

12,101✔

246

      SBoxD5(B0, B1, B2, B3);

12,101✔

247

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

12,101✔

248

      i_transform(B0, B1, B2, B3);

12,101✔

249

      SBoxD4(B0, B1, B2, B3);

12,101✔

250

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

12,101✔

251

      i_transform(B0, B1, B2, B3);

12,101✔

252

      SBoxD3(B0, B1, B2, B3);

12,101✔

253

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

12,101✔

254

      i_transform(B0, B1, B2, B3);

12,101✔

255

      SBoxD2(B0, B1, B2, B3);

12,101✔

256

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

12,101✔

257

      i_transform(B0, B1, B2, B3);

12,101✔

258

      SBoxD1(B0, B1, B2, B3);

12,101✔

259

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

12,101✔

260

      i_transform(B0, B1, B2, B3);

12,101✔

261

      SBoxD0(B0, B1, B2, B3);

12,101✔

262

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

12,101✔

263

      i_transform(B0, B1, B2, B3);

12,101✔

264

      SBoxD7(B0, B1, B2, B3);

12,101✔

265

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

12,101✔

266

      i_transform(B0, B1, B2, B3);

12,101✔

267

      SBoxD6(B0, B1, B2, B3);

12,101✔

268

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

12,101✔

269

      i_transform(B0, B1, B2, B3);

12,101✔

270

      SBoxD5(B0, B1, B2, B3);

12,101✔

271

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

12,101✔

272

      i_transform(B0, B1, B2, B3);

12,101✔

273

      SBoxD4(B0, B1, B2, B3);

12,101✔

274

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

12,101✔

275

      i_transform(B0, B1, B2, B3);

12,101✔

276

      SBoxD3(B0, B1, B2, B3);

12,101✔

277

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

12,101✔

278

      i_transform(B0, B1, B2, B3);

12,101✔

279

      SBoxD2(B0, B1, B2, B3);

12,101✔

280

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

12,101✔

281

      i_transform(B0, B1, B2, B3);

12,101✔

282

      SBoxD1(B0, B1, B2, B3);

12,101✔

283

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

12,101✔

284

      i_transform(B0, B1, B2, B3);

12,101✔

285

      SBoxD0(B0, B1, B2, B3);

12,101✔

286

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

12,101✔

287

      i_transform(B0, B1, B2, B3);

12,101✔

288

      SBoxD7(B0, B1, B2, B3);

12,101✔

289

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

12,101✔

290

      i_transform(B0, B1, B2, B3);

12,101✔

291

      SBoxD6(B0, B1, B2, B3);

12,101✔

292

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

12,101✔

293

      i_transform(B0, B1, B2, B3);

12,101✔

294

      SBoxD5(B0, B1, B2, B3);

12,101✔

295

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

12,101✔

296

      i_transform(B0, B1, B2, B3);

12,101✔

297

      SBoxD4(B0, B1, B2, B3);

12,101✔

298

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

12,101✔

299

      i_transform(B0, B1, B2, B3);

12,101✔

300

      SBoxD3(B0, B1, B2, B3);

12,101✔

301

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

12,101✔

302

      i_transform(B0, B1, B2, B3);

12,101✔

303

      SBoxD2(B0, B1, B2, B3);

12,101✔

304

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

12,101✔

305

      i_transform(B0, B1, B2, B3);

12,101✔

306

      SBoxD1(B0, B1, B2, B3);

12,101✔

307

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

12,101✔

308

      i_transform(B0, B1, B2, B3);

12,101✔

309

      SBoxD0(B0, B1, B2, B3);

12,101✔

310

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

12,101✔

312

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

12,101✔

314

11,453✔

316

bool Serpent::has_keying_material() const {

61,745✔

317

   return !m_round_key.empty();

61,745✔

323

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

12,908✔

324

   using namespace Botan::Serpent_F;

12,908✔

326

   const uint32_t PHI = 0x9E3779B9;

12,908✔

328

   secure_vector<uint32_t> W(140);

12,908✔

329

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

110,982✔

330

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

98,074✔

333

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

12,908✔

335

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

1,716,764✔

336

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

1,703,856✔

337

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

1,703,856✔

340

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

12,908✔

341

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

12,908✔

342

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

12,908✔

343

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

12,908✔

345

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

12,908✔

346

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

12,908✔

347

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

12,908✔

348

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

12,908✔

350

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

12,908✔

351

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

12,908✔

352

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

12,908✔

353

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

12,908✔

355

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

12,908✔

356

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

12,908✔

357

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

12,908✔

358

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

12,908✔

359

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

12,908✔

361

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

12,908✔

362

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

12,908✔

363

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

12,908✔

364

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

12,908✔

366

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

12,908✔

367

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

12,908✔

368

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

12,908✔

369

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

12,908✔

371

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

12,908✔

372

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

12,908✔

373

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

12,908✔

374

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

12,908✔

376

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

12,908✔

377

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

12,908✔

378

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

12,908✔

379

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

12,908✔

381

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

12,908✔

382

12,908✔

384

void Serpent::clear() {

7,437✔

385

   zap(m_round_key);

7,437✔

386

7,437✔

388

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

3,141✔

390

   if(CPUID::has_avx512()) {

3,141✔

396

   if(CPUID::has_avx2()) {

3,141✔

397

      return "avx2";

1,047✔

402

   if(CPUID::has_simd_32()) {

2,094✔

403

      return "simd";

1,047✔

407

   return "base";

1,047✔

randombit / botan / 5230455705

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

randombit / botan / 5230455705

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