tcrypt.c 77 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Quick & dirty crypto testing module.
  4. *
  5. * This will only exist until we have a better testing mechanism
  6. * (e.g. a char device).
  7. *
  8. * Copyright (c) 2002 James Morris <[email protected]>
  9. * Copyright (c) 2002 Jean-Francois Dive <[email protected]>
  10. * Copyright (c) 2007 Nokia Siemens Networks
  11. *
  12. * Updated RFC4106 AES-GCM testing.
  13. * Authors: Aidan O'Mahony ([email protected])
  14. * Adrian Hoban <[email protected]>
  15. * Gabriele Paoloni <[email protected]>
  16. * Tadeusz Struk ([email protected])
  17. * Copyright (c) 2010, Intel Corporation.
  18. */
  19. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  20. #include <crypto/aead.h>
  21. #include <crypto/hash.h>
  22. #include <crypto/skcipher.h>
  23. #include <linux/err.h>
  24. #include <linux/fips.h>
  25. #include <linux/init.h>
  26. #include <linux/gfp.h>
  27. #include <linux/module.h>
  28. #include <linux/scatterlist.h>
  29. #include <linux/string.h>
  30. #include <linux/moduleparam.h>
  31. #include <linux/jiffies.h>
  32. #include <linux/timex.h>
  33. #include <linux/interrupt.h>
  34. #include "tcrypt.h"
  35. /*
  36. * Need slab memory for testing (size in number of pages).
  37. */
  38. #define TVMEMSIZE 4
  39. /*
  40. * Used by test_cipher_speed()
  41. */
  42. #define ENCRYPT 1
  43. #define DECRYPT 0
  44. #define MAX_DIGEST_SIZE 64
  45. /*
  46. * return a string with the driver name
  47. */
  48. #define get_driver_name(tfm_type, tfm) crypto_tfm_alg_driver_name(tfm_type ## _tfm(tfm))
  49. /*
  50. * Used by test_cipher_speed()
  51. */
  52. static unsigned int sec;
  53. static char *alg;
  54. static u32 type;
  55. static u32 mask;
  56. static int mode;
  57. static u32 num_mb = 8;
  58. static unsigned int klen;
  59. static char *tvmem[TVMEMSIZE];
  60. static const int block_sizes[] = { 16, 64, 128, 256, 1024, 1420, 4096, 0 };
  61. static const int aead_sizes[] = { 16, 64, 256, 512, 1024, 1420, 4096, 8192, 0 };
  62. #define XBUFSIZE 8
  63. #define MAX_IVLEN 32
  64. static int testmgr_alloc_buf(char *buf[XBUFSIZE])
  65. {
  66. int i;
  67. for (i = 0; i < XBUFSIZE; i++) {
  68. buf[i] = (void *)__get_free_page(GFP_KERNEL);
  69. if (!buf[i])
  70. goto err_free_buf;
  71. }
  72. return 0;
  73. err_free_buf:
  74. while (i-- > 0)
  75. free_page((unsigned long)buf[i]);
  76. return -ENOMEM;
  77. }
  78. static void testmgr_free_buf(char *buf[XBUFSIZE])
  79. {
  80. int i;
  81. for (i = 0; i < XBUFSIZE; i++)
  82. free_page((unsigned long)buf[i]);
  83. }
  84. static void sg_init_aead(struct scatterlist *sg, char *xbuf[XBUFSIZE],
  85. unsigned int buflen, const void *assoc,
  86. unsigned int aad_size)
  87. {
  88. int np = (buflen + PAGE_SIZE - 1)/PAGE_SIZE;
  89. int k, rem;
  90. if (np > XBUFSIZE) {
  91. rem = PAGE_SIZE;
  92. np = XBUFSIZE;
  93. } else {
  94. rem = buflen % PAGE_SIZE;
  95. }
  96. sg_init_table(sg, np + 1);
  97. sg_set_buf(&sg[0], assoc, aad_size);
  98. if (rem)
  99. np--;
  100. for (k = 0; k < np; k++)
  101. sg_set_buf(&sg[k + 1], xbuf[k], PAGE_SIZE);
  102. if (rem)
  103. sg_set_buf(&sg[k + 1], xbuf[k], rem);
  104. }
  105. static inline int do_one_aead_op(struct aead_request *req, int ret)
  106. {
  107. struct crypto_wait *wait = req->base.data;
  108. return crypto_wait_req(ret, wait);
  109. }
  110. struct test_mb_aead_data {
  111. struct scatterlist sg[XBUFSIZE];
  112. struct scatterlist sgout[XBUFSIZE];
  113. struct aead_request *req;
  114. struct crypto_wait wait;
  115. char *xbuf[XBUFSIZE];
  116. char *xoutbuf[XBUFSIZE];
  117. char *axbuf[XBUFSIZE];
  118. };
  119. static int do_mult_aead_op(struct test_mb_aead_data *data, int enc,
  120. u32 num_mb, int *rc)
  121. {
  122. int i, err = 0;
  123. /* Fire up a bunch of concurrent requests */
  124. for (i = 0; i < num_mb; i++) {
  125. if (enc == ENCRYPT)
  126. rc[i] = crypto_aead_encrypt(data[i].req);
  127. else
  128. rc[i] = crypto_aead_decrypt(data[i].req);
  129. }
  130. /* Wait for all requests to finish */
  131. for (i = 0; i < num_mb; i++) {
  132. rc[i] = crypto_wait_req(rc[i], &data[i].wait);
  133. if (rc[i]) {
  134. pr_info("concurrent request %d error %d\n", i, rc[i]);
  135. err = rc[i];
  136. }
  137. }
  138. return err;
  139. }
  140. static int test_mb_aead_jiffies(struct test_mb_aead_data *data, int enc,
  141. int blen, int secs, u32 num_mb)
  142. {
  143. unsigned long start, end;
  144. int bcount;
  145. int ret = 0;
  146. int *rc;
  147. rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);
  148. if (!rc)
  149. return -ENOMEM;
  150. for (start = jiffies, end = start + secs * HZ, bcount = 0;
  151. time_before(jiffies, end); bcount++) {
  152. ret = do_mult_aead_op(data, enc, num_mb, rc);
  153. if (ret)
  154. goto out;
  155. }
  156. pr_cont("%d operations in %d seconds (%llu bytes)\n",
  157. bcount * num_mb, secs, (u64)bcount * blen * num_mb);
  158. out:
  159. kfree(rc);
  160. return ret;
  161. }
  162. static int test_mb_aead_cycles(struct test_mb_aead_data *data, int enc,
  163. int blen, u32 num_mb)
  164. {
  165. unsigned long cycles = 0;
  166. int ret = 0;
  167. int i;
  168. int *rc;
  169. rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);
  170. if (!rc)
  171. return -ENOMEM;
  172. /* Warm-up run. */
  173. for (i = 0; i < 4; i++) {
  174. ret = do_mult_aead_op(data, enc, num_mb, rc);
  175. if (ret)
  176. goto out;
  177. }
  178. /* The real thing. */
  179. for (i = 0; i < 8; i++) {
  180. cycles_t start, end;
  181. start = get_cycles();
  182. ret = do_mult_aead_op(data, enc, num_mb, rc);
  183. end = get_cycles();
  184. if (ret)
  185. goto out;
  186. cycles += end - start;
  187. }
  188. pr_cont("1 operation in %lu cycles (%d bytes)\n",
  189. (cycles + 4) / (8 * num_mb), blen);
  190. out:
  191. kfree(rc);
  192. return ret;
  193. }
  194. static void test_mb_aead_speed(const char *algo, int enc, int secs,
  195. struct aead_speed_template *template,
  196. unsigned int tcount, u8 authsize,
  197. unsigned int aad_size, u8 *keysize, u32 num_mb)
  198. {
  199. struct test_mb_aead_data *data;
  200. struct crypto_aead *tfm;
  201. unsigned int i, j, iv_len;
  202. const int *b_size;
  203. const char *key;
  204. const char *e;
  205. void *assoc;
  206. char *iv;
  207. int ret;
  208. if (aad_size >= PAGE_SIZE) {
  209. pr_err("associate data length (%u) too big\n", aad_size);
  210. return;
  211. }
  212. iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
  213. if (!iv)
  214. return;
  215. if (enc == ENCRYPT)
  216. e = "encryption";
  217. else
  218. e = "decryption";
  219. data = kcalloc(num_mb, sizeof(*data), GFP_KERNEL);
  220. if (!data)
  221. goto out_free_iv;
  222. tfm = crypto_alloc_aead(algo, 0, 0);
  223. if (IS_ERR(tfm)) {
  224. pr_err("failed to load transform for %s: %ld\n",
  225. algo, PTR_ERR(tfm));
  226. goto out_free_data;
  227. }
  228. ret = crypto_aead_setauthsize(tfm, authsize);
  229. if (ret) {
  230. pr_err("alg: aead: Failed to setauthsize for %s: %d\n", algo,
  231. ret);
  232. goto out_free_tfm;
  233. }
  234. for (i = 0; i < num_mb; ++i)
  235. if (testmgr_alloc_buf(data[i].xbuf)) {
  236. while (i--)
  237. testmgr_free_buf(data[i].xbuf);
  238. goto out_free_tfm;
  239. }
  240. for (i = 0; i < num_mb; ++i)
  241. if (testmgr_alloc_buf(data[i].axbuf)) {
  242. while (i--)
  243. testmgr_free_buf(data[i].axbuf);
  244. goto out_free_xbuf;
  245. }
  246. for (i = 0; i < num_mb; ++i)
  247. if (testmgr_alloc_buf(data[i].xoutbuf)) {
  248. while (i--)
  249. testmgr_free_buf(data[i].xoutbuf);
  250. goto out_free_axbuf;
  251. }
  252. for (i = 0; i < num_mb; ++i) {
  253. data[i].req = aead_request_alloc(tfm, GFP_KERNEL);
  254. if (!data[i].req) {
  255. pr_err("alg: aead: Failed to allocate request for %s\n",
  256. algo);
  257. while (i--)
  258. aead_request_free(data[i].req);
  259. goto out_free_xoutbuf;
  260. }
  261. }
  262. for (i = 0; i < num_mb; ++i) {
  263. crypto_init_wait(&data[i].wait);
  264. aead_request_set_callback(data[i].req,
  265. CRYPTO_TFM_REQ_MAY_BACKLOG,
  266. crypto_req_done, &data[i].wait);
  267. }
  268. pr_info("\ntesting speed of multibuffer %s (%s) %s\n", algo,
  269. get_driver_name(crypto_aead, tfm), e);
  270. i = 0;
  271. do {
  272. b_size = aead_sizes;
  273. do {
  274. int bs = round_up(*b_size, crypto_aead_blocksize(tfm));
  275. if (bs + authsize > XBUFSIZE * PAGE_SIZE) {
  276. pr_err("template (%u) too big for buffer (%lu)\n",
  277. authsize + bs,
  278. XBUFSIZE * PAGE_SIZE);
  279. goto out;
  280. }
  281. pr_info("test %u (%d bit key, %d byte blocks): ", i,
  282. *keysize * 8, bs);
  283. /* Set up tfm global state, i.e. the key */
  284. memset(tvmem[0], 0xff, PAGE_SIZE);
  285. key = tvmem[0];
  286. for (j = 0; j < tcount; j++) {
  287. if (template[j].klen == *keysize) {
  288. key = template[j].key;
  289. break;
  290. }
  291. }
  292. crypto_aead_clear_flags(tfm, ~0);
  293. ret = crypto_aead_setkey(tfm, key, *keysize);
  294. if (ret) {
  295. pr_err("setkey() failed flags=%x\n",
  296. crypto_aead_get_flags(tfm));
  297. goto out;
  298. }
  299. iv_len = crypto_aead_ivsize(tfm);
  300. if (iv_len)
  301. memset(iv, 0xff, iv_len);
  302. /* Now setup per request stuff, i.e. buffers */
  303. for (j = 0; j < num_mb; ++j) {
  304. struct test_mb_aead_data *cur = &data[j];
  305. assoc = cur->axbuf[0];
  306. memset(assoc, 0xff, aad_size);
  307. sg_init_aead(cur->sg, cur->xbuf,
  308. bs + (enc ? 0 : authsize),
  309. assoc, aad_size);
  310. sg_init_aead(cur->sgout, cur->xoutbuf,
  311. bs + (enc ? authsize : 0),
  312. assoc, aad_size);
  313. aead_request_set_ad(cur->req, aad_size);
  314. if (!enc) {
  315. aead_request_set_crypt(cur->req,
  316. cur->sgout,
  317. cur->sg,
  318. bs, iv);
  319. ret = crypto_aead_encrypt(cur->req);
  320. ret = do_one_aead_op(cur->req, ret);
  321. if (ret) {
  322. pr_err("calculating auth failed (%d)\n",
  323. ret);
  324. break;
  325. }
  326. }
  327. aead_request_set_crypt(cur->req, cur->sg,
  328. cur->sgout, bs +
  329. (enc ? 0 : authsize),
  330. iv);
  331. }
  332. if (secs) {
  333. ret = test_mb_aead_jiffies(data, enc, bs,
  334. secs, num_mb);
  335. cond_resched();
  336. } else {
  337. ret = test_mb_aead_cycles(data, enc, bs,
  338. num_mb);
  339. }
  340. if (ret) {
  341. pr_err("%s() failed return code=%d\n", e, ret);
  342. break;
  343. }
  344. b_size++;
  345. i++;
  346. } while (*b_size);
  347. keysize++;
  348. } while (*keysize);
  349. out:
  350. for (i = 0; i < num_mb; ++i)
  351. aead_request_free(data[i].req);
  352. out_free_xoutbuf:
  353. for (i = 0; i < num_mb; ++i)
  354. testmgr_free_buf(data[i].xoutbuf);
  355. out_free_axbuf:
  356. for (i = 0; i < num_mb; ++i)
  357. testmgr_free_buf(data[i].axbuf);
  358. out_free_xbuf:
  359. for (i = 0; i < num_mb; ++i)
  360. testmgr_free_buf(data[i].xbuf);
  361. out_free_tfm:
  362. crypto_free_aead(tfm);
  363. out_free_data:
  364. kfree(data);
  365. out_free_iv:
  366. kfree(iv);
  367. }
  368. static int test_aead_jiffies(struct aead_request *req, int enc,
  369. int blen, int secs)
  370. {
  371. unsigned long start, end;
  372. int bcount;
  373. int ret;
  374. for (start = jiffies, end = start + secs * HZ, bcount = 0;
  375. time_before(jiffies, end); bcount++) {
  376. if (enc)
  377. ret = do_one_aead_op(req, crypto_aead_encrypt(req));
  378. else
  379. ret = do_one_aead_op(req, crypto_aead_decrypt(req));
  380. if (ret)
  381. return ret;
  382. }
  383. pr_cont("%d operations in %d seconds (%llu bytes)\n",
  384. bcount, secs, (u64)bcount * blen);
  385. return 0;
  386. }
  387. static int test_aead_cycles(struct aead_request *req, int enc, int blen)
  388. {
  389. unsigned long cycles = 0;
  390. int ret = 0;
  391. int i;
  392. /* Warm-up run. */
  393. for (i = 0; i < 4; i++) {
  394. if (enc)
  395. ret = do_one_aead_op(req, crypto_aead_encrypt(req));
  396. else
  397. ret = do_one_aead_op(req, crypto_aead_decrypt(req));
  398. if (ret)
  399. goto out;
  400. }
  401. /* The real thing. */
  402. for (i = 0; i < 8; i++) {
  403. cycles_t start, end;
  404. start = get_cycles();
  405. if (enc)
  406. ret = do_one_aead_op(req, crypto_aead_encrypt(req));
  407. else
  408. ret = do_one_aead_op(req, crypto_aead_decrypt(req));
  409. end = get_cycles();
  410. if (ret)
  411. goto out;
  412. cycles += end - start;
  413. }
  414. out:
  415. if (ret == 0)
  416. printk("1 operation in %lu cycles (%d bytes)\n",
  417. (cycles + 4) / 8, blen);
  418. return ret;
  419. }
  420. static void test_aead_speed(const char *algo, int enc, unsigned int secs,
  421. struct aead_speed_template *template,
  422. unsigned int tcount, u8 authsize,
  423. unsigned int aad_size, u8 *keysize)
  424. {
  425. unsigned int i, j;
  426. struct crypto_aead *tfm;
  427. int ret = -ENOMEM;
  428. const char *key;
  429. struct aead_request *req;
  430. struct scatterlist *sg;
  431. struct scatterlist *sgout;
  432. const char *e;
  433. void *assoc;
  434. char *iv;
  435. char *xbuf[XBUFSIZE];
  436. char *xoutbuf[XBUFSIZE];
  437. char *axbuf[XBUFSIZE];
  438. const int *b_size;
  439. unsigned int iv_len;
  440. struct crypto_wait wait;
  441. iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
  442. if (!iv)
  443. return;
  444. if (aad_size >= PAGE_SIZE) {
  445. pr_err("associate data length (%u) too big\n", aad_size);
  446. goto out_noxbuf;
  447. }
  448. if (enc == ENCRYPT)
  449. e = "encryption";
  450. else
  451. e = "decryption";
  452. if (testmgr_alloc_buf(xbuf))
  453. goto out_noxbuf;
  454. if (testmgr_alloc_buf(axbuf))
  455. goto out_noaxbuf;
  456. if (testmgr_alloc_buf(xoutbuf))
  457. goto out_nooutbuf;
  458. sg = kmalloc(sizeof(*sg) * 9 * 2, GFP_KERNEL);
  459. if (!sg)
  460. goto out_nosg;
  461. sgout = &sg[9];
  462. tfm = crypto_alloc_aead(algo, 0, 0);
  463. if (IS_ERR(tfm)) {
  464. pr_err("alg: aead: Failed to load transform for %s: %ld\n", algo,
  465. PTR_ERR(tfm));
  466. goto out_notfm;
  467. }
  468. ret = crypto_aead_setauthsize(tfm, authsize);
  469. if (ret) {
  470. pr_err("alg: aead: Failed to setauthsize for %s: %d\n", algo,
  471. ret);
  472. goto out_noreq;
  473. }
  474. crypto_init_wait(&wait);
  475. printk(KERN_INFO "\ntesting speed of %s (%s) %s\n", algo,
  476. get_driver_name(crypto_aead, tfm), e);
  477. req = aead_request_alloc(tfm, GFP_KERNEL);
  478. if (!req) {
  479. pr_err("alg: aead: Failed to allocate request for %s\n",
  480. algo);
  481. goto out_noreq;
  482. }
  483. aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
  484. crypto_req_done, &wait);
  485. i = 0;
  486. do {
  487. b_size = aead_sizes;
  488. do {
  489. u32 bs = round_up(*b_size, crypto_aead_blocksize(tfm));
  490. assoc = axbuf[0];
  491. memset(assoc, 0xff, aad_size);
  492. if ((*keysize + bs) > TVMEMSIZE * PAGE_SIZE) {
  493. pr_err("template (%u) too big for tvmem (%lu)\n",
  494. *keysize + bs,
  495. TVMEMSIZE * PAGE_SIZE);
  496. goto out;
  497. }
  498. key = tvmem[0];
  499. for (j = 0; j < tcount; j++) {
  500. if (template[j].klen == *keysize) {
  501. key = template[j].key;
  502. break;
  503. }
  504. }
  505. ret = crypto_aead_setkey(tfm, key, *keysize);
  506. if (ret) {
  507. pr_err("setkey() failed flags=%x: %d\n",
  508. crypto_aead_get_flags(tfm), ret);
  509. goto out;
  510. }
  511. iv_len = crypto_aead_ivsize(tfm);
  512. if (iv_len)
  513. memset(iv, 0xff, iv_len);
  514. crypto_aead_clear_flags(tfm, ~0);
  515. printk(KERN_INFO "test %u (%d bit key, %d byte blocks): ",
  516. i, *keysize * 8, bs);
  517. memset(tvmem[0], 0xff, PAGE_SIZE);
  518. sg_init_aead(sg, xbuf, bs + (enc ? 0 : authsize),
  519. assoc, aad_size);
  520. sg_init_aead(sgout, xoutbuf,
  521. bs + (enc ? authsize : 0), assoc,
  522. aad_size);
  523. aead_request_set_ad(req, aad_size);
  524. if (!enc) {
  525. /*
  526. * For decryption we need a proper auth so
  527. * we do the encryption path once with buffers
  528. * reversed (input <-> output) to calculate it
  529. */
  530. aead_request_set_crypt(req, sgout, sg,
  531. bs, iv);
  532. ret = do_one_aead_op(req,
  533. crypto_aead_encrypt(req));
  534. if (ret) {
  535. pr_err("calculating auth failed (%d)\n",
  536. ret);
  537. break;
  538. }
  539. }
  540. aead_request_set_crypt(req, sg, sgout,
  541. bs + (enc ? 0 : authsize),
  542. iv);
  543. if (secs) {
  544. ret = test_aead_jiffies(req, enc, bs,
  545. secs);
  546. cond_resched();
  547. } else {
  548. ret = test_aead_cycles(req, enc, bs);
  549. }
  550. if (ret) {
  551. pr_err("%s() failed return code=%d\n", e, ret);
  552. break;
  553. }
  554. b_size++;
  555. i++;
  556. } while (*b_size);
  557. keysize++;
  558. } while (*keysize);
  559. out:
  560. aead_request_free(req);
  561. out_noreq:
  562. crypto_free_aead(tfm);
  563. out_notfm:
  564. kfree(sg);
  565. out_nosg:
  566. testmgr_free_buf(xoutbuf);
  567. out_nooutbuf:
  568. testmgr_free_buf(axbuf);
  569. out_noaxbuf:
  570. testmgr_free_buf(xbuf);
  571. out_noxbuf:
  572. kfree(iv);
  573. }
  574. static void test_hash_sg_init(struct scatterlist *sg)
  575. {
  576. int i;
  577. sg_init_table(sg, TVMEMSIZE);
  578. for (i = 0; i < TVMEMSIZE; i++) {
  579. sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
  580. memset(tvmem[i], 0xff, PAGE_SIZE);
  581. }
  582. }
  583. static inline int do_one_ahash_op(struct ahash_request *req, int ret)
  584. {
  585. struct crypto_wait *wait = req->base.data;
  586. return crypto_wait_req(ret, wait);
  587. }
  588. static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
  589. char *out, int secs)
  590. {
  591. unsigned long start, end;
  592. int bcount;
  593. int ret;
  594. for (start = jiffies, end = start + secs * HZ, bcount = 0;
  595. time_before(jiffies, end); bcount++) {
  596. ret = do_one_ahash_op(req, crypto_ahash_digest(req));
  597. if (ret)
  598. return ret;
  599. }
  600. printk("%6u opers/sec, %9lu bytes/sec\n",
  601. bcount / secs, ((long)bcount * blen) / secs);
  602. return 0;
  603. }
  604. static int test_ahash_jiffies(struct ahash_request *req, int blen,
  605. int plen, char *out, int secs)
  606. {
  607. unsigned long start, end;
  608. int bcount, pcount;
  609. int ret;
  610. if (plen == blen)
  611. return test_ahash_jiffies_digest(req, blen, out, secs);
  612. for (start = jiffies, end = start + secs * HZ, bcount = 0;
  613. time_before(jiffies, end); bcount++) {
  614. ret = do_one_ahash_op(req, crypto_ahash_init(req));
  615. if (ret)
  616. return ret;
  617. for (pcount = 0; pcount < blen; pcount += plen) {
  618. ret = do_one_ahash_op(req, crypto_ahash_update(req));
  619. if (ret)
  620. return ret;
  621. }
  622. /* we assume there is enough space in 'out' for the result */
  623. ret = do_one_ahash_op(req, crypto_ahash_final(req));
  624. if (ret)
  625. return ret;
  626. }
  627. pr_cont("%6u opers/sec, %9lu bytes/sec\n",
  628. bcount / secs, ((long)bcount * blen) / secs);
  629. return 0;
  630. }
  631. static int test_ahash_cycles_digest(struct ahash_request *req, int blen,
  632. char *out)
  633. {
  634. unsigned long cycles = 0;
  635. int ret, i;
  636. /* Warm-up run. */
  637. for (i = 0; i < 4; i++) {
  638. ret = do_one_ahash_op(req, crypto_ahash_digest(req));
  639. if (ret)
  640. goto out;
  641. }
  642. /* The real thing. */
  643. for (i = 0; i < 8; i++) {
  644. cycles_t start, end;
  645. start = get_cycles();
  646. ret = do_one_ahash_op(req, crypto_ahash_digest(req));
  647. if (ret)
  648. goto out;
  649. end = get_cycles();
  650. cycles += end - start;
  651. }
  652. out:
  653. if (ret)
  654. return ret;
  655. pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
  656. cycles / 8, cycles / (8 * blen));
  657. return 0;
  658. }
  659. static int test_ahash_cycles(struct ahash_request *req, int blen,
  660. int plen, char *out)
  661. {
  662. unsigned long cycles = 0;
  663. int i, pcount, ret;
  664. if (plen == blen)
  665. return test_ahash_cycles_digest(req, blen, out);
  666. /* Warm-up run. */
  667. for (i = 0; i < 4; i++) {
  668. ret = do_one_ahash_op(req, crypto_ahash_init(req));
  669. if (ret)
  670. goto out;
  671. for (pcount = 0; pcount < blen; pcount += plen) {
  672. ret = do_one_ahash_op(req, crypto_ahash_update(req));
  673. if (ret)
  674. goto out;
  675. }
  676. ret = do_one_ahash_op(req, crypto_ahash_final(req));
  677. if (ret)
  678. goto out;
  679. }
  680. /* The real thing. */
  681. for (i = 0; i < 8; i++) {
  682. cycles_t start, end;
  683. start = get_cycles();
  684. ret = do_one_ahash_op(req, crypto_ahash_init(req));
  685. if (ret)
  686. goto out;
  687. for (pcount = 0; pcount < blen; pcount += plen) {
  688. ret = do_one_ahash_op(req, crypto_ahash_update(req));
  689. if (ret)
  690. goto out;
  691. }
  692. ret = do_one_ahash_op(req, crypto_ahash_final(req));
  693. if (ret)
  694. goto out;
  695. end = get_cycles();
  696. cycles += end - start;
  697. }
  698. out:
  699. if (ret)
  700. return ret;
  701. pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
  702. cycles / 8, cycles / (8 * blen));
  703. return 0;
  704. }
  705. static void test_ahash_speed_common(const char *algo, unsigned int secs,
  706. struct hash_speed *speed, unsigned mask)
  707. {
  708. struct scatterlist sg[TVMEMSIZE];
  709. struct crypto_wait wait;
  710. struct ahash_request *req;
  711. struct crypto_ahash *tfm;
  712. char *output;
  713. int i, ret;
  714. tfm = crypto_alloc_ahash(algo, 0, mask);
  715. if (IS_ERR(tfm)) {
  716. pr_err("failed to load transform for %s: %ld\n",
  717. algo, PTR_ERR(tfm));
  718. return;
  719. }
  720. printk(KERN_INFO "\ntesting speed of async %s (%s)\n", algo,
  721. get_driver_name(crypto_ahash, tfm));
  722. if (crypto_ahash_digestsize(tfm) > MAX_DIGEST_SIZE) {
  723. pr_err("digestsize(%u) > %d\n", crypto_ahash_digestsize(tfm),
  724. MAX_DIGEST_SIZE);
  725. goto out;
  726. }
  727. test_hash_sg_init(sg);
  728. req = ahash_request_alloc(tfm, GFP_KERNEL);
  729. if (!req) {
  730. pr_err("ahash request allocation failure\n");
  731. goto out;
  732. }
  733. crypto_init_wait(&wait);
  734. ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
  735. crypto_req_done, &wait);
  736. output = kmalloc(MAX_DIGEST_SIZE, GFP_KERNEL);
  737. if (!output)
  738. goto out_nomem;
  739. for (i = 0; speed[i].blen != 0; i++) {
  740. if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
  741. pr_err("template (%u) too big for tvmem (%lu)\n",
  742. speed[i].blen, TVMEMSIZE * PAGE_SIZE);
  743. break;
  744. }
  745. if (klen)
  746. crypto_ahash_setkey(tfm, tvmem[0], klen);
  747. pr_info("test%3u "
  748. "(%5u byte blocks,%5u bytes per update,%4u updates): ",
  749. i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
  750. ahash_request_set_crypt(req, sg, output, speed[i].plen);
  751. if (secs) {
  752. ret = test_ahash_jiffies(req, speed[i].blen,
  753. speed[i].plen, output, secs);
  754. cond_resched();
  755. } else {
  756. ret = test_ahash_cycles(req, speed[i].blen,
  757. speed[i].plen, output);
  758. }
  759. if (ret) {
  760. pr_err("hashing failed ret=%d\n", ret);
  761. break;
  762. }
  763. }
  764. kfree(output);
  765. out_nomem:
  766. ahash_request_free(req);
  767. out:
  768. crypto_free_ahash(tfm);
  769. }
  770. static void test_ahash_speed(const char *algo, unsigned int secs,
  771. struct hash_speed *speed)
  772. {
  773. return test_ahash_speed_common(algo, secs, speed, 0);
  774. }
  775. static void test_hash_speed(const char *algo, unsigned int secs,
  776. struct hash_speed *speed)
  777. {
  778. return test_ahash_speed_common(algo, secs, speed, CRYPTO_ALG_ASYNC);
  779. }
  780. struct test_mb_skcipher_data {
  781. struct scatterlist sg[XBUFSIZE];
  782. struct skcipher_request *req;
  783. struct crypto_wait wait;
  784. char *xbuf[XBUFSIZE];
  785. };
  786. static int do_mult_acipher_op(struct test_mb_skcipher_data *data, int enc,
  787. u32 num_mb, int *rc)
  788. {
  789. int i, err = 0;
  790. /* Fire up a bunch of concurrent requests */
  791. for (i = 0; i < num_mb; i++) {
  792. if (enc == ENCRYPT)
  793. rc[i] = crypto_skcipher_encrypt(data[i].req);
  794. else
  795. rc[i] = crypto_skcipher_decrypt(data[i].req);
  796. }
  797. /* Wait for all requests to finish */
  798. for (i = 0; i < num_mb; i++) {
  799. rc[i] = crypto_wait_req(rc[i], &data[i].wait);
  800. if (rc[i]) {
  801. pr_info("concurrent request %d error %d\n", i, rc[i]);
  802. err = rc[i];
  803. }
  804. }
  805. return err;
  806. }
  807. static int test_mb_acipher_jiffies(struct test_mb_skcipher_data *data, int enc,
  808. int blen, int secs, u32 num_mb)
  809. {
  810. unsigned long start, end;
  811. int bcount;
  812. int ret = 0;
  813. int *rc;
  814. rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);
  815. if (!rc)
  816. return -ENOMEM;
  817. for (start = jiffies, end = start + secs * HZ, bcount = 0;
  818. time_before(jiffies, end); bcount++) {
  819. ret = do_mult_acipher_op(data, enc, num_mb, rc);
  820. if (ret)
  821. goto out;
  822. }
  823. pr_cont("%d operations in %d seconds (%llu bytes)\n",
  824. bcount * num_mb, secs, (u64)bcount * blen * num_mb);
  825. out:
  826. kfree(rc);
  827. return ret;
  828. }
  829. static int test_mb_acipher_cycles(struct test_mb_skcipher_data *data, int enc,
  830. int blen, u32 num_mb)
  831. {
  832. unsigned long cycles = 0;
  833. int ret = 0;
  834. int i;
  835. int *rc;
  836. rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);
  837. if (!rc)
  838. return -ENOMEM;
  839. /* Warm-up run. */
  840. for (i = 0; i < 4; i++) {
  841. ret = do_mult_acipher_op(data, enc, num_mb, rc);
  842. if (ret)
  843. goto out;
  844. }
  845. /* The real thing. */
  846. for (i = 0; i < 8; i++) {
  847. cycles_t start, end;
  848. start = get_cycles();
  849. ret = do_mult_acipher_op(data, enc, num_mb, rc);
  850. end = get_cycles();
  851. if (ret)
  852. goto out;
  853. cycles += end - start;
  854. }
  855. pr_cont("1 operation in %lu cycles (%d bytes)\n",
  856. (cycles + 4) / (8 * num_mb), blen);
  857. out:
  858. kfree(rc);
  859. return ret;
  860. }
  861. static void test_mb_skcipher_speed(const char *algo, int enc, int secs,
  862. struct cipher_speed_template *template,
  863. unsigned int tcount, u8 *keysize, u32 num_mb)
  864. {
  865. struct test_mb_skcipher_data *data;
  866. struct crypto_skcipher *tfm;
  867. unsigned int i, j, iv_len;
  868. const int *b_size;
  869. const char *key;
  870. const char *e;
  871. char iv[128];
  872. int ret;
  873. if (enc == ENCRYPT)
  874. e = "encryption";
  875. else
  876. e = "decryption";
  877. data = kcalloc(num_mb, sizeof(*data), GFP_KERNEL);
  878. if (!data)
  879. return;
  880. tfm = crypto_alloc_skcipher(algo, 0, 0);
  881. if (IS_ERR(tfm)) {
  882. pr_err("failed to load transform for %s: %ld\n",
  883. algo, PTR_ERR(tfm));
  884. goto out_free_data;
  885. }
  886. for (i = 0; i < num_mb; ++i)
  887. if (testmgr_alloc_buf(data[i].xbuf)) {
  888. while (i--)
  889. testmgr_free_buf(data[i].xbuf);
  890. goto out_free_tfm;
  891. }
  892. for (i = 0; i < num_mb; ++i) {
  893. data[i].req = skcipher_request_alloc(tfm, GFP_KERNEL);
  894. if (!data[i].req) {
  895. pr_err("alg: skcipher: Failed to allocate request for %s\n",
  896. algo);
  897. while (i--)
  898. skcipher_request_free(data[i].req);
  899. goto out_free_xbuf;
  900. }
  901. }
  902. for (i = 0; i < num_mb; ++i) {
  903. skcipher_request_set_callback(data[i].req,
  904. CRYPTO_TFM_REQ_MAY_BACKLOG,
  905. crypto_req_done, &data[i].wait);
  906. crypto_init_wait(&data[i].wait);
  907. }
  908. pr_info("\ntesting speed of multibuffer %s (%s) %s\n", algo,
  909. get_driver_name(crypto_skcipher, tfm), e);
  910. i = 0;
  911. do {
  912. b_size = block_sizes;
  913. do {
  914. u32 bs = round_up(*b_size, crypto_skcipher_blocksize(tfm));
  915. if (bs > XBUFSIZE * PAGE_SIZE) {
  916. pr_err("template (%u) too big for buffer (%lu)\n",
  917. bs, XBUFSIZE * PAGE_SIZE);
  918. goto out;
  919. }
  920. pr_info("test %u (%d bit key, %d byte blocks): ", i,
  921. *keysize * 8, bs);
  922. /* Set up tfm global state, i.e. the key */
  923. memset(tvmem[0], 0xff, PAGE_SIZE);
  924. key = tvmem[0];
  925. for (j = 0; j < tcount; j++) {
  926. if (template[j].klen == *keysize) {
  927. key = template[j].key;
  928. break;
  929. }
  930. }
  931. crypto_skcipher_clear_flags(tfm, ~0);
  932. ret = crypto_skcipher_setkey(tfm, key, *keysize);
  933. if (ret) {
  934. pr_err("setkey() failed flags=%x\n",
  935. crypto_skcipher_get_flags(tfm));
  936. goto out;
  937. }
  938. iv_len = crypto_skcipher_ivsize(tfm);
  939. if (iv_len)
  940. memset(&iv, 0xff, iv_len);
  941. /* Now setup per request stuff, i.e. buffers */
  942. for (j = 0; j < num_mb; ++j) {
  943. struct test_mb_skcipher_data *cur = &data[j];
  944. unsigned int k = bs;
  945. unsigned int pages = DIV_ROUND_UP(k, PAGE_SIZE);
  946. unsigned int p = 0;
  947. sg_init_table(cur->sg, pages);
  948. while (k > PAGE_SIZE) {
  949. sg_set_buf(cur->sg + p, cur->xbuf[p],
  950. PAGE_SIZE);
  951. memset(cur->xbuf[p], 0xff, PAGE_SIZE);
  952. p++;
  953. k -= PAGE_SIZE;
  954. }
  955. sg_set_buf(cur->sg + p, cur->xbuf[p], k);
  956. memset(cur->xbuf[p], 0xff, k);
  957. skcipher_request_set_crypt(cur->req, cur->sg,
  958. cur->sg, bs, iv);
  959. }
  960. if (secs) {
  961. ret = test_mb_acipher_jiffies(data, enc,
  962. bs, secs,
  963. num_mb);
  964. cond_resched();
  965. } else {
  966. ret = test_mb_acipher_cycles(data, enc,
  967. bs, num_mb);
  968. }
  969. if (ret) {
  970. pr_err("%s() failed flags=%x\n", e,
  971. crypto_skcipher_get_flags(tfm));
  972. break;
  973. }
  974. b_size++;
  975. i++;
  976. } while (*b_size);
  977. keysize++;
  978. } while (*keysize);
  979. out:
  980. for (i = 0; i < num_mb; ++i)
  981. skcipher_request_free(data[i].req);
  982. out_free_xbuf:
  983. for (i = 0; i < num_mb; ++i)
  984. testmgr_free_buf(data[i].xbuf);
  985. out_free_tfm:
  986. crypto_free_skcipher(tfm);
  987. out_free_data:
  988. kfree(data);
  989. }
  990. static inline int do_one_acipher_op(struct skcipher_request *req, int ret)
  991. {
  992. struct crypto_wait *wait = req->base.data;
  993. return crypto_wait_req(ret, wait);
  994. }
  995. static int test_acipher_jiffies(struct skcipher_request *req, int enc,
  996. int blen, int secs)
  997. {
  998. unsigned long start, end;
  999. int bcount;
  1000. int ret;
  1001. for (start = jiffies, end = start + secs * HZ, bcount = 0;
  1002. time_before(jiffies, end); bcount++) {
  1003. if (enc)
  1004. ret = do_one_acipher_op(req,
  1005. crypto_skcipher_encrypt(req));
  1006. else
  1007. ret = do_one_acipher_op(req,
  1008. crypto_skcipher_decrypt(req));
  1009. if (ret)
  1010. return ret;
  1011. }
  1012. pr_cont("%d operations in %d seconds (%llu bytes)\n",
  1013. bcount, secs, (u64)bcount * blen);
  1014. return 0;
  1015. }
  1016. static int test_acipher_cycles(struct skcipher_request *req, int enc,
  1017. int blen)
  1018. {
  1019. unsigned long cycles = 0;
  1020. int ret = 0;
  1021. int i;
  1022. /* Warm-up run. */
  1023. for (i = 0; i < 4; i++) {
  1024. if (enc)
  1025. ret = do_one_acipher_op(req,
  1026. crypto_skcipher_encrypt(req));
  1027. else
  1028. ret = do_one_acipher_op(req,
  1029. crypto_skcipher_decrypt(req));
  1030. if (ret)
  1031. goto out;
  1032. }
  1033. /* The real thing. */
  1034. for (i = 0; i < 8; i++) {
  1035. cycles_t start, end;
  1036. start = get_cycles();
  1037. if (enc)
  1038. ret = do_one_acipher_op(req,
  1039. crypto_skcipher_encrypt(req));
  1040. else
  1041. ret = do_one_acipher_op(req,
  1042. crypto_skcipher_decrypt(req));
  1043. end = get_cycles();
  1044. if (ret)
  1045. goto out;
  1046. cycles += end - start;
  1047. }
  1048. out:
  1049. if (ret == 0)
  1050. pr_cont("1 operation in %lu cycles (%d bytes)\n",
  1051. (cycles + 4) / 8, blen);
  1052. return ret;
  1053. }
  1054. static void test_skcipher_speed(const char *algo, int enc, unsigned int secs,
  1055. struct cipher_speed_template *template,
  1056. unsigned int tcount, u8 *keysize, bool async)
  1057. {
  1058. unsigned int ret, i, j, k, iv_len;
  1059. struct crypto_wait wait;
  1060. const char *key;
  1061. char iv[128];
  1062. struct skcipher_request *req;
  1063. struct crypto_skcipher *tfm;
  1064. const int *b_size;
  1065. const char *e;
  1066. if (enc == ENCRYPT)
  1067. e = "encryption";
  1068. else
  1069. e = "decryption";
  1070. crypto_init_wait(&wait);
  1071. tfm = crypto_alloc_skcipher(algo, 0, async ? 0 : CRYPTO_ALG_ASYNC);
  1072. if (IS_ERR(tfm)) {
  1073. pr_err("failed to load transform for %s: %ld\n", algo,
  1074. PTR_ERR(tfm));
  1075. return;
  1076. }
  1077. pr_info("\ntesting speed of %s %s (%s) %s\n", async ? "async" : "sync",
  1078. algo, get_driver_name(crypto_skcipher, tfm), e);
  1079. req = skcipher_request_alloc(tfm, GFP_KERNEL);
  1080. if (!req) {
  1081. pr_err("tcrypt: skcipher: Failed to allocate request for %s\n",
  1082. algo);
  1083. goto out;
  1084. }
  1085. skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
  1086. crypto_req_done, &wait);
  1087. i = 0;
  1088. do {
  1089. b_size = block_sizes;
  1090. do {
  1091. u32 bs = round_up(*b_size, crypto_skcipher_blocksize(tfm));
  1092. struct scatterlist sg[TVMEMSIZE];
  1093. if ((*keysize + bs) > TVMEMSIZE * PAGE_SIZE) {
  1094. pr_err("template (%u) too big for "
  1095. "tvmem (%lu)\n", *keysize + bs,
  1096. TVMEMSIZE * PAGE_SIZE);
  1097. goto out_free_req;
  1098. }
  1099. pr_info("test %u (%d bit key, %d byte blocks): ", i,
  1100. *keysize * 8, bs);
  1101. memset(tvmem[0], 0xff, PAGE_SIZE);
  1102. /* set key, plain text and IV */
  1103. key = tvmem[0];
  1104. for (j = 0; j < tcount; j++) {
  1105. if (template[j].klen == *keysize) {
  1106. key = template[j].key;
  1107. break;
  1108. }
  1109. }
  1110. crypto_skcipher_clear_flags(tfm, ~0);
  1111. ret = crypto_skcipher_setkey(tfm, key, *keysize);
  1112. if (ret) {
  1113. pr_err("setkey() failed flags=%x\n",
  1114. crypto_skcipher_get_flags(tfm));
  1115. goto out_free_req;
  1116. }
  1117. k = *keysize + bs;
  1118. sg_init_table(sg, DIV_ROUND_UP(k, PAGE_SIZE));
  1119. if (k > PAGE_SIZE) {
  1120. sg_set_buf(sg, tvmem[0] + *keysize,
  1121. PAGE_SIZE - *keysize);
  1122. k -= PAGE_SIZE;
  1123. j = 1;
  1124. while (k > PAGE_SIZE) {
  1125. sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
  1126. memset(tvmem[j], 0xff, PAGE_SIZE);
  1127. j++;
  1128. k -= PAGE_SIZE;
  1129. }
  1130. sg_set_buf(sg + j, tvmem[j], k);
  1131. memset(tvmem[j], 0xff, k);
  1132. } else {
  1133. sg_set_buf(sg, tvmem[0] + *keysize, bs);
  1134. }
  1135. iv_len = crypto_skcipher_ivsize(tfm);
  1136. if (iv_len)
  1137. memset(&iv, 0xff, iv_len);
  1138. skcipher_request_set_crypt(req, sg, sg, bs, iv);
  1139. if (secs) {
  1140. ret = test_acipher_jiffies(req, enc,
  1141. bs, secs);
  1142. cond_resched();
  1143. } else {
  1144. ret = test_acipher_cycles(req, enc,
  1145. bs);
  1146. }
  1147. if (ret) {
  1148. pr_err("%s() failed flags=%x\n", e,
  1149. crypto_skcipher_get_flags(tfm));
  1150. break;
  1151. }
  1152. b_size++;
  1153. i++;
  1154. } while (*b_size);
  1155. keysize++;
  1156. } while (*keysize);
  1157. out_free_req:
  1158. skcipher_request_free(req);
  1159. out:
  1160. crypto_free_skcipher(tfm);
  1161. }
  1162. static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
  1163. struct cipher_speed_template *template,
  1164. unsigned int tcount, u8 *keysize)
  1165. {
  1166. return test_skcipher_speed(algo, enc, secs, template, tcount, keysize,
  1167. true);
  1168. }
  1169. static void test_cipher_speed(const char *algo, int enc, unsigned int secs,
  1170. struct cipher_speed_template *template,
  1171. unsigned int tcount, u8 *keysize)
  1172. {
  1173. return test_skcipher_speed(algo, enc, secs, template, tcount, keysize,
  1174. false);
  1175. }
  1176. static inline int tcrypt_test(const char *alg)
  1177. {
  1178. int ret;
  1179. pr_debug("testing %s\n", alg);
  1180. ret = alg_test(alg, alg, 0, 0);
  1181. /* non-fips algs return -EINVAL or -ECANCELED in fips mode */
  1182. if (fips_enabled && (ret == -EINVAL || ret == -ECANCELED))
  1183. ret = 0;
  1184. return ret;
  1185. }
  1186. static int do_test(const char *alg, u32 type, u32 mask, int m, u32 num_mb)
  1187. {
  1188. int i;
  1189. int ret = 0;
  1190. switch (m) {
  1191. case 0:
  1192. if (alg) {
  1193. if (!crypto_has_alg(alg, type,
  1194. mask ?: CRYPTO_ALG_TYPE_MASK))
  1195. ret = -ENOENT;
  1196. break;
  1197. }
  1198. for (i = 1; i < 200; i++)
  1199. ret = min(ret, do_test(NULL, 0, 0, i, num_mb));
  1200. break;
  1201. case 1:
  1202. ret = min(ret, tcrypt_test("md5"));
  1203. break;
  1204. case 2:
  1205. ret = min(ret, tcrypt_test("sha1"));
  1206. break;
  1207. case 3:
  1208. ret = min(ret, tcrypt_test("ecb(des)"));
  1209. ret = min(ret, tcrypt_test("cbc(des)"));
  1210. ret = min(ret, tcrypt_test("ctr(des)"));
  1211. break;
  1212. case 4:
  1213. ret = min(ret, tcrypt_test("ecb(des3_ede)"));
  1214. ret = min(ret, tcrypt_test("cbc(des3_ede)"));
  1215. ret = min(ret, tcrypt_test("ctr(des3_ede)"));
  1216. break;
  1217. case 5:
  1218. ret = min(ret, tcrypt_test("md4"));
  1219. break;
  1220. case 6:
  1221. ret = min(ret, tcrypt_test("sha256"));
  1222. break;
  1223. case 7:
  1224. ret = min(ret, tcrypt_test("ecb(blowfish)"));
  1225. ret = min(ret, tcrypt_test("cbc(blowfish)"));
  1226. ret = min(ret, tcrypt_test("ctr(blowfish)"));
  1227. break;
  1228. case 8:
  1229. ret = min(ret, tcrypt_test("ecb(twofish)"));
  1230. ret = min(ret, tcrypt_test("cbc(twofish)"));
  1231. ret = min(ret, tcrypt_test("ctr(twofish)"));
  1232. ret = min(ret, tcrypt_test("lrw(twofish)"));
  1233. ret = min(ret, tcrypt_test("xts(twofish)"));
  1234. break;
  1235. case 9:
  1236. ret = min(ret, tcrypt_test("ecb(serpent)"));
  1237. ret = min(ret, tcrypt_test("cbc(serpent)"));
  1238. ret = min(ret, tcrypt_test("ctr(serpent)"));
  1239. ret = min(ret, tcrypt_test("lrw(serpent)"));
  1240. ret = min(ret, tcrypt_test("xts(serpent)"));
  1241. break;
  1242. case 10:
  1243. ret = min(ret, tcrypt_test("ecb(aes)"));
  1244. ret = min(ret, tcrypt_test("cbc(aes)"));
  1245. ret = min(ret, tcrypt_test("lrw(aes)"));
  1246. ret = min(ret, tcrypt_test("xts(aes)"));
  1247. ret = min(ret, tcrypt_test("ctr(aes)"));
  1248. ret = min(ret, tcrypt_test("rfc3686(ctr(aes))"));
  1249. ret = min(ret, tcrypt_test("ofb(aes)"));
  1250. ret = min(ret, tcrypt_test("cfb(aes)"));
  1251. ret = min(ret, tcrypt_test("xctr(aes)"));
  1252. break;
  1253. case 11:
  1254. ret = min(ret, tcrypt_test("sha384"));
  1255. break;
  1256. case 12:
  1257. ret = min(ret, tcrypt_test("sha512"));
  1258. break;
  1259. case 13:
  1260. ret = min(ret, tcrypt_test("deflate"));
  1261. break;
  1262. case 14:
  1263. ret = min(ret, tcrypt_test("ecb(cast5)"));
  1264. ret = min(ret, tcrypt_test("cbc(cast5)"));
  1265. ret = min(ret, tcrypt_test("ctr(cast5)"));
  1266. break;
  1267. case 15:
  1268. ret = min(ret, tcrypt_test("ecb(cast6)"));
  1269. ret = min(ret, tcrypt_test("cbc(cast6)"));
  1270. ret = min(ret, tcrypt_test("ctr(cast6)"));
  1271. ret = min(ret, tcrypt_test("lrw(cast6)"));
  1272. ret = min(ret, tcrypt_test("xts(cast6)"));
  1273. break;
  1274. case 16:
  1275. ret = min(ret, tcrypt_test("ecb(arc4)"));
  1276. break;
  1277. case 17:
  1278. ret = min(ret, tcrypt_test("michael_mic"));
  1279. break;
  1280. case 18:
  1281. ret = min(ret, tcrypt_test("crc32c"));
  1282. break;
  1283. case 19:
  1284. ret = min(ret, tcrypt_test("ecb(tea)"));
  1285. break;
  1286. case 20:
  1287. ret = min(ret, tcrypt_test("ecb(xtea)"));
  1288. break;
  1289. case 21:
  1290. ret = min(ret, tcrypt_test("ecb(khazad)"));
  1291. break;
  1292. case 22:
  1293. ret = min(ret, tcrypt_test("wp512"));
  1294. break;
  1295. case 23:
  1296. ret = min(ret, tcrypt_test("wp384"));
  1297. break;
  1298. case 24:
  1299. ret = min(ret, tcrypt_test("wp256"));
  1300. break;
  1301. case 26:
  1302. ret = min(ret, tcrypt_test("ecb(anubis)"));
  1303. ret = min(ret, tcrypt_test("cbc(anubis)"));
  1304. break;
  1305. case 30:
  1306. ret = min(ret, tcrypt_test("ecb(xeta)"));
  1307. break;
  1308. case 31:
  1309. ret = min(ret, tcrypt_test("pcbc(fcrypt)"));
  1310. break;
  1311. case 32:
  1312. ret = min(ret, tcrypt_test("ecb(camellia)"));
  1313. ret = min(ret, tcrypt_test("cbc(camellia)"));
  1314. ret = min(ret, tcrypt_test("ctr(camellia)"));
  1315. ret = min(ret, tcrypt_test("lrw(camellia)"));
  1316. ret = min(ret, tcrypt_test("xts(camellia)"));
  1317. break;
  1318. case 33:
  1319. ret = min(ret, tcrypt_test("sha224"));
  1320. break;
  1321. case 35:
  1322. ret = min(ret, tcrypt_test("gcm(aes)"));
  1323. break;
  1324. case 36:
  1325. ret = min(ret, tcrypt_test("lzo"));
  1326. break;
  1327. case 37:
  1328. ret = min(ret, tcrypt_test("ccm(aes)"));
  1329. break;
  1330. case 38:
  1331. ret = min(ret, tcrypt_test("cts(cbc(aes))"));
  1332. break;
  1333. case 39:
  1334. ret = min(ret, tcrypt_test("xxhash64"));
  1335. break;
  1336. case 40:
  1337. ret = min(ret, tcrypt_test("rmd160"));
  1338. break;
  1339. case 42:
  1340. ret = min(ret, tcrypt_test("blake2b-512"));
  1341. break;
  1342. case 43:
  1343. ret = min(ret, tcrypt_test("ecb(seed)"));
  1344. break;
  1345. case 45:
  1346. ret = min(ret, tcrypt_test("rfc4309(ccm(aes))"));
  1347. break;
  1348. case 46:
  1349. ret = min(ret, tcrypt_test("ghash"));
  1350. break;
  1351. case 47:
  1352. ret = min(ret, tcrypt_test("crct10dif"));
  1353. break;
  1354. case 48:
  1355. ret = min(ret, tcrypt_test("sha3-224"));
  1356. break;
  1357. case 49:
  1358. ret = min(ret, tcrypt_test("sha3-256"));
  1359. break;
  1360. case 50:
  1361. ret = min(ret, tcrypt_test("sha3-384"));
  1362. break;
  1363. case 51:
  1364. ret = min(ret, tcrypt_test("sha3-512"));
  1365. break;
  1366. case 52:
  1367. ret = min(ret, tcrypt_test("sm3"));
  1368. break;
  1369. case 53:
  1370. ret = min(ret, tcrypt_test("streebog256"));
  1371. break;
  1372. case 54:
  1373. ret = min(ret, tcrypt_test("streebog512"));
  1374. break;
  1375. case 55:
  1376. ret = min(ret, tcrypt_test("gcm(sm4)"));
  1377. break;
  1378. case 56:
  1379. ret = min(ret, tcrypt_test("ccm(sm4)"));
  1380. break;
  1381. case 57:
  1382. ret = min(ret, tcrypt_test("polyval"));
  1383. break;
  1384. case 58:
  1385. ret = min(ret, tcrypt_test("gcm(aria)"));
  1386. break;
  1387. case 100:
  1388. ret = min(ret, tcrypt_test("hmac(md5)"));
  1389. break;
  1390. case 101:
  1391. ret = min(ret, tcrypt_test("hmac(sha1)"));
  1392. break;
  1393. case 102:
  1394. ret = min(ret, tcrypt_test("hmac(sha256)"));
  1395. break;
  1396. case 103:
  1397. ret = min(ret, tcrypt_test("hmac(sha384)"));
  1398. break;
  1399. case 104:
  1400. ret = min(ret, tcrypt_test("hmac(sha512)"));
  1401. break;
  1402. case 105:
  1403. ret = min(ret, tcrypt_test("hmac(sha224)"));
  1404. break;
  1405. case 106:
  1406. ret = min(ret, tcrypt_test("xcbc(aes)"));
  1407. break;
  1408. case 108:
  1409. ret = min(ret, tcrypt_test("hmac(rmd160)"));
  1410. break;
  1411. case 109:
  1412. ret = min(ret, tcrypt_test("vmac64(aes)"));
  1413. break;
  1414. case 111:
  1415. ret = min(ret, tcrypt_test("hmac(sha3-224)"));
  1416. break;
  1417. case 112:
  1418. ret = min(ret, tcrypt_test("hmac(sha3-256)"));
  1419. break;
  1420. case 113:
  1421. ret = min(ret, tcrypt_test("hmac(sha3-384)"));
  1422. break;
  1423. case 114:
  1424. ret = min(ret, tcrypt_test("hmac(sha3-512)"));
  1425. break;
  1426. case 115:
  1427. ret = min(ret, tcrypt_test("hmac(streebog256)"));
  1428. break;
  1429. case 116:
  1430. ret = min(ret, tcrypt_test("hmac(streebog512)"));
  1431. break;
  1432. case 150:
  1433. ret = min(ret, tcrypt_test("ansi_cprng"));
  1434. break;
  1435. case 151:
  1436. ret = min(ret, tcrypt_test("rfc4106(gcm(aes))"));
  1437. break;
  1438. case 152:
  1439. ret = min(ret, tcrypt_test("rfc4543(gcm(aes))"));
  1440. break;
  1441. case 153:
  1442. ret = min(ret, tcrypt_test("cmac(aes)"));
  1443. break;
  1444. case 154:
  1445. ret = min(ret, tcrypt_test("cmac(des3_ede)"));
  1446. break;
  1447. case 155:
  1448. ret = min(ret, tcrypt_test("authenc(hmac(sha1),cbc(aes))"));
  1449. break;
  1450. case 156:
  1451. ret = min(ret, tcrypt_test("authenc(hmac(md5),ecb(cipher_null))"));
  1452. break;
  1453. case 157:
  1454. ret = min(ret, tcrypt_test("authenc(hmac(sha1),ecb(cipher_null))"));
  1455. break;
  1456. case 158:
  1457. ret = min(ret, tcrypt_test("cbcmac(sm4)"));
  1458. break;
  1459. case 159:
  1460. ret = min(ret, tcrypt_test("cmac(sm4)"));
  1461. break;
  1462. case 181:
  1463. ret = min(ret, tcrypt_test("authenc(hmac(sha1),cbc(des))"));
  1464. break;
  1465. case 182:
  1466. ret = min(ret, tcrypt_test("authenc(hmac(sha1),cbc(des3_ede))"));
  1467. break;
  1468. case 183:
  1469. ret = min(ret, tcrypt_test("authenc(hmac(sha224),cbc(des))"));
  1470. break;
  1471. case 184:
  1472. ret = min(ret, tcrypt_test("authenc(hmac(sha224),cbc(des3_ede))"));
  1473. break;
  1474. case 185:
  1475. ret = min(ret, tcrypt_test("authenc(hmac(sha256),cbc(des))"));
  1476. break;
  1477. case 186:
  1478. ret = min(ret, tcrypt_test("authenc(hmac(sha256),cbc(des3_ede))"));
  1479. break;
  1480. case 187:
  1481. ret = min(ret, tcrypt_test("authenc(hmac(sha384),cbc(des))"));
  1482. break;
  1483. case 188:
  1484. ret = min(ret, tcrypt_test("authenc(hmac(sha384),cbc(des3_ede))"));
  1485. break;
  1486. case 189:
  1487. ret = min(ret, tcrypt_test("authenc(hmac(sha512),cbc(des))"));
  1488. break;
  1489. case 190:
  1490. ret = min(ret, tcrypt_test("authenc(hmac(sha512),cbc(des3_ede))"));
  1491. break;
  1492. case 191:
  1493. ret = min(ret, tcrypt_test("ecb(sm4)"));
  1494. ret = min(ret, tcrypt_test("cbc(sm4)"));
  1495. ret = min(ret, tcrypt_test("cfb(sm4)"));
  1496. ret = min(ret, tcrypt_test("ctr(sm4)"));
  1497. break;
  1498. case 192:
  1499. ret = min(ret, tcrypt_test("ecb(aria)"));
  1500. ret = min(ret, tcrypt_test("cbc(aria)"));
  1501. ret = min(ret, tcrypt_test("cfb(aria)"));
  1502. ret = min(ret, tcrypt_test("ctr(aria)"));
  1503. break;
  1504. case 200:
  1505. test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
  1506. speed_template_16_24_32);
  1507. test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
  1508. speed_template_16_24_32);
  1509. test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
  1510. speed_template_16_24_32);
  1511. test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
  1512. speed_template_16_24_32);
  1513. test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
  1514. speed_template_32_40_48);
  1515. test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
  1516. speed_template_32_40_48);
  1517. test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
  1518. speed_template_32_64);
  1519. test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
  1520. speed_template_32_64);
  1521. test_cipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
  1522. speed_template_16_24_32);
  1523. test_cipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
  1524. speed_template_16_24_32);
  1525. test_cipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
  1526. speed_template_16_24_32);
  1527. test_cipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
  1528. speed_template_16_24_32);
  1529. test_cipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0,
  1530. speed_template_16_24_32);
  1531. test_cipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0,
  1532. speed_template_16_24_32);
  1533. break;
  1534. case 201:
  1535. test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
  1536. des3_speed_template, DES3_SPEED_VECTORS,
  1537. speed_template_24);
  1538. test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
  1539. des3_speed_template, DES3_SPEED_VECTORS,
  1540. speed_template_24);
  1541. test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
  1542. des3_speed_template, DES3_SPEED_VECTORS,
  1543. speed_template_24);
  1544. test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
  1545. des3_speed_template, DES3_SPEED_VECTORS,
  1546. speed_template_24);
  1547. test_cipher_speed("ctr(des3_ede)", ENCRYPT, sec,
  1548. des3_speed_template, DES3_SPEED_VECTORS,
  1549. speed_template_24);
  1550. test_cipher_speed("ctr(des3_ede)", DECRYPT, sec,
  1551. des3_speed_template, DES3_SPEED_VECTORS,
  1552. speed_template_24);
  1553. break;
  1554. case 202:
  1555. test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
  1556. speed_template_16_24_32);
  1557. test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
  1558. speed_template_16_24_32);
  1559. test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
  1560. speed_template_16_24_32);
  1561. test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
  1562. speed_template_16_24_32);
  1563. test_cipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
  1564. speed_template_16_24_32);
  1565. test_cipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
  1566. speed_template_16_24_32);
  1567. test_cipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
  1568. speed_template_32_40_48);
  1569. test_cipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
  1570. speed_template_32_40_48);
  1571. test_cipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
  1572. speed_template_32_48_64);
  1573. test_cipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
  1574. speed_template_32_48_64);
  1575. break;
  1576. case 203:
  1577. test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
  1578. speed_template_8_32);
  1579. test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
  1580. speed_template_8_32);
  1581. test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
  1582. speed_template_8_32);
  1583. test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
  1584. speed_template_8_32);
  1585. test_cipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
  1586. speed_template_8_32);
  1587. test_cipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
  1588. speed_template_8_32);
  1589. break;
  1590. case 204:
  1591. test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
  1592. speed_template_8);
  1593. test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
  1594. speed_template_8);
  1595. test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
  1596. speed_template_8);
  1597. test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
  1598. speed_template_8);
  1599. break;
  1600. case 205:
  1601. test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
  1602. speed_template_16_24_32);
  1603. test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
  1604. speed_template_16_24_32);
  1605. test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
  1606. speed_template_16_24_32);
  1607. test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
  1608. speed_template_16_24_32);
  1609. test_cipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
  1610. speed_template_16_24_32);
  1611. test_cipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
  1612. speed_template_16_24_32);
  1613. test_cipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
  1614. speed_template_32_40_48);
  1615. test_cipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
  1616. speed_template_32_40_48);
  1617. test_cipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
  1618. speed_template_32_48_64);
  1619. test_cipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
  1620. speed_template_32_48_64);
  1621. break;
  1622. case 207:
  1623. test_cipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
  1624. speed_template_16_32);
  1625. test_cipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
  1626. speed_template_16_32);
  1627. test_cipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
  1628. speed_template_16_32);
  1629. test_cipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
  1630. speed_template_16_32);
  1631. test_cipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
  1632. speed_template_16_32);
  1633. test_cipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
  1634. speed_template_16_32);
  1635. test_cipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
  1636. speed_template_32_48);
  1637. test_cipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
  1638. speed_template_32_48);
  1639. test_cipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
  1640. speed_template_32_64);
  1641. test_cipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
  1642. speed_template_32_64);
  1643. break;
  1644. case 208:
  1645. test_cipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
  1646. speed_template_8);
  1647. break;
  1648. case 209:
  1649. test_cipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
  1650. speed_template_8_16);
  1651. test_cipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
  1652. speed_template_8_16);
  1653. test_cipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
  1654. speed_template_8_16);
  1655. test_cipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
  1656. speed_template_8_16);
  1657. test_cipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
  1658. speed_template_8_16);
  1659. test_cipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
  1660. speed_template_8_16);
  1661. break;
  1662. case 210:
  1663. test_cipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
  1664. speed_template_16_32);
  1665. test_cipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
  1666. speed_template_16_32);
  1667. test_cipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
  1668. speed_template_16_32);
  1669. test_cipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
  1670. speed_template_16_32);
  1671. test_cipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
  1672. speed_template_16_32);
  1673. test_cipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
  1674. speed_template_16_32);
  1675. test_cipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
  1676. speed_template_32_48);
  1677. test_cipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
  1678. speed_template_32_48);
  1679. test_cipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
  1680. speed_template_32_64);
  1681. test_cipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
  1682. speed_template_32_64);
  1683. break;
  1684. case 211:
  1685. test_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec,
  1686. NULL, 0, 16, 16, aead_speed_template_20);
  1687. test_aead_speed("gcm(aes)", ENCRYPT, sec,
  1688. NULL, 0, 16, 8, speed_template_16_24_32);
  1689. test_aead_speed("rfc4106(gcm(aes))", DECRYPT, sec,
  1690. NULL, 0, 16, 16, aead_speed_template_20);
  1691. test_aead_speed("gcm(aes)", DECRYPT, sec,
  1692. NULL, 0, 16, 8, speed_template_16_24_32);
  1693. break;
  1694. case 212:
  1695. test_aead_speed("rfc4309(ccm(aes))", ENCRYPT, sec,
  1696. NULL, 0, 16, 16, aead_speed_template_19);
  1697. test_aead_speed("rfc4309(ccm(aes))", DECRYPT, sec,
  1698. NULL, 0, 16, 16, aead_speed_template_19);
  1699. break;
  1700. case 213:
  1701. test_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT, sec,
  1702. NULL, 0, 16, 8, aead_speed_template_36);
  1703. test_aead_speed("rfc7539esp(chacha20,poly1305)", DECRYPT, sec,
  1704. NULL, 0, 16, 8, aead_speed_template_36);
  1705. break;
  1706. case 214:
  1707. test_cipher_speed("chacha20", ENCRYPT, sec, NULL, 0,
  1708. speed_template_32);
  1709. break;
  1710. case 215:
  1711. test_mb_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec, NULL,
  1712. 0, 16, 16, aead_speed_template_20, num_mb);
  1713. test_mb_aead_speed("gcm(aes)", ENCRYPT, sec, NULL, 0, 16, 8,
  1714. speed_template_16_24_32, num_mb);
  1715. test_mb_aead_speed("rfc4106(gcm(aes))", DECRYPT, sec, NULL,
  1716. 0, 16, 16, aead_speed_template_20, num_mb);
  1717. test_mb_aead_speed("gcm(aes)", DECRYPT, sec, NULL, 0, 16, 8,
  1718. speed_template_16_24_32, num_mb);
  1719. break;
  1720. case 216:
  1721. test_mb_aead_speed("rfc4309(ccm(aes))", ENCRYPT, sec, NULL, 0,
  1722. 16, 16, aead_speed_template_19, num_mb);
  1723. test_mb_aead_speed("rfc4309(ccm(aes))", DECRYPT, sec, NULL, 0,
  1724. 16, 16, aead_speed_template_19, num_mb);
  1725. break;
  1726. case 217:
  1727. test_mb_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT,
  1728. sec, NULL, 0, 16, 8, aead_speed_template_36,
  1729. num_mb);
  1730. test_mb_aead_speed("rfc7539esp(chacha20,poly1305)", DECRYPT,
  1731. sec, NULL, 0, 16, 8, aead_speed_template_36,
  1732. num_mb);
  1733. break;
  1734. case 218:
  1735. test_cipher_speed("ecb(sm4)", ENCRYPT, sec, NULL, 0,
  1736. speed_template_16);
  1737. test_cipher_speed("ecb(sm4)", DECRYPT, sec, NULL, 0,
  1738. speed_template_16);
  1739. test_cipher_speed("cbc(sm4)", ENCRYPT, sec, NULL, 0,
  1740. speed_template_16);
  1741. test_cipher_speed("cbc(sm4)", DECRYPT, sec, NULL, 0,
  1742. speed_template_16);
  1743. test_cipher_speed("cfb(sm4)", ENCRYPT, sec, NULL, 0,
  1744. speed_template_16);
  1745. test_cipher_speed("cfb(sm4)", DECRYPT, sec, NULL, 0,
  1746. speed_template_16);
  1747. test_cipher_speed("ctr(sm4)", ENCRYPT, sec, NULL, 0,
  1748. speed_template_16);
  1749. test_cipher_speed("ctr(sm4)", DECRYPT, sec, NULL, 0,
  1750. speed_template_16);
  1751. break;
  1752. case 219:
  1753. test_cipher_speed("adiantum(xchacha12,aes)", ENCRYPT, sec, NULL,
  1754. 0, speed_template_32);
  1755. test_cipher_speed("adiantum(xchacha12,aes)", DECRYPT, sec, NULL,
  1756. 0, speed_template_32);
  1757. test_cipher_speed("adiantum(xchacha20,aes)", ENCRYPT, sec, NULL,
  1758. 0, speed_template_32);
  1759. test_cipher_speed("adiantum(xchacha20,aes)", DECRYPT, sec, NULL,
  1760. 0, speed_template_32);
  1761. break;
  1762. case 220:
  1763. test_acipher_speed("essiv(cbc(aes),sha256)",
  1764. ENCRYPT, sec, NULL, 0,
  1765. speed_template_16_24_32);
  1766. test_acipher_speed("essiv(cbc(aes),sha256)",
  1767. DECRYPT, sec, NULL, 0,
  1768. speed_template_16_24_32);
  1769. break;
  1770. case 221:
  1771. test_aead_speed("aegis128", ENCRYPT, sec,
  1772. NULL, 0, 16, 8, speed_template_16);
  1773. test_aead_speed("aegis128", DECRYPT, sec,
  1774. NULL, 0, 16, 8, speed_template_16);
  1775. break;
  1776. case 222:
  1777. test_aead_speed("gcm(sm4)", ENCRYPT, sec,
  1778. NULL, 0, 16, 8, speed_template_16);
  1779. test_aead_speed("gcm(sm4)", DECRYPT, sec,
  1780. NULL, 0, 16, 8, speed_template_16);
  1781. break;
  1782. case 223:
  1783. test_aead_speed("rfc4309(ccm(sm4))", ENCRYPT, sec,
  1784. NULL, 0, 16, 16, aead_speed_template_19);
  1785. test_aead_speed("rfc4309(ccm(sm4))", DECRYPT, sec,
  1786. NULL, 0, 16, 16, aead_speed_template_19);
  1787. break;
  1788. case 224:
  1789. test_mb_aead_speed("gcm(sm4)", ENCRYPT, sec, NULL, 0, 16, 8,
  1790. speed_template_16, num_mb);
  1791. test_mb_aead_speed("gcm(sm4)", DECRYPT, sec, NULL, 0, 16, 8,
  1792. speed_template_16, num_mb);
  1793. break;
  1794. case 225:
  1795. test_mb_aead_speed("rfc4309(ccm(sm4))", ENCRYPT, sec, NULL, 0,
  1796. 16, 16, aead_speed_template_19, num_mb);
  1797. test_mb_aead_speed("rfc4309(ccm(sm4))", DECRYPT, sec, NULL, 0,
  1798. 16, 16, aead_speed_template_19, num_mb);
  1799. break;
  1800. case 226:
  1801. test_cipher_speed("hctr2(aes)", ENCRYPT, sec, NULL,
  1802. 0, speed_template_32);
  1803. break;
  1804. case 227:
  1805. test_cipher_speed("ecb(aria)", ENCRYPT, sec, NULL, 0,
  1806. speed_template_16_24_32);
  1807. test_cipher_speed("ecb(aria)", DECRYPT, sec, NULL, 0,
  1808. speed_template_16_24_32);
  1809. test_cipher_speed("cbc(aria)", ENCRYPT, sec, NULL, 0,
  1810. speed_template_16_24_32);
  1811. test_cipher_speed("cbc(aria)", DECRYPT, sec, NULL, 0,
  1812. speed_template_16_24_32);
  1813. test_cipher_speed("cfb(aria)", ENCRYPT, sec, NULL, 0,
  1814. speed_template_16_24_32);
  1815. test_cipher_speed("cfb(aria)", DECRYPT, sec, NULL, 0,
  1816. speed_template_16_24_32);
  1817. test_cipher_speed("ctr(aria)", ENCRYPT, sec, NULL, 0,
  1818. speed_template_16_24_32);
  1819. test_cipher_speed("ctr(aria)", DECRYPT, sec, NULL, 0,
  1820. speed_template_16_24_32);
  1821. break;
  1822. case 228:
  1823. test_aead_speed("gcm(aria)", ENCRYPT, sec,
  1824. NULL, 0, 16, 8, speed_template_16_24_32);
  1825. test_aead_speed("gcm(aria)", DECRYPT, sec,
  1826. NULL, 0, 16, 8, speed_template_16_24_32);
  1827. break;
  1828. case 229:
  1829. test_mb_aead_speed("gcm(aria)", ENCRYPT, sec, NULL, 0, 16, 8,
  1830. speed_template_16, num_mb);
  1831. test_mb_aead_speed("gcm(aria)", DECRYPT, sec, NULL, 0, 16, 8,
  1832. speed_template_16, num_mb);
  1833. break;
  1834. case 300:
  1835. if (alg) {
  1836. test_hash_speed(alg, sec, generic_hash_speed_template);
  1837. break;
  1838. }
  1839. fallthrough;
  1840. case 301:
  1841. test_hash_speed("md4", sec, generic_hash_speed_template);
  1842. if (mode > 300 && mode < 400) break;
  1843. fallthrough;
  1844. case 302:
  1845. test_hash_speed("md5", sec, generic_hash_speed_template);
  1846. if (mode > 300 && mode < 400) break;
  1847. fallthrough;
  1848. case 303:
  1849. test_hash_speed("sha1", sec, generic_hash_speed_template);
  1850. if (mode > 300 && mode < 400) break;
  1851. fallthrough;
  1852. case 304:
  1853. test_hash_speed("sha256", sec, generic_hash_speed_template);
  1854. if (mode > 300 && mode < 400) break;
  1855. fallthrough;
  1856. case 305:
  1857. test_hash_speed("sha384", sec, generic_hash_speed_template);
  1858. if (mode > 300 && mode < 400) break;
  1859. fallthrough;
  1860. case 306:
  1861. test_hash_speed("sha512", sec, generic_hash_speed_template);
  1862. if (mode > 300 && mode < 400) break;
  1863. fallthrough;
  1864. case 307:
  1865. test_hash_speed("wp256", sec, generic_hash_speed_template);
  1866. if (mode > 300 && mode < 400) break;
  1867. fallthrough;
  1868. case 308:
  1869. test_hash_speed("wp384", sec, generic_hash_speed_template);
  1870. if (mode > 300 && mode < 400) break;
  1871. fallthrough;
  1872. case 309:
  1873. test_hash_speed("wp512", sec, generic_hash_speed_template);
  1874. if (mode > 300 && mode < 400) break;
  1875. fallthrough;
  1876. case 313:
  1877. test_hash_speed("sha224", sec, generic_hash_speed_template);
  1878. if (mode > 300 && mode < 400) break;
  1879. fallthrough;
  1880. case 314:
  1881. test_hash_speed("xxhash64", sec, generic_hash_speed_template);
  1882. if (mode > 300 && mode < 400) break;
  1883. fallthrough;
  1884. case 315:
  1885. test_hash_speed("rmd160", sec, generic_hash_speed_template);
  1886. if (mode > 300 && mode < 400) break;
  1887. fallthrough;
  1888. case 317:
  1889. test_hash_speed("blake2b-512", sec, generic_hash_speed_template);
  1890. if (mode > 300 && mode < 400) break;
  1891. fallthrough;
  1892. case 318:
  1893. klen = 16;
  1894. test_hash_speed("ghash", sec, generic_hash_speed_template);
  1895. if (mode > 300 && mode < 400) break;
  1896. fallthrough;
  1897. case 319:
  1898. test_hash_speed("crc32c", sec, generic_hash_speed_template);
  1899. if (mode > 300 && mode < 400) break;
  1900. fallthrough;
  1901. case 320:
  1902. test_hash_speed("crct10dif", sec, generic_hash_speed_template);
  1903. if (mode > 300 && mode < 400) break;
  1904. fallthrough;
  1905. case 321:
  1906. test_hash_speed("poly1305", sec, poly1305_speed_template);
  1907. if (mode > 300 && mode < 400) break;
  1908. fallthrough;
  1909. case 322:
  1910. test_hash_speed("sha3-224", sec, generic_hash_speed_template);
  1911. if (mode > 300 && mode < 400) break;
  1912. fallthrough;
  1913. case 323:
  1914. test_hash_speed("sha3-256", sec, generic_hash_speed_template);
  1915. if (mode > 300 && mode < 400) break;
  1916. fallthrough;
  1917. case 324:
  1918. test_hash_speed("sha3-384", sec, generic_hash_speed_template);
  1919. if (mode > 300 && mode < 400) break;
  1920. fallthrough;
  1921. case 325:
  1922. test_hash_speed("sha3-512", sec, generic_hash_speed_template);
  1923. if (mode > 300 && mode < 400) break;
  1924. fallthrough;
  1925. case 326:
  1926. test_hash_speed("sm3", sec, generic_hash_speed_template);
  1927. if (mode > 300 && mode < 400) break;
  1928. fallthrough;
  1929. case 327:
  1930. test_hash_speed("streebog256", sec,
  1931. generic_hash_speed_template);
  1932. if (mode > 300 && mode < 400) break;
  1933. fallthrough;
  1934. case 328:
  1935. test_hash_speed("streebog512", sec,
  1936. generic_hash_speed_template);
  1937. if (mode > 300 && mode < 400) break;
  1938. fallthrough;
  1939. case 399:
  1940. break;
  1941. case 400:
  1942. if (alg) {
  1943. test_ahash_speed(alg, sec, generic_hash_speed_template);
  1944. break;
  1945. }
  1946. fallthrough;
  1947. case 401:
  1948. test_ahash_speed("md4", sec, generic_hash_speed_template);
  1949. if (mode > 400 && mode < 500) break;
  1950. fallthrough;
  1951. case 402:
  1952. test_ahash_speed("md5", sec, generic_hash_speed_template);
  1953. if (mode > 400 && mode < 500) break;
  1954. fallthrough;
  1955. case 403:
  1956. test_ahash_speed("sha1", sec, generic_hash_speed_template);
  1957. if (mode > 400 && mode < 500) break;
  1958. fallthrough;
  1959. case 404:
  1960. test_ahash_speed("sha256", sec, generic_hash_speed_template);
  1961. if (mode > 400 && mode < 500) break;
  1962. fallthrough;
  1963. case 405:
  1964. test_ahash_speed("sha384", sec, generic_hash_speed_template);
  1965. if (mode > 400 && mode < 500) break;
  1966. fallthrough;
  1967. case 406:
  1968. test_ahash_speed("sha512", sec, generic_hash_speed_template);
  1969. if (mode > 400 && mode < 500) break;
  1970. fallthrough;
  1971. case 407:
  1972. test_ahash_speed("wp256", sec, generic_hash_speed_template);
  1973. if (mode > 400 && mode < 500) break;
  1974. fallthrough;
  1975. case 408:
  1976. test_ahash_speed("wp384", sec, generic_hash_speed_template);
  1977. if (mode > 400 && mode < 500) break;
  1978. fallthrough;
  1979. case 409:
  1980. test_ahash_speed("wp512", sec, generic_hash_speed_template);
  1981. if (mode > 400 && mode < 500) break;
  1982. fallthrough;
  1983. case 413:
  1984. test_ahash_speed("sha224", sec, generic_hash_speed_template);
  1985. if (mode > 400 && mode < 500) break;
  1986. fallthrough;
  1987. case 414:
  1988. test_ahash_speed("xxhash64", sec, generic_hash_speed_template);
  1989. if (mode > 400 && mode < 500) break;
  1990. fallthrough;
  1991. case 415:
  1992. test_ahash_speed("rmd160", sec, generic_hash_speed_template);
  1993. if (mode > 400 && mode < 500) break;
  1994. fallthrough;
  1995. case 417:
  1996. test_ahash_speed("blake2b-512", sec, generic_hash_speed_template);
  1997. if (mode > 400 && mode < 500) break;
  1998. fallthrough;
  1999. case 418:
  2000. test_ahash_speed("sha3-224", sec, generic_hash_speed_template);
  2001. if (mode > 400 && mode < 500) break;
  2002. fallthrough;
  2003. case 419:
  2004. test_ahash_speed("sha3-256", sec, generic_hash_speed_template);
  2005. if (mode > 400 && mode < 500) break;
  2006. fallthrough;
  2007. case 420:
  2008. test_ahash_speed("sha3-384", sec, generic_hash_speed_template);
  2009. if (mode > 400 && mode < 500) break;
  2010. fallthrough;
  2011. case 421:
  2012. test_ahash_speed("sha3-512", sec, generic_hash_speed_template);
  2013. if (mode > 400 && mode < 500) break;
  2014. fallthrough;
  2015. case 422:
  2016. test_ahash_speed("sm3", sec, generic_hash_speed_template);
  2017. if (mode > 400 && mode < 500) break;
  2018. fallthrough;
  2019. case 499:
  2020. break;
  2021. case 500:
  2022. test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
  2023. speed_template_16_24_32);
  2024. test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
  2025. speed_template_16_24_32);
  2026. test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
  2027. speed_template_16_24_32);
  2028. test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
  2029. speed_template_16_24_32);
  2030. test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
  2031. speed_template_32_40_48);
  2032. test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
  2033. speed_template_32_40_48);
  2034. test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
  2035. speed_template_32_64);
  2036. test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
  2037. speed_template_32_64);
  2038. test_acipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
  2039. speed_template_16_24_32);
  2040. test_acipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
  2041. speed_template_16_24_32);
  2042. test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
  2043. speed_template_16_24_32);
  2044. test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
  2045. speed_template_16_24_32);
  2046. test_acipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0,
  2047. speed_template_16_24_32);
  2048. test_acipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0,
  2049. speed_template_16_24_32);
  2050. test_acipher_speed("ofb(aes)", ENCRYPT, sec, NULL, 0,
  2051. speed_template_16_24_32);
  2052. test_acipher_speed("ofb(aes)", DECRYPT, sec, NULL, 0,
  2053. speed_template_16_24_32);
  2054. test_acipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL, 0,
  2055. speed_template_20_28_36);
  2056. test_acipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL, 0,
  2057. speed_template_20_28_36);
  2058. break;
  2059. case 501:
  2060. test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec,
  2061. des3_speed_template, DES3_SPEED_VECTORS,
  2062. speed_template_24);
  2063. test_acipher_speed("ecb(des3_ede)", DECRYPT, sec,
  2064. des3_speed_template, DES3_SPEED_VECTORS,
  2065. speed_template_24);
  2066. test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec,
  2067. des3_speed_template, DES3_SPEED_VECTORS,
  2068. speed_template_24);
  2069. test_acipher_speed("cbc(des3_ede)", DECRYPT, sec,
  2070. des3_speed_template, DES3_SPEED_VECTORS,
  2071. speed_template_24);
  2072. test_acipher_speed("cfb(des3_ede)", ENCRYPT, sec,
  2073. des3_speed_template, DES3_SPEED_VECTORS,
  2074. speed_template_24);
  2075. test_acipher_speed("cfb(des3_ede)", DECRYPT, sec,
  2076. des3_speed_template, DES3_SPEED_VECTORS,
  2077. speed_template_24);
  2078. test_acipher_speed("ofb(des3_ede)", ENCRYPT, sec,
  2079. des3_speed_template, DES3_SPEED_VECTORS,
  2080. speed_template_24);
  2081. test_acipher_speed("ofb(des3_ede)", DECRYPT, sec,
  2082. des3_speed_template, DES3_SPEED_VECTORS,
  2083. speed_template_24);
  2084. break;
  2085. case 502:
  2086. test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
  2087. speed_template_8);
  2088. test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
  2089. speed_template_8);
  2090. test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
  2091. speed_template_8);
  2092. test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
  2093. speed_template_8);
  2094. test_acipher_speed("cfb(des)", ENCRYPT, sec, NULL, 0,
  2095. speed_template_8);
  2096. test_acipher_speed("cfb(des)", DECRYPT, sec, NULL, 0,
  2097. speed_template_8);
  2098. test_acipher_speed("ofb(des)", ENCRYPT, sec, NULL, 0,
  2099. speed_template_8);
  2100. test_acipher_speed("ofb(des)", DECRYPT, sec, NULL, 0,
  2101. speed_template_8);
  2102. break;
  2103. case 503:
  2104. test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
  2105. speed_template_16_32);
  2106. test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
  2107. speed_template_16_32);
  2108. test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
  2109. speed_template_16_32);
  2110. test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
  2111. speed_template_16_32);
  2112. test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
  2113. speed_template_16_32);
  2114. test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
  2115. speed_template_16_32);
  2116. test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
  2117. speed_template_32_48);
  2118. test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
  2119. speed_template_32_48);
  2120. test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
  2121. speed_template_32_64);
  2122. test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
  2123. speed_template_32_64);
  2124. break;
  2125. case 504:
  2126. test_acipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
  2127. speed_template_16_24_32);
  2128. test_acipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
  2129. speed_template_16_24_32);
  2130. test_acipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
  2131. speed_template_16_24_32);
  2132. test_acipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
  2133. speed_template_16_24_32);
  2134. test_acipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
  2135. speed_template_16_24_32);
  2136. test_acipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
  2137. speed_template_16_24_32);
  2138. test_acipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
  2139. speed_template_32_40_48);
  2140. test_acipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
  2141. speed_template_32_40_48);
  2142. test_acipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
  2143. speed_template_32_48_64);
  2144. test_acipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
  2145. speed_template_32_48_64);
  2146. break;
  2147. case 505:
  2148. test_acipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
  2149. speed_template_8);
  2150. break;
  2151. case 506:
  2152. test_acipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
  2153. speed_template_8_16);
  2154. test_acipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
  2155. speed_template_8_16);
  2156. test_acipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
  2157. speed_template_8_16);
  2158. test_acipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
  2159. speed_template_8_16);
  2160. test_acipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
  2161. speed_template_8_16);
  2162. test_acipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
  2163. speed_template_8_16);
  2164. break;
  2165. case 507:
  2166. test_acipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
  2167. speed_template_16_32);
  2168. test_acipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
  2169. speed_template_16_32);
  2170. test_acipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
  2171. speed_template_16_32);
  2172. test_acipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
  2173. speed_template_16_32);
  2174. test_acipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
  2175. speed_template_16_32);
  2176. test_acipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
  2177. speed_template_16_32);
  2178. test_acipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
  2179. speed_template_32_48);
  2180. test_acipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
  2181. speed_template_32_48);
  2182. test_acipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
  2183. speed_template_32_64);
  2184. test_acipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
  2185. speed_template_32_64);
  2186. break;
  2187. case 508:
  2188. test_acipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
  2189. speed_template_16_32);
  2190. test_acipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
  2191. speed_template_16_32);
  2192. test_acipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
  2193. speed_template_16_32);
  2194. test_acipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
  2195. speed_template_16_32);
  2196. test_acipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
  2197. speed_template_16_32);
  2198. test_acipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
  2199. speed_template_16_32);
  2200. test_acipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
  2201. speed_template_32_48);
  2202. test_acipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
  2203. speed_template_32_48);
  2204. test_acipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
  2205. speed_template_32_64);
  2206. test_acipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
  2207. speed_template_32_64);
  2208. break;
  2209. case 509:
  2210. test_acipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
  2211. speed_template_8_32);
  2212. test_acipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
  2213. speed_template_8_32);
  2214. test_acipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
  2215. speed_template_8_32);
  2216. test_acipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
  2217. speed_template_8_32);
  2218. test_acipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
  2219. speed_template_8_32);
  2220. test_acipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
  2221. speed_template_8_32);
  2222. break;
  2223. case 518:
  2224. test_acipher_speed("ecb(sm4)", ENCRYPT, sec, NULL, 0,
  2225. speed_template_16);
  2226. test_acipher_speed("ecb(sm4)", DECRYPT, sec, NULL, 0,
  2227. speed_template_16);
  2228. test_acipher_speed("cbc(sm4)", ENCRYPT, sec, NULL, 0,
  2229. speed_template_16);
  2230. test_acipher_speed("cbc(sm4)", DECRYPT, sec, NULL, 0,
  2231. speed_template_16);
  2232. test_acipher_speed("cfb(sm4)", ENCRYPT, sec, NULL, 0,
  2233. speed_template_16);
  2234. test_acipher_speed("cfb(sm4)", DECRYPT, sec, NULL, 0,
  2235. speed_template_16);
  2236. test_acipher_speed("ctr(sm4)", ENCRYPT, sec, NULL, 0,
  2237. speed_template_16);
  2238. test_acipher_speed("ctr(sm4)", DECRYPT, sec, NULL, 0,
  2239. speed_template_16);
  2240. break;
  2241. case 519:
  2242. test_acipher_speed("ecb(aria)", ENCRYPT, sec, NULL, 0,
  2243. speed_template_16_24_32);
  2244. test_acipher_speed("ecb(aria)", DECRYPT, sec, NULL, 0,
  2245. speed_template_16_24_32);
  2246. test_acipher_speed("ctr(aria)", ENCRYPT, sec, NULL, 0,
  2247. speed_template_16_24_32);
  2248. test_acipher_speed("ctr(aria)", DECRYPT, sec, NULL, 0,
  2249. speed_template_16_24_32);
  2250. break;
  2251. case 600:
  2252. test_mb_skcipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
  2253. speed_template_16_24_32, num_mb);
  2254. test_mb_skcipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
  2255. speed_template_16_24_32, num_mb);
  2256. test_mb_skcipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
  2257. speed_template_16_24_32, num_mb);
  2258. test_mb_skcipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
  2259. speed_template_16_24_32, num_mb);
  2260. test_mb_skcipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
  2261. speed_template_32_40_48, num_mb);
  2262. test_mb_skcipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
  2263. speed_template_32_40_48, num_mb);
  2264. test_mb_skcipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
  2265. speed_template_32_64, num_mb);
  2266. test_mb_skcipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
  2267. speed_template_32_64, num_mb);
  2268. test_mb_skcipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
  2269. speed_template_16_24_32, num_mb);
  2270. test_mb_skcipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
  2271. speed_template_16_24_32, num_mb);
  2272. test_mb_skcipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
  2273. speed_template_16_24_32, num_mb);
  2274. test_mb_skcipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
  2275. speed_template_16_24_32, num_mb);
  2276. test_mb_skcipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0,
  2277. speed_template_16_24_32, num_mb);
  2278. test_mb_skcipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0,
  2279. speed_template_16_24_32, num_mb);
  2280. test_mb_skcipher_speed("ofb(aes)", ENCRYPT, sec, NULL, 0,
  2281. speed_template_16_24_32, num_mb);
  2282. test_mb_skcipher_speed("ofb(aes)", DECRYPT, sec, NULL, 0,
  2283. speed_template_16_24_32, num_mb);
  2284. test_mb_skcipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL,
  2285. 0, speed_template_20_28_36, num_mb);
  2286. test_mb_skcipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL,
  2287. 0, speed_template_20_28_36, num_mb);
  2288. break;
  2289. case 601:
  2290. test_mb_skcipher_speed("ecb(des3_ede)", ENCRYPT, sec,
  2291. des3_speed_template, DES3_SPEED_VECTORS,
  2292. speed_template_24, num_mb);
  2293. test_mb_skcipher_speed("ecb(des3_ede)", DECRYPT, sec,
  2294. des3_speed_template, DES3_SPEED_VECTORS,
  2295. speed_template_24, num_mb);
  2296. test_mb_skcipher_speed("cbc(des3_ede)", ENCRYPT, sec,
  2297. des3_speed_template, DES3_SPEED_VECTORS,
  2298. speed_template_24, num_mb);
  2299. test_mb_skcipher_speed("cbc(des3_ede)", DECRYPT, sec,
  2300. des3_speed_template, DES3_SPEED_VECTORS,
  2301. speed_template_24, num_mb);
  2302. test_mb_skcipher_speed("cfb(des3_ede)", ENCRYPT, sec,
  2303. des3_speed_template, DES3_SPEED_VECTORS,
  2304. speed_template_24, num_mb);
  2305. test_mb_skcipher_speed("cfb(des3_ede)", DECRYPT, sec,
  2306. des3_speed_template, DES3_SPEED_VECTORS,
  2307. speed_template_24, num_mb);
  2308. test_mb_skcipher_speed("ofb(des3_ede)", ENCRYPT, sec,
  2309. des3_speed_template, DES3_SPEED_VECTORS,
  2310. speed_template_24, num_mb);
  2311. test_mb_skcipher_speed("ofb(des3_ede)", DECRYPT, sec,
  2312. des3_speed_template, DES3_SPEED_VECTORS,
  2313. speed_template_24, num_mb);
  2314. break;
  2315. case 602:
  2316. test_mb_skcipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
  2317. speed_template_8, num_mb);
  2318. test_mb_skcipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
  2319. speed_template_8, num_mb);
  2320. test_mb_skcipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
  2321. speed_template_8, num_mb);
  2322. test_mb_skcipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
  2323. speed_template_8, num_mb);
  2324. test_mb_skcipher_speed("cfb(des)", ENCRYPT, sec, NULL, 0,
  2325. speed_template_8, num_mb);
  2326. test_mb_skcipher_speed("cfb(des)", DECRYPT, sec, NULL, 0,
  2327. speed_template_8, num_mb);
  2328. test_mb_skcipher_speed("ofb(des)", ENCRYPT, sec, NULL, 0,
  2329. speed_template_8, num_mb);
  2330. test_mb_skcipher_speed("ofb(des)", DECRYPT, sec, NULL, 0,
  2331. speed_template_8, num_mb);
  2332. break;
  2333. case 603:
  2334. test_mb_skcipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
  2335. speed_template_16_32, num_mb);
  2336. test_mb_skcipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
  2337. speed_template_16_32, num_mb);
  2338. test_mb_skcipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
  2339. speed_template_16_32, num_mb);
  2340. test_mb_skcipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
  2341. speed_template_16_32, num_mb);
  2342. test_mb_skcipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
  2343. speed_template_16_32, num_mb);
  2344. test_mb_skcipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
  2345. speed_template_16_32, num_mb);
  2346. test_mb_skcipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
  2347. speed_template_32_48, num_mb);
  2348. test_mb_skcipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
  2349. speed_template_32_48, num_mb);
  2350. test_mb_skcipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
  2351. speed_template_32_64, num_mb);
  2352. test_mb_skcipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
  2353. speed_template_32_64, num_mb);
  2354. break;
  2355. case 604:
  2356. test_mb_skcipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
  2357. speed_template_16_24_32, num_mb);
  2358. test_mb_skcipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
  2359. speed_template_16_24_32, num_mb);
  2360. test_mb_skcipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
  2361. speed_template_16_24_32, num_mb);
  2362. test_mb_skcipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
  2363. speed_template_16_24_32, num_mb);
  2364. test_mb_skcipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
  2365. speed_template_16_24_32, num_mb);
  2366. test_mb_skcipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
  2367. speed_template_16_24_32, num_mb);
  2368. test_mb_skcipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
  2369. speed_template_32_40_48, num_mb);
  2370. test_mb_skcipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
  2371. speed_template_32_40_48, num_mb);
  2372. test_mb_skcipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
  2373. speed_template_32_48_64, num_mb);
  2374. test_mb_skcipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
  2375. speed_template_32_48_64, num_mb);
  2376. break;
  2377. case 605:
  2378. test_mb_skcipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
  2379. speed_template_8, num_mb);
  2380. break;
  2381. case 606:
  2382. test_mb_skcipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
  2383. speed_template_8_16, num_mb);
  2384. test_mb_skcipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
  2385. speed_template_8_16, num_mb);
  2386. test_mb_skcipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
  2387. speed_template_8_16, num_mb);
  2388. test_mb_skcipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
  2389. speed_template_8_16, num_mb);
  2390. test_mb_skcipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
  2391. speed_template_8_16, num_mb);
  2392. test_mb_skcipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
  2393. speed_template_8_16, num_mb);
  2394. break;
  2395. case 607:
  2396. test_mb_skcipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
  2397. speed_template_16_32, num_mb);
  2398. test_mb_skcipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
  2399. speed_template_16_32, num_mb);
  2400. test_mb_skcipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
  2401. speed_template_16_32, num_mb);
  2402. test_mb_skcipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
  2403. speed_template_16_32, num_mb);
  2404. test_mb_skcipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
  2405. speed_template_16_32, num_mb);
  2406. test_mb_skcipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
  2407. speed_template_16_32, num_mb);
  2408. test_mb_skcipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
  2409. speed_template_32_48, num_mb);
  2410. test_mb_skcipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
  2411. speed_template_32_48, num_mb);
  2412. test_mb_skcipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
  2413. speed_template_32_64, num_mb);
  2414. test_mb_skcipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
  2415. speed_template_32_64, num_mb);
  2416. break;
  2417. case 608:
  2418. test_mb_skcipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
  2419. speed_template_16_32, num_mb);
  2420. test_mb_skcipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
  2421. speed_template_16_32, num_mb);
  2422. test_mb_skcipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
  2423. speed_template_16_32, num_mb);
  2424. test_mb_skcipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
  2425. speed_template_16_32, num_mb);
  2426. test_mb_skcipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
  2427. speed_template_16_32, num_mb);
  2428. test_mb_skcipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
  2429. speed_template_16_32, num_mb);
  2430. test_mb_skcipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
  2431. speed_template_32_48, num_mb);
  2432. test_mb_skcipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
  2433. speed_template_32_48, num_mb);
  2434. test_mb_skcipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
  2435. speed_template_32_64, num_mb);
  2436. test_mb_skcipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
  2437. speed_template_32_64, num_mb);
  2438. break;
  2439. case 609:
  2440. test_mb_skcipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
  2441. speed_template_8_32, num_mb);
  2442. test_mb_skcipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
  2443. speed_template_8_32, num_mb);
  2444. test_mb_skcipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
  2445. speed_template_8_32, num_mb);
  2446. test_mb_skcipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
  2447. speed_template_8_32, num_mb);
  2448. test_mb_skcipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
  2449. speed_template_8_32, num_mb);
  2450. test_mb_skcipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
  2451. speed_template_8_32, num_mb);
  2452. break;
  2453. case 610:
  2454. test_mb_skcipher_speed("ecb(aria)", ENCRYPT, sec, NULL, 0,
  2455. speed_template_16_32, num_mb);
  2456. test_mb_skcipher_speed("ecb(aria)", DECRYPT, sec, NULL, 0,
  2457. speed_template_16_32, num_mb);
  2458. test_mb_skcipher_speed("ctr(aria)", ENCRYPT, sec, NULL, 0,
  2459. speed_template_16_32, num_mb);
  2460. test_mb_skcipher_speed("ctr(aria)", DECRYPT, sec, NULL, 0,
  2461. speed_template_16_32, num_mb);
  2462. break;
  2463. }
  2464. return ret;
  2465. }
  2466. static int __init tcrypt_mod_init(void)
  2467. {
  2468. int err = -ENOMEM;
  2469. int i;
  2470. for (i = 0; i < TVMEMSIZE; i++) {
  2471. tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
  2472. if (!tvmem[i])
  2473. goto err_free_tv;
  2474. }
  2475. err = do_test(alg, type, mask, mode, num_mb);
  2476. if (err) {
  2477. printk(KERN_ERR "tcrypt: one or more tests failed!\n");
  2478. goto err_free_tv;
  2479. } else {
  2480. pr_debug("all tests passed\n");
  2481. }
  2482. /* We intentionaly return -EAGAIN to prevent keeping the module,
  2483. * unless we're running in fips mode. It does all its work from
  2484. * init() and doesn't offer any runtime functionality, but in
  2485. * the fips case, checking for a successful load is helpful.
  2486. * => we don't need it in the memory, do we?
  2487. * -- mludvig
  2488. */
  2489. if (!fips_enabled)
  2490. err = -EAGAIN;
  2491. err_free_tv:
  2492. for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
  2493. free_page((unsigned long)tvmem[i]);
  2494. return err;
  2495. }
  2496. /*
  2497. * If an init function is provided, an exit function must also be provided
  2498. * to allow module unload.
  2499. */
  2500. static void __exit tcrypt_mod_fini(void) { }
  2501. late_initcall(tcrypt_mod_init);
  2502. module_exit(tcrypt_mod_fini);
  2503. module_param(alg, charp, 0);
  2504. module_param(type, uint, 0);
  2505. module_param(mask, uint, 0);
  2506. module_param(mode, int, 0);
  2507. module_param(sec, uint, 0);
  2508. MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
  2509. "(defaults to zero which uses CPU cycles instead)");
  2510. module_param(num_mb, uint, 0000);
  2511. MODULE_PARM_DESC(num_mb, "Number of concurrent requests to be used in mb speed tests (defaults to 8)");
  2512. module_param(klen, uint, 0);
  2513. MODULE_PARM_DESC(klen, "Key length (defaults to 0)");
  2514. MODULE_LICENSE("GPL");
  2515. MODULE_DESCRIPTION("Quick & dirty crypto testing module");
  2516. MODULE_AUTHOR("James Morris <[email protected]>");