randombit/botan | Build 20402826089 | 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(CPUID::Feature::AVX512)) {

19,421✔

40

   if(CPUID::has(CPUID::Feature::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(CPUID::Feature::SIMD_4X32)) {

19,421✔

52

      while(blocks >= 4) {

19,999✔

53

         simd_encrypt_4(in, out);

578✔

54

         in += 4 * BLOCK_SIZE;

578✔

55

         out += 4 * BLOCK_SIZE;

578✔

56

         blocks -= 4;

578✔

61

   const Key_Inserter key_xor(m_round_key.data());

19,421✔

63

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

37,711✔

64

      uint32_t B0 = 0;

18,290✔

65

      uint32_t B1 = 0;

18,290✔

66

      uint32_t B2 = 0;

18,290✔

67

      uint32_t B3 = 0;

18,290✔

68

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

18,290✔

70

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

18,290✔

71

      SBoxE0(B0, B1, B2, B3);

18,290✔

72

      transform(B0, B1, B2, B3);

18,290✔

73

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

18,290✔

74

      SBoxE1(B0, B1, B2, B3);

18,290✔

75

      transform(B0, B1, B2, B3);

18,290✔

76

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

18,290✔

77

      SBoxE2(B0, B1, B2, B3);

18,290✔

78

      transform(B0, B1, B2, B3);

18,290✔

79

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

18,290✔

80

      SBoxE3(B0, B1, B2, B3);

18,290✔

81

      transform(B0, B1, B2, B3);

18,290✔

82

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

18,290✔

83

      SBoxE4(B0, B1, B2, B3);

18,290✔

84

      transform(B0, B1, B2, B3);

18,290✔

85

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

18,290✔

86

      SBoxE5(B0, B1, B2, B3);

18,290✔

87

      transform(B0, B1, B2, B3);

18,290✔

88

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

18,290✔

89

      SBoxE6(B0, B1, B2, B3);

18,290✔

90

      transform(B0, B1, B2, B3);

18,290✔

91

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

18,290✔

92

      SBoxE7(B0, B1, B2, B3);

18,290✔

93

      transform(B0, B1, B2, B3);

18,290✔

94

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

18,290✔

95

      SBoxE0(B0, B1, B2, B3);

18,290✔

96

      transform(B0, B1, B2, B3);

18,290✔

97

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

18,290✔

98

      SBoxE1(B0, B1, B2, B3);

18,290✔

99

      transform(B0, B1, B2, B3);

18,290✔

100

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

18,290✔

101

      SBoxE2(B0, B1, B2, B3);

18,290✔

102

      transform(B0, B1, B2, B3);

18,290✔

103

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

18,290✔

104

      SBoxE3(B0, B1, B2, B3);

18,290✔

105

      transform(B0, B1, B2, B3);

18,290✔

106

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

18,290✔

107

      SBoxE4(B0, B1, B2, B3);

18,290✔

108

      transform(B0, B1, B2, B3);

18,290✔

109

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

18,290✔

110

      SBoxE5(B0, B1, B2, B3);

18,290✔

111

      transform(B0, B1, B2, B3);

18,290✔

112

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

18,290✔

113

      SBoxE6(B0, B1, B2, B3);

18,290✔

114

      transform(B0, B1, B2, B3);

18,290✔

115

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

18,290✔

116

      SBoxE7(B0, B1, B2, B3);

18,290✔

117

      transform(B0, B1, B2, B3);

18,290✔

118

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

18,290✔

119

      SBoxE0(B0, B1, B2, B3);

18,290✔

120

      transform(B0, B1, B2, B3);

18,290✔

121

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

18,290✔

122

      SBoxE1(B0, B1, B2, B3);

18,290✔

123

      transform(B0, B1, B2, B3);

18,290✔

124

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

18,290✔

125

      SBoxE2(B0, B1, B2, B3);

18,290✔

126

      transform(B0, B1, B2, B3);

18,290✔

127

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

18,290✔

128

      SBoxE3(B0, B1, B2, B3);

18,290✔

129

      transform(B0, B1, B2, B3);

18,290✔

130

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

18,290✔

131

      SBoxE4(B0, B1, B2, B3);

18,290✔

132

      transform(B0, B1, B2, B3);

18,290✔

133

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

18,290✔

134

      SBoxE5(B0, B1, B2, B3);

18,290✔

135

      transform(B0, B1, B2, B3);

18,290✔

136

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

18,290✔

137

      SBoxE6(B0, B1, B2, B3);

18,290✔

138

      transform(B0, B1, B2, B3);

18,290✔

139

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

18,290✔

140

      SBoxE7(B0, B1, B2, B3);

18,290✔

141

      transform(B0, B1, B2, B3);

18,290✔

142

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

18,290✔

143

      SBoxE0(B0, B1, B2, B3);

18,290✔

144

      transform(B0, B1, B2, B3);

18,290✔

145

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

18,290✔

146

      SBoxE1(B0, B1, B2, B3);

18,290✔

147

      transform(B0, B1, B2, B3);

18,290✔

148

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

18,290✔

149

      SBoxE2(B0, B1, B2, B3);

18,290✔

150

      transform(B0, B1, B2, B3);

18,290✔

151

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

18,290✔

152

      SBoxE3(B0, B1, B2, B3);

18,290✔

153

      transform(B0, B1, B2, B3);

18,290✔

154

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

18,290✔

155

      SBoxE4(B0, B1, B2, B3);

18,290✔

156

      transform(B0, B1, B2, B3);

18,290✔

157

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

18,290✔

158

      SBoxE5(B0, B1, B2, B3);

18,290✔

159

      transform(B0, B1, B2, B3);

18,290✔

160

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

18,290✔

161

      SBoxE6(B0, B1, B2, B3);

18,290✔

162

      transform(B0, B1, B2, B3);

18,290✔

163

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

18,290✔

164

      SBoxE7(B0, B1, B2, B3);

18,290✔

165

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

18,290✔

167

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

18,290✔

169

19,421✔

174

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

17,735✔

175

   using namespace Botan::Serpent_F;

17,735✔

177

   assert_key_material_set();

17,735✔

180

   if(CPUID::has(CPUID::Feature::AVX512)) {

11,453✔

191

   if(CPUID::has(CPUID::Feature::AVX2)) {

11,453✔

192

      while(blocks >= 8) {

7,809✔

193

         avx2_decrypt_8(in, out);

544✔

194

         in += 8 * BLOCK_SIZE;

544✔

195

         out += 8 * BLOCK_SIZE;

544✔

196

         blocks -= 8;

544✔

202

   if(CPUID::has(CPUID::Feature::SIMD_4X32)) {

11,453✔

203

      while(blocks >= 4) {

12,031✔

204

         simd_decrypt_4(in, out);

578✔

205

         in += 4 * BLOCK_SIZE;

578✔

206

         out += 4 * BLOCK_SIZE;

578✔

207

         blocks -= 4;

578✔

212

   const Key_Inserter key_xor(m_round_key.data());

11,453✔

214

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

23,330✔

215

      uint32_t B0 = 0;

11,877✔

216

      uint32_t B1 = 0;

11,877✔

217

      uint32_t B2 = 0;

11,877✔

218

      uint32_t B3 = 0;

11,877✔

219

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

11,877✔

221

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

11,877✔

222

      SBoxD7(B0, B1, B2, B3);

11,877✔

223

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

11,877✔

224

      i_transform(B0, B1, B2, B3);

11,877✔

225

      SBoxD6(B0, B1, B2, B3);

11,877✔

226

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

11,877✔

227

      i_transform(B0, B1, B2, B3);

11,877✔

228

      SBoxD5(B0, B1, B2, B3);

11,877✔

229

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

11,877✔

230

      i_transform(B0, B1, B2, B3);

11,877✔

231

      SBoxD4(B0, B1, B2, B3);

11,877✔

232

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

11,877✔

233

      i_transform(B0, B1, B2, B3);

11,877✔

234

      SBoxD3(B0, B1, B2, B3);

11,877✔

235

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

11,877✔

236

      i_transform(B0, B1, B2, B3);

11,877✔

237

      SBoxD2(B0, B1, B2, B3);

11,877✔

238

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

11,877✔

239

      i_transform(B0, B1, B2, B3);

11,877✔

240

      SBoxD1(B0, B1, B2, B3);

11,877✔

241

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

11,877✔

242

      i_transform(B0, B1, B2, B3);

11,877✔

243

      SBoxD0(B0, B1, B2, B3);

11,877✔

244

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

11,877✔

245

      i_transform(B0, B1, B2, B3);

11,877✔

246

      SBoxD7(B0, B1, B2, B3);

11,877✔

247

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

11,877✔

248

      i_transform(B0, B1, B2, B3);

11,877✔

249

      SBoxD6(B0, B1, B2, B3);

11,877✔

250

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

11,877✔

251

      i_transform(B0, B1, B2, B3);

11,877✔

252

      SBoxD5(B0, B1, B2, B3);

11,877✔

253

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

11,877✔

254

      i_transform(B0, B1, B2, B3);

11,877✔

255

      SBoxD4(B0, B1, B2, B3);

11,877✔

256

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

11,877✔

257

      i_transform(B0, B1, B2, B3);

11,877✔

258

      SBoxD3(B0, B1, B2, B3);

11,877✔

259

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

11,877✔

260

      i_transform(B0, B1, B2, B3);

11,877✔

261

      SBoxD2(B0, B1, B2, B3);

11,877✔

262

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

11,877✔

263

      i_transform(B0, B1, B2, B3);

11,877✔

264

      SBoxD1(B0, B1, B2, B3);

11,877✔

265

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

11,877✔

266

      i_transform(B0, B1, B2, B3);

11,877✔

267

      SBoxD0(B0, B1, B2, B3);

11,877✔

268

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

11,877✔

269

      i_transform(B0, B1, B2, B3);

11,877✔

270

      SBoxD7(B0, B1, B2, B3);

11,877✔

271

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

11,877✔

272

      i_transform(B0, B1, B2, B3);

11,877✔

273

      SBoxD6(B0, B1, B2, B3);

11,877✔

274

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

11,877✔

275

      i_transform(B0, B1, B2, B3);

11,877✔

276

      SBoxD5(B0, B1, B2, B3);

11,877✔

277

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

11,877✔

278

      i_transform(B0, B1, B2, B3);

11,877✔

279

      SBoxD4(B0, B1, B2, B3);

11,877✔

280

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

11,877✔

281

      i_transform(B0, B1, B2, B3);

11,877✔

282

      SBoxD3(B0, B1, B2, B3);

11,877✔

283

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

11,877✔

284

      i_transform(B0, B1, B2, B3);

11,877✔

285

      SBoxD2(B0, B1, B2, B3);

11,877✔

286

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

11,877✔

287

      i_transform(B0, B1, B2, B3);

11,877✔

288

      SBoxD1(B0, B1, B2, B3);

11,877✔

289

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

11,877✔

290

      i_transform(B0, B1, B2, B3);

11,877✔

291

      SBoxD0(B0, B1, B2, B3);

11,877✔

292

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

11,877✔

293

      i_transform(B0, B1, B2, B3);

11,877✔

294

      SBoxD7(B0, B1, B2, B3);

11,877✔

295

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

11,877✔

296

      i_transform(B0, B1, B2, B3);

11,877✔

297

      SBoxD6(B0, B1, B2, B3);

11,877✔

298

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

11,877✔

299

      i_transform(B0, B1, B2, B3);

11,877✔

300

      SBoxD5(B0, B1, B2, B3);

11,877✔

301

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

11,877✔

302

      i_transform(B0, B1, B2, B3);

11,877✔

303

      SBoxD4(B0, B1, B2, B3);

11,877✔

304

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

11,877✔

305

      i_transform(B0, B1, B2, B3);

11,877✔

306

      SBoxD3(B0, B1, B2, B3);

11,877✔

307

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

11,877✔

308

      i_transform(B0, B1, B2, B3);

11,877✔

309

      SBoxD2(B0, B1, B2, B3);

11,877✔

310

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

11,877✔

311

      i_transform(B0, B1, B2, B3);

11,877✔

312

      SBoxD1(B0, B1, B2, B3);

11,877✔

313

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

11,877✔

314

      i_transform(B0, B1, B2, B3);

11,877✔

315

      SBoxD0(B0, B1, B2, B3);

11,877✔

316

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

11,877✔

318

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

11,877✔

320

11,453✔

322

bool Serpent::has_keying_material() const {

61,727✔

323

   return !m_round_key.empty();

61,727✔

329

void Serpent::key_schedule(std::span<const uint8_t> key) {

12,908✔

330

   using namespace Botan::Serpent_F;

12,908✔

332

   const uint32_t PHI = 0x9E3779B9;

12,908✔

334

   secure_vector<uint32_t> W(140);

12,908✔

335

   for(size_t i = 0; i != key.size() / 4; ++i) {

110,982✔

336

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

98,074✔

339

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

12,908✔

341

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

1,716,764✔

342

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

1,703,856✔

343

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

1,703,856✔

346

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

12,908✔

347

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

12,908✔

348

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

12,908✔

349

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

12,908✔

351

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

12,908✔

352

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

12,908✔

353

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

12,908✔

354

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

12,908✔

356

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

12,908✔

357

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

12,908✔

358

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

12,908✔

359

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

12,908✔

361

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

12,908✔

362

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

12,908✔

363

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

12,908✔

364

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

12,908✔

365

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

12,908✔

367

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

12,908✔

368

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

12,908✔

369

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

12,908✔

370

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

12,908✔

372

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

12,908✔

373

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

12,908✔

374

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

12,908✔

375

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

12,908✔

377

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

12,908✔

378

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

12,908✔

379

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

12,908✔

380

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

12,908✔

382

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

12,908✔

383

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

12,908✔

384

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

12,908✔

385

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

12,908✔

387

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

12,908✔

388

12,908✔

390

void Serpent::clear() {

7,437✔

391

   zap(m_round_key);

7,437✔

392

7,437✔

394

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

3,141✔

396

   if(auto feat = CPUID::check(CPUID::Feature::AVX512)) {

3,141✔

402

   if(auto feat = CPUID::check(CPUID::Feature::AVX2)) {

3,141✔

403

      return *feat;

2,094✔

404

1,047✔

408

   if(auto feat = CPUID::check(CPUID::Feature::SIMD_4X32)) {

2,094✔

409

      return *feat;

4,188✔

410

2,094✔

randombit / botan / 20402826089

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

randombit / botan / 20402826089

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