tcrypt.c 78 KB

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