FFmpeg: tools/crypto_bench.c Source File

FFmpeg

[フレーム]

tools

crypto_bench.c

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public License

8 * as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

14 * GNU Lesser General Public License for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public License

17 * along with FFmpeg; if not, write to the Free Software Foundation, Inc.,

18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

19 */

21 /* Optional external libraries; can be enabled using:

22 * make VERSUS=crypto+gcrypt+tomcrypt+mbedcrypto tools/crypto_bench */

23 #define USE_crypto 0x01 /* OpenSSL's libcrypto */

24 #define USE_gcrypt 0x02 /* GnuTLS's libgcrypt */

25 #define USE_tomcrypt 0x04 /* LibTomCrypt */

26 #define USE_mbedcrypto 0x08 /* mbed TLS */

28 #include <stdlib.h>

29 #include <math.h>

31 #include "libavutil/avutil.h"

32 #include "libavutil/avstring.h"

33 #include "libavutil/crc.h"

34 #include "libavutil/intreadwrite.h"

35 #include "libavutil/timer.h"

37 #ifndef AV_READ_TIME

38 #define AV_READ_TIME(x) 0

39 #endif

41 #if HAVE_UNISTD_H

42 #include <unistd.h> /* for getopt */

43 #endif

44 #if !HAVE_GETOPT

45 #include "compat/getopt.c"

46 #endif

48 #define MAX_INPUT_SIZE 1048576

49 #define MAX_OUTPUT_SIZE 128

51 static const char *enabled_libs;

52 static const char *enabled_algos;

53 static unsigned specified_runs;

55 static const uint8_t *hardcoded_key = "FFmpeg is the best program ever.";

57 static void fatal_error(const char *tag)

58 {

59 av_log(NULL, AV_LOG_ERROR, "Fatal error: %s\n", tag);

60 exit(1);

61 }

63 struct hash_impl {

64 const char *lib;

65 const char *name;

66 void (*run)(uint8_t *output, const uint8_t *input, unsigned size);

67 const char *output;

68 };

70 /***************************************************************************

71 * lavu: libavutil

72 ***************************************************************************/

74 #include "libavutil/md5.h"

75 #include "libavutil/sha.h"

76 #include "libavutil/sha512.h"

77 #include "libavutil/ripemd.h"

78 #include "libavutil/aes.h"

79 #include "libavutil/blowfish.h"

80 #include "libavutil/camellia.h"

81 #include "libavutil/cast5.h"

82 #include "libavutil/des.h"

83 #include "libavutil/twofish.h"

84 #include "libavutil/rc4.h"

85 #include "libavutil/xtea.h"

87 #define IMPL_USE_lavu IMPL_USE

89 static void run_lavu_md5(uint8_t *output,

90 const uint8_t *input, unsigned size)

91 {

92 av_md5_sum(output, input, size);

93 }

95 #define DEFINE_LAVU_MD(suffix, type, namespace, hsize) \

96 static void run_lavu_ ## suffix(uint8_t *output, \

97 const uint8_t *input, unsigned size) \

98 { \

99 static struct type *h; \

100 if (!h && !(h = av_ ## namespace ## _alloc())) \

101 fatal_error("out of memory"); \

102 av_ ## namespace ## _init(h, hsize); \

103 av_ ## namespace ## _update(h, input, size); \

104 av_ ## namespace ## _final(h, output); \

105 }

106

107 DEFINE_LAVU_MD(sha1, AVSHA, sha, 160);

108 DEFINE_LAVU_MD(sha256, AVSHA, sha, 256);

109 DEFINE_LAVU_MD(sha512, AVSHA512, sha512, 512);

110 DEFINE_LAVU_MD(ripemd128, AVRIPEMD, ripemd, 128);

111 DEFINE_LAVU_MD(ripemd160, AVRIPEMD, ripemd, 160);

112

113 static void run_lavu_aes128(uint8_t *output,

114 const uint8_t *input, unsigned size)

115 {

116 static struct AVAES *aes;

117 if (!aes && !(aes = av_aes_alloc()))

118 fatal_error("out of memory");

119 av_aes_init(aes, hardcoded_key, 128, 0);

120 av_aes_crypt(aes, output, input, size >> 4, NULL, 0);

121 }

122

123 static void run_lavu_blowfish(uint8_t *output,

124 const uint8_t *input, unsigned size)

125 {

126 static struct AVBlowfish *blowfish;

127 if (!blowfish && !(blowfish = av_blowfish_alloc()))

128 fatal_error("out of memory");

129 av_blowfish_init(blowfish, hardcoded_key, 16);

130 av_blowfish_crypt(blowfish, output, input, size >> 3, NULL, 0);

131 }

132

133 static void run_lavu_camellia(uint8_t *output,

134 const uint8_t *input, unsigned size)

135 {

136 static struct AVCAMELLIA *camellia;

137 if (!camellia && !(camellia = av_camellia_alloc()))

138 fatal_error("out of memory");

139 av_camellia_init(camellia, hardcoded_key, 128);

140 av_camellia_crypt(camellia, output, input, size >> 4, NULL, 0);

141 }

142

143 static void run_lavu_cast128(uint8_t *output,

144 const uint8_t *input, unsigned size)

145 {

146 static struct AVCAST5 *cast;

147 if (!cast && !(cast = av_cast5_alloc()))

148 fatal_error("out of memory");

149 av_cast5_init(cast, hardcoded_key, 128);

150 av_cast5_crypt(cast, output, input, size >> 3, 0);

151 }

152

153 static void run_lavu_des(uint8_t *output,

154 const uint8_t *input, unsigned size)

155 {

156 static struct AVDES *des;

157 if (!des && !(des = av_des_alloc()))

158 fatal_error("out of memory");

159 av_des_init(des, hardcoded_key, 64, 0);

160 av_des_crypt(des, output, input, size >> 3, NULL, 0);

161 }

162

163 static void run_lavu_twofish(uint8_t *output,

164 const uint8_t *input, unsigned size)

165 {

166 static struct AVTWOFISH *twofish;

167 if (!twofish && !(twofish = av_twofish_alloc()))

168 fatal_error("out of memory");

169 av_twofish_init(twofish, hardcoded_key, 128);

170 av_twofish_crypt(twofish, output, input, size >> 4, NULL, 0);

171 }

172

173 static void run_lavu_rc4(uint8_t *output,

174 const uint8_t *input, unsigned size)

175 {

176 static struct AVRC4 *rc4;

177 if (!rc4 && !(rc4 = av_rc4_alloc()))

178 fatal_error("out of memory");

179 av_rc4_init(rc4, hardcoded_key, 128, 0);

180 av_rc4_crypt(rc4, output, input, size, NULL, 0);

181 }

182

183 static void run_lavu_xtea(uint8_t *output,

184 const uint8_t *input, unsigned size)

185 {

186 static struct AVXTEA *xtea;

187 if (!xtea && !(xtea = av_xtea_alloc()))

188 fatal_error("out of memory");

189 av_xtea_init(xtea, hardcoded_key);

190 av_xtea_crypt(xtea, output, input, size >> 3, NULL, 0);

191 }

192

193 /***************************************************************************

194 * crypto: OpenSSL's libcrypto

195 ***************************************************************************/

196

197 #if (USE_EXT_LIBS) & USE_crypto

198

199 #define OPENSSL_DISABLE_OLD_DES_SUPPORT

200 #include <openssl/md5.h>

201 #include <openssl/sha.h>

202 #include <openssl/ripemd.h>

203 #include <openssl/aes.h>

204 #include <openssl/blowfish.h>

205 #include <openssl/camellia.h>

206 #include <openssl/cast.h>

207 #include <openssl/des.h>

208 #include <openssl/rc4.h>

209

210 #define DEFINE_CRYPTO_WRAPPER(suffix, function) \

211 static void run_crypto_ ## suffix(uint8_t *output, \

212 const uint8_t *input, unsigned size) \

213 { \

214 function(input, size, output); \

215 }

216

217 DEFINE_CRYPTO_WRAPPER(md5, MD5)

218 DEFINE_CRYPTO_WRAPPER(sha1, SHA1)

219 DEFINE_CRYPTO_WRAPPER(sha256, SHA256)

220 DEFINE_CRYPTO_WRAPPER(sha512, SHA512)

221 DEFINE_CRYPTO_WRAPPER(ripemd160, RIPEMD160)

222

223 static void run_crypto_aes128(uint8_t *output,

224 const uint8_t *input, unsigned size)

225 {

226 AES_KEY aes;

227 unsigned i;

228

229 AES_set_encrypt_key(hardcoded_key, 128, &aes);

230 size -= 15;

231 for (i = 0; i < size; i += 16)

232 AES_encrypt(input + i, output + i, &aes);

233 }

234

235 static void run_crypto_blowfish(uint8_t *output,

236 const uint8_t *input, unsigned size)

237 {

238 BF_KEY blowfish;

239 unsigned i;

240

241 BF_set_key(&blowfish, 16, hardcoded_key);

242 for (i = 0; i < size; i += 8)

243 BF_ecb_encrypt(input + i, output + i, &blowfish, 1);

244 }

245

246 static void run_crypto_camellia(uint8_t *output,

247 const uint8_t *input, unsigned size)

248 {

249 CAMELLIA_KEY camellia;

250 unsigned i;

251

252 Camellia_set_key(hardcoded_key, 128, &camellia);

253 size -= 15;

254 for (i = 0; i < size; i += 16)

255 Camellia_ecb_encrypt(input + i, output + i, &camellia, 1);

256 }

257

258 static void run_crypto_cast128(uint8_t *output,

259 const uint8_t *input, unsigned size)

260 {

261 CAST_KEY cast;

262 unsigned i;

263

264 CAST_set_key(&cast, 16, hardcoded_key);

265 for (i = 0; i < size; i += 8)

266 CAST_ecb_encrypt(input + i, output + i, &cast, 1);

267 }

268

269 static void run_crypto_des(uint8_t *output,

270 const uint8_t *input, unsigned size)

271 {

272 DES_key_schedule des;

273 unsigned i;

274

275 DES_set_key(hardcoded_key, &des);

276 for (i = 0; i < size; i += 8)

277 DES_ecb_encrypt(input + i, output + i, &des, 1);

278 }

279

280 static void run_crypto_rc4(uint8_t *output,

281 const uint8_t *input, unsigned size)

282 {

283 RC4_KEY rc4;

284

285 RC4_set_key(&rc4, 16, hardcoded_key);

286 RC4(&rc4, size, input, output);

287 }

288

289 #define IMPL_USE_crypto(...) IMPL_USE(__VA_ARGS__)

290 #else

291 #define IMPL_USE_crypto(...) /* ignore */

292 #endif

293

294 /***************************************************************************

295 * gcrypt: GnuTLS's libgcrypt

296 ***************************************************************************/

297

298 #if (USE_EXT_LIBS) & USE_gcrypt

299

300 #include <gcrypt.h>

301

302 #define DEFINE_GCRYPT_WRAPPER(suffix, algo) \

303 static void run_gcrypt_ ## suffix(uint8_t *output, \

304 const uint8_t *input, unsigned size) \

305 { \

306 gcry_md_hash_buffer(GCRY_MD_ ## algo, output, input, size); \

307 }

308

309 DEFINE_GCRYPT_WRAPPER(md5, MD5)

310 DEFINE_GCRYPT_WRAPPER(sha1, SHA1)

311 DEFINE_GCRYPT_WRAPPER(sha256, SHA256)

312 DEFINE_GCRYPT_WRAPPER(sha512, SHA512)

313 DEFINE_GCRYPT_WRAPPER(ripemd160, RMD160)

314

315 #define DEFINE_GCRYPT_CYPHER_WRAPPER(suffix, cypher, mode, sz) \

316 static void run_gcrypt_ ## suffix(uint8_t *output, \

317 const uint8_t *input, unsigned size) \

318 { \

319 static gcry_cipher_hd_t suffix; \

320 if (!suffix) \

321 gcry_cipher_open(&suffix, GCRY_CIPHER_ ## cypher, GCRY_CIPHER_MODE_ ## mode, 0); \

322 gcry_cipher_setkey(suffix, hardcoded_key, sz); \

323 gcry_cipher_encrypt(suffix, output, size, input, size); \

324 }

325

326 DEFINE_GCRYPT_CYPHER_WRAPPER(aes128, AES128, ECB, 16)

327 DEFINE_GCRYPT_CYPHER_WRAPPER(blowfish, BLOWFISH, ECB, 16)

328 DEFINE_GCRYPT_CYPHER_WRAPPER(camellia, CAMELLIA128, ECB, 16)

329 DEFINE_GCRYPT_CYPHER_WRAPPER(cast128, CAST5, ECB, 16)

330 DEFINE_GCRYPT_CYPHER_WRAPPER(des, DES, ECB, 8)

331 DEFINE_GCRYPT_CYPHER_WRAPPER(twofish, TWOFISH128, ECB, 16)

332 DEFINE_GCRYPT_CYPHER_WRAPPER(rc4, ARCFOUR, STREAM, 16)

333

334 #define IMPL_USE_gcrypt(...) IMPL_USE(__VA_ARGS__)

335 #else

336 #define IMPL_USE_gcrypt(...) /* ignore */

337 #endif

338

339 /***************************************************************************

340 * mbedcrypto: mbed TLS

341 ***************************************************************************/

342

343 #if (USE_EXT_LIBS) & USE_mbedcrypto

344

345 #include <mbedtls/aes.h>

346 #include <mbedtls/arc4.h>

347 #include <mbedtls/blowfish.h>

348 #include <mbedtls/camellia.h>

349 #include <mbedtls/des.h>

350 #include <mbedtls/md5.h>

351 #include <mbedtls/ripemd160.h>

352 #include <mbedtls/sha1.h>

353 #include <mbedtls/sha256.h>

354 #include <mbedtls/sha512.h>

355 #include <mbedtls/xtea.h>

356

357 #define DEFINE_MBEDCRYPTO_WRAPPER(suffix) \

358 static void run_mbedcrypto_ ## suffix(uint8_t *output, \

359 const uint8_t *input, unsigned size) \

360 { \

361 mbedtls_ ## suffix ## _ret(input, size, output); \

362 }

363

364 #define DEFINE_MBEDCRYPTO_WRAPPER_SHA2(suffix) \

365 static void run_mbedcrypto_ ## suffix(uint8_t *output, \

366 const uint8_t *input, unsigned size) \

367 { \

368 mbedtls_ ## suffix ## _ret(input, size, output, 0); \

369 }

370

371 DEFINE_MBEDCRYPTO_WRAPPER(md5)

372 DEFINE_MBEDCRYPTO_WRAPPER(ripemd160)

373 DEFINE_MBEDCRYPTO_WRAPPER(sha1)

374 DEFINE_MBEDCRYPTO_WRAPPER_SHA2(sha256)

375 DEFINE_MBEDCRYPTO_WRAPPER_SHA2(sha512)

376

377

378 #define DEFINE_MBEDCRYPTO_CYPHER_WRAPPER(suffix, cypher, algo) \

379 static void run_mbedcrypto_ ## suffix(uint8_t *output, \

380 const uint8_t *input, unsigned size) \

381 { \

382 mbedtls_ ## cypher ## _context cypher; \

383 \

384 mbedtls_ ## cypher ## _init(&cypher); \

385 mbedtls_ ## cypher ## _setkey_enc(&cypher, hardcoded_key, 128); \

386 for (int i = 0; i < size; i += 16) \

387 mbedtls_ ## cypher ## _crypt_ecb(&cypher, MBEDTLS_ ## algo ## _ENCRYPT, \

388 input + i, output + i); \

389 mbedtls_ ## cypher ## _free(&cypher); \

390 }

391

392 DEFINE_MBEDCRYPTO_CYPHER_WRAPPER(aes128, aes, AES)

393 DEFINE_MBEDCRYPTO_CYPHER_WRAPPER(camellia, camellia, CAMELLIA)

394

395 static void run_mbedcrypto_blowfish(uint8_t *output,

396 const uint8_t *input, unsigned size)

397 {

398 mbedtls_blowfish_context blowfish;

399

400 mbedtls_blowfish_init(&blowfish);

401 mbedtls_blowfish_setkey(&blowfish, hardcoded_key, 128);

402 for (int i = 0; i < size; i += 8)

403 mbedtls_blowfish_crypt_ecb(&blowfish, MBEDTLS_BLOWFISH_ENCRYPT,

404 input + i, output + i);

405 mbedtls_blowfish_free(&blowfish);

406 }

407

408 static void run_mbedcrypto_des(uint8_t *output,

409 const uint8_t *input, unsigned size)

410 {

411 mbedtls_des_context des;

412

413 mbedtls_des_init(&des);

414 mbedtls_des_setkey_enc(&des, hardcoded_key);

415 for (int i = 0; i < size; i += 8)

416 mbedtls_des_crypt_ecb(&des, input + i, output + i);

417 mbedtls_des_free(&des);

418 }

419

420 static void run_mbedcrypto_rc4(uint8_t *output,

421 const uint8_t *input, unsigned size)

422 {

423 mbedtls_arc4_context rc4;

424

425 mbedtls_arc4_init(&rc4);

426 mbedtls_arc4_setup(&rc4, hardcoded_key, 16);

427 mbedtls_arc4_crypt(&rc4, size, input, output);

428 mbedtls_arc4_free(&rc4);

429 }

430

431 static void run_mbedcrypto_xtea(uint8_t *output,

432 const uint8_t *input, unsigned size)

433 {

434 mbedtls_xtea_context xtea;

435

436 mbedtls_xtea_init(&xtea);

437 mbedtls_xtea_setup(&xtea, hardcoded_key);

438 for (int i = 0; i < size; i += 8)

439 mbedtls_xtea_crypt_ecb(&xtea, MBEDTLS_XTEA_ENCRYPT,

440 input + i, output + i);

441 mbedtls_xtea_free(&xtea);

442 }

443

444 #define IMPL_USE_mbedcrypto(...) IMPL_USE(__VA_ARGS__)

445 #else

446 #define IMPL_USE_mbedcrypto(...) /* ignore */

447 #endif

448

449 /***************************************************************************

450 * tomcrypt: LibTomCrypt

451 ***************************************************************************/

452

453 #if (USE_EXT_LIBS) & USE_tomcrypt

454

455 #include <tomcrypt.h>

456

457 #define DEFINE_TOMCRYPT_WRAPPER(suffix, namespace, algo) \

458 static void run_tomcrypt_ ## suffix(uint8_t *output, \

459 const uint8_t *input, unsigned size) \

460 { \

461 hash_state md; \

462 namespace ## _init(&md); \

463 namespace ## _process(&md, input, size); \

464 namespace ## _done(&md, output); \

465 }

466

467 DEFINE_TOMCRYPT_WRAPPER(md5, md5, MD5)

468 DEFINE_TOMCRYPT_WRAPPER(sha1, sha1, SHA1)

469 DEFINE_TOMCRYPT_WRAPPER(sha256, sha256, SHA256)

470 DEFINE_TOMCRYPT_WRAPPER(sha512, sha512, SHA512)

471 DEFINE_TOMCRYPT_WRAPPER(ripemd128, rmd128, RIPEMD128)

472 DEFINE_TOMCRYPT_WRAPPER(ripemd160, rmd160, RIPEMD160)

473

474 static void run_tomcrypt_aes128(uint8_t *output,

475 const uint8_t *input, unsigned size)

476 {

477 symmetric_key aes;

478 unsigned i;

479

480 aes_setup(hardcoded_key, 16, 0, &aes);

481 size -= 15;

482 for (i = 0; i < size; i += 16)

483 aes_ecb_encrypt(input + i, output + i, &aes);

484 }

485

486 static void run_tomcrypt_blowfish(uint8_t *output,

487 const uint8_t *input, unsigned size)

488 {

489 symmetric_key blowfish;

490 unsigned i;

491

492 blowfish_setup(hardcoded_key, 16, 0, &blowfish);

493 for (i = 0; i < size; i += 8)

494 blowfish_ecb_encrypt(input + i, output + i, &blowfish);

495 }

496

497 static void run_tomcrypt_camellia(uint8_t *output,

498 const uint8_t *input, unsigned size)

499 {

500 symmetric_key camellia;

501 unsigned i;

502

503 camellia_setup(hardcoded_key, 16, 0, &camellia);

504 size -= 15;

505 for (i = 0; i < size; i += 16)

506 camellia_ecb_encrypt(input + i, output + i, &camellia);

507 }

508

509 static void run_tomcrypt_cast128(uint8_t *output,

510 const uint8_t *input, unsigned size)

511 {

512 symmetric_key cast;

513 unsigned i;

514

515 cast5_setup(hardcoded_key, 16, 0, &cast);

516 for (i = 0; i < size; i += 8)

517 cast5_ecb_encrypt(input + i, output + i, &cast);

518 }

519

520 static void run_tomcrypt_des(uint8_t *output,

521 const uint8_t *input, unsigned size)

522 {

523 symmetric_key des;

524 unsigned i;

525

526 des_setup(hardcoded_key, 8, 0, &des);

527 for (i = 0; i < size; i += 8)

528 des_ecb_encrypt(input + i, output + i, &des);

529 }

530

531 static void run_tomcrypt_rc4(uint8_t *output,

532 const uint8_t *input, unsigned size)

533 {

534 rc4_state rc4;

535

536 rc4_stream_setup(&rc4, hardcoded_key, 16);

537 rc4_stream_crypt(&rc4, input, size, output);

538 rc4_stream_done(&rc4);

539 }

540

541 static void run_tomcrypt_twofish(uint8_t *output,

542 const uint8_t *input, unsigned size)

543 {

544 symmetric_key twofish;

545 unsigned i;

546

547 twofish_setup(hardcoded_key, 16, 0, &twofish);

548 size -= 15;

549 for (i = 0; i < size; i += 16)

550 twofish_ecb_encrypt(input + i, output + i, &twofish);

551 }

552

553 static void run_tomcrypt_xtea(uint8_t *output,

554 const uint8_t *input, unsigned size)

555 {

556 symmetric_key xtea;

557 unsigned i;

558

559 xtea_setup(hardcoded_key, 16, 0, &xtea);

560 for (i = 0; i < size; i += 8)

561 xtea_ecb_encrypt(input + i, output + i, &xtea);

562 }

563

564

565 #define IMPL_USE_tomcrypt(...) IMPL_USE(__VA_ARGS__)

566 #else

567 #define IMPL_USE_tomcrypt(...) /* ignore */

568 #endif

569

570 /***************************************************************************

571 * Driver code

572 ***************************************************************************/

573

574 static unsigned crc32(const uint8_t *data, unsigned size)

575 {

576 return av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, data, size);

577 }

578

579 static void run_implementation(const uint8_t *input, uint8_t *output,

580 struct hash_impl *impl, unsigned size)

581 {

582 uint64_t t0, t1;

583 unsigned nruns = specified_runs ? specified_runs : (1 << 30) / size;

584 unsigned outlen = 0, outcrc = 0;

585 unsigned i, j, val;

586 double mtime, ttime = 0, ttime2 = 0, stime;

587 uint8_t outref[MAX_OUTPUT_SIZE];

588

589 if (enabled_libs && !av_stristr(enabled_libs, impl->lib) ||

590 enabled_algos && !av_stristr(enabled_algos, impl->name))

591 return;

592 if (!sscanf(impl->output, "crc:%x", &outcrc)) {

593 outlen = strlen(impl->output) / 2;

594 for (i = 0; i < outlen; i++) {

595 sscanf(impl->output + i * 2, "%02x", &val);

596 outref[i] = val;

597 }

598 }

599 for (i = 0; i < 8; i++) /* heat caches */

600 impl->run(output, input, size);

601 for (i = 0; i < nruns; i++) {

602 memset(output, 0, size); /* avoid leftovers from previous runs */

603 t0 = AV_READ_TIME();

604 impl->run(output, input, size);

605 t1 = AV_READ_TIME();

606 if (outlen ? memcmp(output, outref, outlen) :

607 crc32(output, size) != outcrc) {

608 fprintf(stderr, "Expected: ");

609 if (outlen)

610 for (j = 0; j < outlen; j++)

611 fprintf(stderr, "%02x", output[j]);

612 else

613 fprintf(stderr, "%08x", crc32(output, size));

614 fprintf(stderr, "\n");

615 fatal_error("output mismatch");

616 }

617 mtime = (double)(t1 - t0) / size;

618 ttime += mtime;

619 ttime2 += mtime * mtime;

620 }

621

622 ttime /= nruns;

623 ttime2 /= nruns;

624 stime = sqrt(ttime2 - ttime * ttime);

625 printf("%-10s %-12s size: %7d runs: %6d time: %8.3f +- %.3f\n",

626 impl->lib, impl->name, size, nruns, ttime, stime);

627 fflush(stdout);

628 }

629

630 #define IMPL_USE(lib, name, symbol, output) \

631 { #lib, name, run_ ## lib ## _ ## symbol, output },

632 #define IMPL(lib, ...) IMPL_USE_ ## lib(lib, __VA_ARGS__)

633 #define IMPL_ALL(...) \

634 IMPL(lavu, __VA_ARGS__) \

635 IMPL(crypto, __VA_ARGS__) \

636 IMPL(gcrypt, __VA_ARGS__) \

637 IMPL(mbedcrypto, __VA_ARGS__) \

638 IMPL(tomcrypt, __VA_ARGS__)

639

640 struct hash_impl implementations[] = {

641 IMPL_ALL("MD5", md5, "aa26ff5b895356bcffd9292ba9f89e66")

642 IMPL_ALL("SHA-1", sha1, "1fd8bd1fa02f5b0fe916b0d71750726b096c5744")

643 IMPL_ALL("SHA-256", sha256, "14028ac673b3087e51a1d407fbf0df4deeec8f217119e13b07bf2138f93db8c5")

644 IMPL_ALL("SHA-512", sha512, "3afdd44a80d99af15c87bd724cb717243193767835ce866dd5d58c02d674bb57"

645 "7c25b9e118c200a189fcd5a01ef106a4e200061f3e97dbf50ba065745fd46bef")

646 IMPL(lavu, "RIPEMD-128", ripemd128, "9ab8bfba2ddccc5d99c9d4cdfb844a5f")

647 IMPL(tomcrypt, "RIPEMD-128", ripemd128, "9ab8bfba2ddccc5d99c9d4cdfb844a5f")

648 IMPL_ALL("RIPEMD-160", ripemd160, "62a5321e4fc8784903bb43ab7752c75f8b25af00")

649 IMPL_ALL("AES-128", aes128, "crc:ff6bc888")

650 IMPL_ALL("CAMELLIA", camellia, "crc:7abb59a7")

651 IMPL(lavu, "CAST-128", cast128, "crc:456aa584")

652 IMPL(crypto, "CAST-128", cast128, "crc:456aa584")

653 IMPL(gcrypt, "CAST-128", cast128, "crc:456aa584")

654 IMPL(tomcrypt, "CAST-128", cast128, "crc:456aa584")

655 IMPL_ALL("BLOWFISH", blowfish, "crc:33e8aa74")

656 IMPL_ALL("DES", des, "crc:31291e0b")

657 IMPL(lavu, "TWOFISH", twofish, "crc:9edbd5c1")

658 IMPL(gcrypt, "TWOFISH", twofish, "crc:9edbd5c1")

659 IMPL(tomcrypt, "TWOFISH", twofish, "crc:9edbd5c1")

660 IMPL_ALL("RC4", rc4, "crc:538d37b2")

661 IMPL(lavu, "XTEA", xtea, "crc:931fc270")

662 IMPL(mbedcrypto, "XTEA", xtea, "crc:931fc270")

663 IMPL(tomcrypt, "XTEA", xtea, "crc:931fc270")

664 };

665

666 int main(int argc, char **argv)

667 {

668 uint8_t *input;

669 uint8_t *output;

670 unsigned i, impl, size;

671 int opt;

672

673 while ((opt = getopt(argc, argv, "hl:a:r:")) != -1) {

674 switch (opt) {

675 case 'l':

676 enabled_libs = optarg;

677 break;

678 case 'a':

679 enabled_algos = optarg;

680 break;

681 case 'r':

682 specified_runs = strtol(optarg, NULL, 0);

683 break;

684 case 'h':

685 default:

686 fprintf(stderr, "Usage: %s [-l libs] [-a algos] [-r runs]\n",

687 argv[0]);

688 if ((USE_EXT_LIBS)) {

689 char buf[1024];

690 snprintf(buf, sizeof(buf), "%s%s%s%s",

691 ((USE_EXT_LIBS) & USE_crypto) ? "+crypto" : "",

692 ((USE_EXT_LIBS) & USE_gcrypt) ? "+gcrypt" : "",

693 ((USE_EXT_LIBS) & USE_mbedcrypto) ? "+mbedcrypto" : "",

694 ((USE_EXT_LIBS) & USE_tomcrypt) ? "+tomcrypt" : "");

695 fprintf(stderr, "Built with the following external libraries:\n"

696 "make VERSUS=%s\n", buf + 1);

697 } else {

698 fprintf(stderr, "Built without external libraries; use\n"

699 "make VERSUS=crypto+gcrypt+mbedcrypto+tomcrypt tools/crypto_bench\n"

700 "to enable them.\n");

701 }

702 exit(opt != 'h');

703 }

704 }

705 input = av_malloc(MAX_INPUT_SIZE * 2);

706 if (!input)

707 fatal_error("out of memory");

708 for (i = 0; i < MAX_INPUT_SIZE; i += 4)

709 AV_WB32(input + i, i);

710

711 output = input + MAX_INPUT_SIZE;

712

713 size = MAX_INPUT_SIZE;

714 for (impl = 0; impl < FF_ARRAY_ELEMS(implementations); impl++)

715 run_implementation(input, output, &implementations[impl], size);

716

717 av_free(input);

718

719 return 0;

720 }

av_des_init

int av_des_init(AVDES *d, const uint8_t *key, int key_bits, av_unused int decrypt)

Definition: des.c:280

av_aes_init

int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)

Initialize an AVAES context.

Definition: aes.c:201

cast

The reader does not expect b to be semantically here and if the code is changed by maybe adding a cast

Definition: undefined.txt:36

AVTWOFISH

Definition: twofish.c:33

AVSHA512

hash context

Definition: sha512.c:35

av_stristr

char * av_stristr(const char *s1, const char *s2)

Locate the first case-independent occurrence in the string haystack of the string needle.

Definition: avstring.c:59

av_des_crypt

void av_des_crypt(AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)

Encrypts / decrypts using the DES algorithm.

Definition: des.c:324

av_camellia_alloc

struct AVCAMELLIA * av_camellia_alloc(void)

Allocate an AVCAMELLIA context To free the struct: av_free(ptr)

Definition: camellia.c:351

output

filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output

Definition: filter_design.txt:225

AVRC4

Definition: rc4.h:32

#define t0

Definition: regdef.h:28

AVCAMELLIA

Definition: camellia.c:46

MD5

@ MD5

Definition: hash.c:40

data

const char data[16]

Definition: mxf.c:146

av_cast5_alloc

struct AVCAST5 * av_cast5_alloc(void)

Allocate an AVCAST5 context To free the struct: av_free(ptr)

Definition: cast5.c:455

av_xtea_crypt

void av_xtea_crypt(AVXTEA *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)

Encrypt or decrypt a buffer using a previously initialized context, in big endian format.

Definition: xtea.c:243

MAX_OUTPUT_SIZE

#define MAX_OUTPUT_SIZE

Definition: crypto_bench.c:49

AVCAST5

Definition: cast5.c:75

DEFINE_LAVU_MD

#define DEFINE_LAVU_MD(suffix, type, namespace, hsize)

Definition: crypto_bench.c:95

#define t1

Definition: regdef.h:29

sha512.h

hash_impl::name

const char * name

Definition: crypto_bench.c:65

av_cast5_crypt

void av_cast5_crypt(AVCAST5 *cs, uint8_t *dst, const uint8_t *src, int count, int decrypt)

Encrypt or decrypt a buffer using a previously initialized context, ECB mode only.

Definition: cast5.c:500

av_twofish_init

av_cold int av_twofish_init(AVTWOFISH *cs, const uint8_t *key, int key_bits)

Initialize an AVTWOFISH context.

Definition: twofish.c:273

av_xtea_init

void av_xtea_init(AVXTEA *ctx, const uint8_t key[16])

Initialize an AVXTEA context.

Definition: xtea.c:42

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

crc.h

USE_crypto

#define USE_crypto

Definition: crypto_bench.c:23

hash_impl::lib

const char * lib

Definition: crypto_bench.c:64

USE_gcrypt

#define USE_gcrypt

Definition: crypto_bench.c:24

IMPL

#define IMPL(lib,...)

Definition: crypto_bench.c:632

md5

struct AVMD5 * md5

Definition: movenc.c:56

cast5.h

Public header for libavutil CAST5 algorithm.

run_lavu_des

static void run_lavu_des(uint8_t *output, const uint8_t *input, unsigned size)

Definition: crypto_bench.c:153

val

static double val(void *priv, double ch)

Definition: aeval.c:77

run_lavu_aes128

static void run_lavu_aes128(uint8_t *output, const uint8_t *input, unsigned size)

Definition: crypto_bench.c:113

implementations

struct hash_impl implementations[]

Definition: crypto_bench.c:640

USE_tomcrypt

#define USE_tomcrypt

Definition: crypto_bench.c:25

av_camellia_crypt

void av_camellia_crypt(AVCAMELLIA *cs, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)

Encrypt or decrypt a buffer using a previously initialized context.

Definition: camellia.c:397

run_lavu_camellia

static void run_lavu_camellia(uint8_t *output, const uint8_t *input, unsigned size)

Definition: crypto_bench.c:133

av_twofish_alloc

struct AVTWOFISH * av_twofish_alloc(void)

Allocate an AVTWOFISH context To free the struct: av_free(ptr)

Definition: twofish.c:119

enabled_libs

static const char * enabled_libs

Definition: crypto_bench.c:51

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

getopt

static int getopt(int argc, char *argv[], char *opts)

Definition: getopt.c:41

intreadwrite.h

ripemd.h

av_blowfish_alloc

AVBlowfish * av_blowfish_alloc(void)

Allocate an AVBlowfish context.

Definition: blowfish.c:305

av_camellia_init

av_cold int av_camellia_init(AVCAMELLIA *cs, const uint8_t *key, int key_bits)

Initialize an AVCAMELLIA context.

Definition: camellia.c:356

hash_impl

Definition: crypto_bench.c:63

main

int main(int argc, char **argv)

Definition: crypto_bench.c:666

RIPEMD160

@ RIPEMD160

Definition: hash.c:43

crc32

static unsigned crc32(const uint8_t *data, unsigned size)

Definition: crypto_bench.c:574

aes.h

NULL

#define NULL

Definition: coverity.c:32

sha.h

av_aes_crypt

void av_aes_crypt(AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)

Encrypt or decrypt a buffer using a previously initialized context.

Definition: aes.c:169

av_aes_alloc

struct AVAES * av_aes_alloc(void)

Allocate an AVAES context.

Definition: aes.c:35

timer.h

double

Definition: af_crystalizer.c:132

run_lavu_cast128

static void run_lavu_cast128(uint8_t *output, const uint8_t *input, unsigned size)

Definition: crypto_bench.c:143

SHA256

@ SHA256

Definition: hash.c:48

AV_WB32

#define AV_WB32(p, v)

Definition: intreadwrite.h:419

blowfish.h

av_twofish_crypt

void av_twofish_crypt(AVTWOFISH *cs, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)

Encrypt or decrypt a buffer using a previously initialized context.

Definition: twofish.c:316

run_lavu_twofish

static void run_lavu_twofish(uint8_t *output, const uint8_t *input, unsigned size)

Definition: crypto_bench.c:163

run_lavu_md5

static void run_lavu_md5(uint8_t *output, const uint8_t *input, unsigned size)

Definition: crypto_bench.c:89

av_blowfish_crypt

void av_blowfish_crypt(AVBlowfish *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)

Encrypt or decrypt a buffer using a previously initialized context.

Definition: blowfish.c:376

twofish.h

Public header for libavutil TWOFISH algorithm.

enabled_algos

static const char * enabled_algos

Definition: crypto_bench.c:52

des.h

size

int size

Definition: twinvq_data.h:10344

av_md5_sum

void av_md5_sum(uint8_t *dst, const uint8_t *src, size_t len)

Hash an array of data.

Definition: md5.c:201

run_lavu_rc4

static void run_lavu_rc4(uint8_t *output, const uint8_t *input, unsigned size)

Definition: crypto_bench.c:173

printf

printf("static const uint8_t my_array[100] = {\n")

run_lavu_blowfish

static void run_lavu_blowfish(uint8_t *output, const uint8_t *input, unsigned size)

Definition: crypto_bench.c:123

av_rc4_alloc

AVRC4 * av_rc4_alloc(void)

Allocate an AVRC4 context.

Definition: rc4.c:29

av_crc_get_table

const AVCRC * av_crc_get_table(AVCRCId crc_id)

Get an initialized standard CRC table.

Definition: crc.c:374

SHA512

@ SHA512

Definition: hash.c:52

fatal_error

static void fatal_error(const char *tag)

Definition: crypto_bench.c:57

AVRIPEMD

hash context

Definition: ripemd.c:35

USE_mbedcrypto

#define USE_mbedcrypto

Definition: crypto_bench.c:26

hash_impl::output

const char * output

Definition: crypto_bench.c:67

input

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input

Definition: filter_design.txt:172

av_des_alloc

AVDES * av_des_alloc(void)

Allocate an AVDES context.

Definition: des.c:275

hash_impl::run

void(* run)(uint8_t *output, const uint8_t *input, unsigned size)

Definition: crypto_bench.c:66

AVBlowfish

Definition: blowfish.h:35

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:269