开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
blapitest.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：53k
源码类别：

CA认证

开发平台：

WINDOWS

blapitest.c：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is the Netscape security libraries.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are 
  16.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above.  If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  */
  34. #include <stdio.h>
  35. #include <stdlib.h>
  37. #include "blapi.h"
  38. #include "prmem.h"
  39. #include "prprf.h"
  40. #include "prtime.h"
  41. #include "prsystem.h"
  42. #include "plstr.h"
  43. #include "nssb64.h"
  44. #include "secutil.h"
  45. #include "plgetopt.h"
  46. #include "softoken.h"
  48. char *progName;
  49. char *testdir = ".";
  51. #define CHECKERROR(rv, ln) 
  52. if (rv) { 
  53. char *errtxt = NULL; 
  54. if (PR_GetError() != 0) { 
  55. errtxt = PORT_Alloc(PR_GetErrorTextLength()); 
  56. PR_GetErrorText(errtxt); 
  57. } 
  58. PR_fprintf(PR_STDERR, "%s: ERR (%s) at line %d.n", progName, 
  59.                        (errtxt) ? "" : errtxt, ln); 
  60. exit(-1); 
  61. }
  63. static void Usage()
  64. {
  65. #define PRINTUSAGE(subject, option, predicate) 
  66. fprintf(stderr, "%10s %st%sn", subject, option, predicate);
  67. fprintf(stderr, "n");
  68. PRINTUSAGE(progName, "[-DEHSV] -m", "List available cipher modes.");
  69. fprintf(stderr, "n");
  70. PRINTUSAGE(progName, "-E -m mode ", "Encrypt a buffer.");
  71. PRINTUSAGE("",      "", "[-i plaintext] [-o ciphertext] [-k key] [-v iv]");
  72. PRINTUSAGE("",      "", "[-b bufsize] [-g keysize] [-erw]");
  73. PRINTUSAGE("",      "", "[-p repetitions]");
  74. PRINTUSAGE("",      "-m", "cipher mode to use.");
  75. PRINTUSAGE("",      "-i", "file which contains input buffer.");
  76. PRINTUSAGE("",      "-o", "file for output buffer.");
  77. PRINTUSAGE("",      "-k", "file which contains key.");
  78. PRINTUSAGE("",      "-v", "file which contains initialization vector.");
  79. PRINTUSAGE("",      "-b", "size of input buffer.");
  80. PRINTUSAGE("",      "-g", "key size (in bytes).");
  81. PRINTUSAGE("",      "-p", "do performance test.");
  82. PRINTUSAGE("(rsa)", "-e", "rsa public exponent.");
  83. #if NSS_SOFTOKEN_DOES_RC5
  84. PRINTUSAGE("(rc5)", "-r", "number of rounds.");
  85. PRINTUSAGE("(rc5)", "-w", "wordsize (32 or 64).");
  86. #endif
  87. fprintf(stderr, "n");
  88. PRINTUSAGE(progName, "-D -m mode", "Decrypt a buffer.");
  89. PRINTUSAGE("",      "", "[-i plaintext] [-o ciphertext] [-k key] [-v iv]");
  90. PRINTUSAGE("",      "", "[-p repetitions]");
  91. PRINTUSAGE("",      "-m", "cipher mode to use.");
  92. PRINTUSAGE("",      "-i", "file which contains input buffer.");
  93. PRINTUSAGE("",      "-o", "file for output buffer.");
  94. PRINTUSAGE("",      "-k", "file which contains key.");
  95. PRINTUSAGE("",      "-v", "file which contains initialization vector.");
  96. PRINTUSAGE("",      "-p", "do performance test.");
  97. fprintf(stderr, "n");
  98. PRINTUSAGE(progName, "-H -m mode", "Hash a buffer.");
  99. PRINTUSAGE("",      "", "[-i plaintext] [-o hash]");
  100. PRINTUSAGE("",      "", "[-b bufsize]");
  101. PRINTUSAGE("",      "", "[-p repetitions]");
  102. PRINTUSAGE("",      "-m", "cipher mode to use.");
  103. PRINTUSAGE("",      "-i", "file which contains input buffer.");
  104. PRINTUSAGE("",      "-o", "file for hash.");
  105. PRINTUSAGE("",      "-b", "size of input buffer.");
  106. PRINTUSAGE("",      "-p", "do performance test.");
  107. fprintf(stderr, "n");
  108. PRINTUSAGE(progName, "-S -m mode", "Sign a buffer.");
  109. PRINTUSAGE("",      "", "[-i plaintext] [-o signature] [-k key]");
  110. PRINTUSAGE("",      "", "[-b bufsize]");
  111. PRINTUSAGE("",      "", "[-p repetitions]");
  112. PRINTUSAGE("",      "-m", "cipher mode to use.");
  113. PRINTUSAGE("",      "-i", "file which contains input buffer.");
  114. PRINTUSAGE("",      "-o", "file for signature.");
  115. PRINTUSAGE("",      "-k", "file which contains key.");
  116. PRINTUSAGE("",      "-p", "do performance test.");
  117. fprintf(stderr, "n");
  118. PRINTUSAGE(progName, "-V -m mode", "Verify a signed buffer.");
  119. PRINTUSAGE("",      "", "[-i plaintext] [-s signature] [-k key]");
  120. PRINTUSAGE("",      "", "[-p repetitions]");
  121. PRINTUSAGE("",      "-m", "cipher mode to use.");
  122. PRINTUSAGE("",      "-i", "file which contains input buffer.");
  123. PRINTUSAGE("",      "-s", "file which contains signature of input buffer.");
  124. PRINTUSAGE("",      "-k", "file which contains key.");
  125. PRINTUSAGE("",      "-p", "do performance test.");
  126. fprintf(stderr, "n");
  127. PRINTUSAGE(progName, "-F", "Run the FIPS self-test.");
  128. fprintf(stderr, "n");
  129. PRINTUSAGE(progName, "-T [mode1 mode2 ...]", "Run the BLAPI self-test.");
  130. fprintf(stderr, "n");
  131. exit(1);
  132. }
  134. /*  Helper functions for ascii<-->binary conversion/reading/writing */
  136. static PRInt32
  137. get_binary(void *arg, const unsigned char *ibuf, PRInt32 size)
  138. {
  139. SECItem *binary = arg;
  140. SECItem *tmp;
  141. int index;
  142. if (binary->data == NULL) {
  143. tmp = SECITEM_AllocItem(NULL, NULL, size);
  144. binary->data = tmp->data;
  145. binary->len = tmp->len;
  146. index = 0;
  147. } else {
  148. SECITEM_ReallocItem(NULL, binary, binary->len, binary->len + size);
  149. index = binary->len;
  150. }
  151. PORT_Memcpy(&binary->data[index], ibuf, size);
  152. return binary->len;
  153. }
  155. static PRInt32
  156. get_ascii(void *arg, const char *ibuf, PRInt32 size)
  157. {
  158. SECItem *ascii = arg;
  159. SECItem *tmp;
  160. int index;
  161. if (ascii->data == NULL) {
  162. tmp = SECITEM_AllocItem(NULL, NULL, size);
  163. ascii->data = tmp->data;
  164. ascii->len = tmp->len;
  165. index = 0;
  166. } else {
  167. SECITEM_ReallocItem(NULL, ascii, ascii->len, ascii->len + size);
  168. index = ascii->len;
  169. }
  170. PORT_Memcpy(&ascii->data[index], ibuf, size);
  171. return ascii->len;
  172. }
  174. static SECStatus
  175. atob(SECItem *ascii, SECItem *binary)
  176. {
  177. SECStatus status;
  178. NSSBase64Decoder *cx;
  179. int len;
  180. binary->data = NULL; 
  181. binary->len = 0;
  182. len = (strcmp(&ascii->data[ascii->len-2],"rn"))?ascii->len:ascii->len-2;
  183. cx = NSSBase64Decoder_Create(get_binary, binary);
  184. status = NSSBase64Decoder_Update(cx, (const char *)ascii->data, len);
  185. status = NSSBase64Decoder_Destroy(cx, PR_FALSE);
  186. return status;
  187. }
  189. static PRInt32
  190. output_ascii(void *arg, const char *obuf, PRInt32 size)
  191. {
  192. PRFileDesc *outfile = arg;
  193. PRInt32 nb = PR_Write(outfile, obuf, size);
  194. if (nb != size) {
  195. PORT_SetError(SEC_ERROR_IO);
  196. return -1;
  197. }
  198. return nb;
  199. }
  201. static SECStatus
  202. btoa(SECItem *binary, SECItem *ascii)
  203. {
  204. SECStatus status;
  205. NSSBase64Encoder *cx;
  206. ascii->data = NULL;
  207. ascii->len = 0;
  208. cx = NSSBase64Encoder_Create(get_ascii, ascii);
  209. status = NSSBase64Encoder_Update(cx, binary->data, binary->len);
  210. status = NSSBase64Encoder_Destroy(cx, PR_FALSE);
  211. return status;
  212. }
  214. static SECStatus
  215. btoa_file(SECItem *binary, PRFileDesc *outfile)
  216. {
  217. SECStatus status;
  218. NSSBase64Encoder *cx;
  219. SECItem ascii;
  220. ascii.data = NULL; 
  221. ascii.len = 0;
  222. if (binary->len == 0) 
  223. return SECSuccess;
  224. cx = NSSBase64Encoder_Create(output_ascii, outfile);
  225. status = NSSBase64Encoder_Update(cx, binary->data, binary->len);
  226. status = NSSBase64Encoder_Destroy(cx, PR_FALSE);
  227. status = PR_Write(outfile, "rn", 2);
  228. return status;
  229. }
  231. static SECStatus
  232. get_and_write_random_bytes(SECItem *item, PRInt32 numbytes, char *filename)
  233. {
  234. SECStatus rv;
  235. PRFileDesc *file;
  236. item->len = numbytes;
  237. item->data = (unsigned char *)PORT_ZAlloc(numbytes);
  238. RNG_GenerateGlobalRandomBytes(item->data + 1, numbytes - 1);
  239. file = PR_Open(filename, PR_WRONLY|PR_CREATE_FILE, 00660);
  240. rv = btoa_file(item, file);
  241. CHECKERROR((rv < 0), __LINE__);
  242. return (rv < 0);
  243. }
  245. static RSAPrivateKey *
  246. rsakey_from_filedata(SECItem *filedata)
  247. {
  248. PRArenaPool *arena;
  249. RSAPrivateKey *key;
  250. unsigned char *buf = filedata->data;
  251. int fpos = 0;
  252. int i;
  253. SECItem *item;
  254. /*  Allocate space for key structure. */
  255. arena = PORT_NewArena(2048);
  256. key = (RSAPrivateKey *)PORT_ArenaZAlloc(arena, sizeof(RSAPrivateKey));
  257. key->arena = arena;
  258. item = &key->version;
  259. for (i=0; i<9; i++) {
  260. item->len  = (buf[fpos++] & 0xff) << 24;
  261. item->len |= (buf[fpos++] & 0xff) << 16;
  262. item->len |= (buf[fpos++] & 0xff) <<  8;
  263. item->len |= (buf[fpos++] & 0xff);
  264. if (item->len > 0) {
  265. item->data = PORT_ArenaAlloc(arena, item->len);
  266. PORT_Memcpy(item->data, &buf[fpos], item->len);
  267. } else {
  268. item->data = NULL;
  269. }
  270. fpos += item->len;
  271. item++;
  272. }
  273. return key;
  274. }
  276. static void
  277. rsakey_to_file(RSAPrivateKey *key, char *filename)
  278. {
  279. PRFileDesc *file;
  280. SECItem *item;
  281. unsigned char len[4];
  282. int i;
  283. SECStatus status;
  284. NSSBase64Encoder *cx;
  285. SECItem ascii;
  286. ascii.data = NULL; 
  287. ascii.len = 0;
  288. file  = PR_Open(filename, PR_WRONLY|PR_CREATE_FILE, 00660);
  289. cx = NSSBase64Encoder_Create(output_ascii, file);
  290. item = &key->version;
  291. for (i=0; i<9; i++) {
  292. len[0] = (item->len >> 24) & 0xff;
  293. len[1] = (item->len >> 16) & 0xff;
  294. len[2] = (item->len >>  8) & 0xff;
  295. len[3] = (item->len & 0xff);
  296. status = NSSBase64Encoder_Update(cx, len, 4);
  297. status = NSSBase64Encoder_Update(cx, item->data, item->len);
  298. item++;
  299. }
  300. status = NSSBase64Encoder_Destroy(cx, PR_FALSE);
  301. status = PR_Write(file, "rn", 2);
  302. PR_Close(file);
  303. }
  305. static PQGParams *
  306. pqg_from_filedata(SECItem *filedata)
  307. {
  308. PRArenaPool *arena;
  309. PQGParams *pqg;
  310. unsigned char *buf = filedata->data;
  311. int fpos = 0;
  312. int i;
  313. SECItem *item;
  314. /*  Allocate space for key structure. */
  315. arena = PORT_NewArena(2048);
  316. pqg = (PQGParams *)PORT_ArenaZAlloc(arena, sizeof(PQGParams));
  317. pqg->arena = arena;
  318. item = &pqg->prime;
  319. for (i=0; i<3; i++) {
  320. item->len  = (buf[fpos++] & 0xff) << 24;
  321. item->len |= (buf[fpos++] & 0xff) << 16;
  322. item->len |= (buf[fpos++] & 0xff) <<  8;
  323. item->len |= (buf[fpos++] & 0xff);
  324. if (item->len > 0) {
  325. item->data = PORT_ArenaAlloc(arena, item->len);
  326. PORT_Memcpy(item->data, &buf[fpos], item->len);
  327. } else {
  328. item->data = NULL;
  329. }
  330. fpos += item->len;
  331. item++;
  332. }
  333. return pqg;
  334. }
  336. static DSAPrivateKey *
  337. dsakey_from_filedata(SECItem *filedata)
  338. {
  339. PRArenaPool *arena;
  340. DSAPrivateKey *key;
  341. unsigned char *buf = filedata->data;
  342. int fpos = 0;
  343. int i;
  344. SECItem *item;
  345. /*  Allocate space for key structure. */
  346. arena = PORT_NewArena(2048);
  347. key = (DSAPrivateKey *)PORT_ArenaZAlloc(arena, sizeof(DSAPrivateKey));
  348. key->params.arena = arena;
  349. item = &key->params.prime;
  350. for (i=0; i<5; i++) {
  351. item->len  = (buf[fpos++] & 0xff) << 24;
  352. item->len |= (buf[fpos++] & 0xff) << 16;
  353. item->len |= (buf[fpos++] & 0xff) <<  8;
  354. item->len |= (buf[fpos++] & 0xff);
  355. if (item->len > 0) {
  356. item->data = PORT_ArenaAlloc(arena, item->len);
  357. PORT_Memcpy(item->data, &buf[fpos], item->len);
  358. } else {
  359. item->data = NULL;
  360. }
  361. fpos += item->len;
  362. item++;
  363. }
  364. return key;
  365. }
  367. static void
  368. pqg_to_file(PQGParams *params, char *filename)
  369. {
  370. PRFileDesc *file;
  371. SECItem *item;
  372. unsigned char len[4];
  373. int i;
  374. SECStatus status;
  375. NSSBase64Encoder *cx;
  376. SECItem ascii;
  377. ascii.data = NULL; 
  378. ascii.len = 0;
  379. file  = PR_Open(filename, PR_WRONLY|PR_CREATE_FILE, 00660);
  380. cx = NSSBase64Encoder_Create(output_ascii, file);
  381. item = &params->prime;
  382. for (i=0; i<3; i++) {
  383. len[0] = (item->len >> 24) & 0xff;
  384. len[1] = (item->len >> 16) & 0xff;
  385. len[2] = (item->len >>  8) & 0xff;
  386. len[3] = (item->len & 0xff);
  387. status = NSSBase64Encoder_Update(cx, len, 4);
  388. status = NSSBase64Encoder_Update(cx, item->data, item->len);
  389. item++;
  390. }
  391. status = NSSBase64Encoder_Destroy(cx, PR_FALSE);
  392. status = PR_Write(file, "rn", 2);
  393. }
  395. static void
  396. dsakey_to_file(DSAPrivateKey *key, char *filename)
  397. {
  398. PRFileDesc *file;
  399. SECItem *item;
  400. unsigned char len[4];
  401. int i;
  402. SECStatus status;
  403. NSSBase64Encoder *cx;
  404. SECItem ascii;
  405. ascii.data = NULL; 
  406. ascii.len = 0;
  407. file  = PR_Open(filename, PR_WRONLY|PR_CREATE_FILE, 00660);
  408. cx = NSSBase64Encoder_Create(output_ascii, file);
  409. item = &key->params.prime;
  410. for (i=0; i<5; i++) {
  411. len[0] = (item->len >> 24) & 0xff;
  412. len[1] = (item->len >> 16) & 0xff;
  413. len[2] = (item->len >>  8) & 0xff;
  414. len[3] = (item->len & 0xff);
  415. status = NSSBase64Encoder_Update(cx, len, 4);
  416. status = NSSBase64Encoder_Update(cx, item->data, item->len);
  417. item++;
  418. }
  419. status = NSSBase64Encoder_Destroy(cx, PR_FALSE);
  420. status = PR_Write(file, "rn", 2);
  421. }
  423. static void
  424. dump_pqg(PQGParams *pqg)
  425. {
  426. SECU_PrintInteger(stdout, &pqg->prime, "PRIME:", 0);
  427. SECU_PrintInteger(stdout, &pqg->subPrime, "SUBPRIME:", 0);
  428. SECU_PrintInteger(stdout, &pqg->base, "BASE:", 0);
  429. }
  431. static void
  432. dump_dsakey(DSAPrivateKey *key)
  433. {
  434. dump_pqg(&key->params);
  435. SECU_PrintInteger(stdout, &key->publicValue, "PUBLIC VALUE:", 0);
  436. SECU_PrintInteger(stdout, &key->privateValue, "PRIVATE VALUE:", 0);
  437. }
  439. /*  Multi-purpose crypto information */
  440. typedef struct 
  441. {
  442. PRBool  encrypt;
  443. PRBool  decrypt;
  444. PRBool  sign;
  445. PRBool  verify;
  446. PRBool  hash;
  447. SECItem seed;
  448. SECItem pqg;
  449. SECItem key;
  450.     SECItem iv;
  451.     SECItem in;
  452.     SECItem out;
  453. SECItem sigseed;
  454. PRInt32 keysize;
  455. PRInt32 bufsize;
  456. PRBool  useseed;
  457. PRBool  usesigseed;
  458. PRBool  performance;
  459. PRBool  multihash;
  460. PQGParams *params;      /* DSA only */
  461. unsigned int rounds;    /* RC5 only */
  462. unsigned int wordsize;  /* RC5 only */
  463. unsigned int rsapubexp; /* RSA only */
  464. unsigned int repetitions; /* performance tests only */
  465. } blapitestInfo;
  467. /* Macros for performance timing. */
  468. #define TIMESTART() 
  469. if (info->performance) 
  470. time1 = PR_IntervalNow();
  472. #define TIMEFINISH(mode, nb) 
  473. if (info->performance) { 
  474. time2 = (PRIntervalTime)(PR_IntervalNow() - time1); 
  475. time1 = PR_IntervalToMilliseconds(time2); 
  476. printf("%s,%d,%.3fn", mode, nb, ((float)(time1))/info->repetitions); 
  477. }
  479. SECStatus
  480. fillitem(SECItem *item, int numbytes, char *filename)
  481. {
  482. if (item->len == 0)
  483. return get_and_write_random_bytes(item, numbytes, filename);
  484. return SECSuccess;
  485. }
  487. /************************
  488. **  DES 
  489. ************************/
  491. /*  encrypt/decrypt for all DES */
  492. static SECStatus
  493. des_common(DESContext *descx, blapitestInfo *info)
  494. {
  495. PRInt32 maxsize;
  496. SECStatus rv;
  497. PRIntervalTime time1, time2;
  498. int i, numiter;
  499. numiter = info->repetitions;
  500. maxsize = info->in.len;
  501. info->out.data = (unsigned char *)PORT_ZAlloc(maxsize);
  502. if (info->encrypt) {
  503. TIMESTART();
  504. for (i=0; i<numiter; i++)
  505. rv = DES_Encrypt(descx, info->out.data, &info->out.len, maxsize,
  506.                  info->in.data, info->in.len);
  507. TIMEFINISH("DES ENCRYPT", maxsize);
  508. if (rv) {
  509. fprintf(stderr, "%s:  Failed to encrypt!n", progName);
  510. CHECKERROR(rv, __LINE__);
  511. }
  512. } else {
  513. TIMESTART();
  514. for (i=0; i<numiter; i++)
  515. rv = DES_Decrypt(descx, info->out.data, &info->out.len, maxsize,
  516.                  info->in.data, info->in.len);
  517. TIMEFINISH("DES DECRYPT", maxsize);
  518. if (rv) {
  519. fprintf(stderr, "%s:  Failed to decrypt!n", progName);
  520. CHECKERROR(rv, __LINE__);
  521. }
  522. }
  523. return rv;
  524. }
  526. /*  DES codebook mode */
  527. static SECStatus
  528. des_ecb_test(blapitestInfo *info)
  529. {
  530. SECStatus rv;
  531. DESContext *descx;
  532. PRIntervalTime time1, time2;
  533. int i, numiter = info->repetitions;
  534. fillitem(&info->key, DES_KEY_LENGTH, "tmp.key");
  535. fillitem(&info->in, info->bufsize, "tmp.pt");
  536. TIMESTART();
  537. for (i=0; i<numiter-1; i++) {
  538. descx = DES_CreateContext(info->key.data, NULL, NSS_DES, info->encrypt);
  539. DES_DestroyContext(descx, PR_TRUE);
  540. }
  541. descx = DES_CreateContext(info->key.data, NULL, NSS_DES, info->encrypt);
  542. TIMEFINISH("DES ECB CONTEXT CREATE", info->key.len);
  543. if (!descx) {
  544. fprintf(stderr,"%s:  Failed to create encryption context!n", progName);
  545. return SECFailure;
  546. }
  547. rv = des_common(descx, info);
  548. CHECKERROR(rv, __LINE__);
  549. DES_DestroyContext(descx, PR_TRUE);
  550. return rv;
  551. }
  553. /*  DES chaining mode */
  554. static SECStatus
  555. des_cbc_test(blapitestInfo *info)
  556. {
  557. SECStatus rv;
  558. DESContext *descx;
  559. PRIntervalTime time1, time2;
  560. int i, numiter = info->repetitions;
  561. fillitem(&info->key, DES_KEY_LENGTH, "tmp.key");
  562. fillitem(&info->in, info->bufsize, "tmp.pt");
  563. fillitem(&info->iv, DES_KEY_LENGTH, "tmp.iv");
  564. TIMESTART();
  565. for (i=0; i<numiter-1; i++) {
  566. descx = DES_CreateContext(info->key.data, info->iv.data, NSS_DES_CBC, 
  567.                           info->encrypt);
  568. DES_DestroyContext(descx, PR_TRUE);
  569. }
  570. descx = DES_CreateContext(info->key.data, info->iv.data, NSS_DES_CBC, 
  571.                           info->encrypt);
  572. TIMEFINISH("DES CBC CONTEXT CREATE", info->key.len);
  573. if (!descx) {
  574. PR_fprintf(PR_STDERR, 
  575.   "%s:  Failed to create encryption context!n", progName);
  576. return SECFailure;
  577. }
  578. if (info->performance) {
  579. /*  In chaining mode, repeated iterations of the encryption
  580.  *  function using the same context will alter the final output.
  581.  *  So, once the performance test is done, reset the context
  582.  *  and perform a single iteration to obtain the correct result.
  583.  */
  584. int tmp = info->repetitions;
  585. rv = des_common(descx, info);
  586. DES_DestroyContext(descx, PR_TRUE);
  587. descx = DES_CreateContext(info->key.data, info->iv.data, NSS_DES_CBC, 
  588.                           info->encrypt);
  589. info->performance = PR_FALSE;
  590. info->repetitions = 1;
  591. rv = des_common(descx, info);
  592. info->performance = PR_TRUE;
  593. info->repetitions = tmp;
  594. } else {
  595. rv = des_common(descx, info);
  596. }
  597. CHECKERROR(rv, __LINE__);
  598. DES_DestroyContext(descx, PR_TRUE);
  599. return rv;
  600. }
  602. /*  3-key Triple-DES codebook mode */
  603. static SECStatus
  604. des_ede_ecb_test(blapitestInfo *info)
  605. {
  606. SECStatus rv;
  607. DESContext *descx;
  608. PRIntervalTime time1, time2;
  609. int i, numiter = info->repetitions;
  610. fillitem(&info->key, 3*DES_KEY_LENGTH, "tmp.key");
  611. fillitem(&info->in, info->bufsize, "tmp.pt");
  612. TIMESTART();
  613. for (i=0; i<numiter-1; i++) {
  614. descx = DES_CreateContext(info->key.data, NULL, NSS_DES_EDE3,
  615.                           info->encrypt);
  616. DES_DestroyContext(descx, PR_TRUE);
  617. }
  618. descx = DES_CreateContext(info->key.data, NULL, NSS_DES_EDE3,
  619.                           info->encrypt);
  620. TIMEFINISH("3DES ECB CONTEXT CREATE", info->key.len);
  621. if (!descx) {
  622. fprintf(stderr,"%s:  Failed to create encryption context!n", progName);
  623. return SECFailure;
  624. }
  625. rv = des_common(descx, info);
  626. CHECKERROR(rv, __LINE__);
  627. DES_DestroyContext(descx, PR_TRUE);
  628. return rv;
  629. }
  631. /*  3-key Triple-DES chaining mode */
  632. static SECStatus
  633. des_ede_cbc_test(blapitestInfo *info)
  634. {
  635. SECStatus rv;
  636. DESContext *descx;
  637. PRIntervalTime time1, time2;
  638. int i, numiter = info->repetitions;
  639. fillitem(&info->key, 3*DES_KEY_LENGTH, "tmp.key");
  640. fillitem(&info->in, info->bufsize, "tmp.pt");
  641. fillitem(&info->iv, DES_KEY_LENGTH, "tmp.iv");
  642. TIMESTART();
  643. for (i=0; i<numiter-1; i++) {
  644. descx = DES_CreateContext(info->key.data, info->iv.data, 
  645.                           NSS_DES_EDE3_CBC, info->encrypt);
  646. DES_DestroyContext(descx, PR_TRUE);
  647. }
  648. descx = DES_CreateContext(info->key.data, info->iv.data, NSS_DES_EDE3_CBC, 
  649.                           info->encrypt);
  650. TIMEFINISH("3DES CBC CONTEXT CREATE", info->key.len);
  651. if (!descx) {
  652. fprintf(stderr,"%s:  Failed to create encryption context!n", progName);
  653. return SECFailure;
  654. }
  655. if (info->performance) {
  656. /*  In chaining mode, repeated iterations of the encryption
  657.  *  function using the same context will alter the final output.
  658.  *  So, once the performance test is done, reset the context
  659.  *  and perform a single iteration to obtain the correct result.
  660.  */
  661. int tmp = info->repetitions;
  662. rv = des_common(descx, info);
  663. DES_DestroyContext(descx, PR_TRUE);
  664. descx = DES_CreateContext(info->key.data, info->iv.data, 
  665.                           NSS_DES_EDE3_CBC, info->encrypt);
  666. info->performance = PR_FALSE;
  667. info->repetitions = 1;
  668. rv = des_common(descx, info);
  669. info->performance = PR_TRUE;
  670. info->repetitions = tmp;
  671. } else {
  672. rv = des_common(descx, info);
  673. }
  674. CHECKERROR(rv, __LINE__);
  675. DES_DestroyContext(descx, PR_TRUE);
  676. return rv;
  677. }
  679. /************************
  680. **  RC2 
  681. ************************/
  683. /*  RC2 ECB */
  684. static SECStatus
  685. rc2_ecb_test(blapitestInfo *info)
  686. {
  687. SECStatus rv;
  688. RC2Context *rc2cx;
  689. PRIntervalTime time1, time2;
  690. int i, numiter = info->repetitions;
  691. fillitem(&info->key, info->keysize, "tmp.key");
  692. fillitem(&info->in, info->bufsize, "tmp.pt");
  693. TIMESTART();
  694. for (i=0; i<numiter-1; i++) {
  695. rc2cx = RC2_CreateContext(info->key.data, info->key.len, NULL, 
  696.                           NSS_RC2, info->key.len);
  697. RC2_DestroyContext(rc2cx, PR_TRUE);
  698. }
  699. rc2cx = RC2_CreateContext(info->key.data, info->key.len, NULL, 
  700.                           NSS_RC2, info->key.len);
  701. TIMEFINISH("RC2 ECB CONTEXT CREATE", info->key.len);
  702. if (!rc2cx) {
  703. fprintf(stderr,"%s:  Failed to create encryption context!n", progName);
  704. return SECFailure;
  705. }
  706. info->out.len = 2*info->in.len;
  707. info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
  708. if (info->encrypt) {
  709. TIMESTART();
  710. for (i=0; i<numiter; i++)
  711. rv = RC2_Encrypt(rc2cx, info->out.data, &info->out.len, 
  712.                  info->out.len, info->in.data, info->in.len);
  713. TIMEFINISH("RC2 ECB ENCRYPT", info->in.len);
  714. CHECKERROR(rv, __LINE__);
  715. } else {
  716. TIMESTART();
  717. for (i=0; i<numiter; i++)
  718. rv = RC2_Decrypt(rc2cx, info->out.data, &info->out.len, 
  719.                  info->out.len, info->in.data, info->in.len);
  720. TIMEFINISH("RC2 ECB DECRYPT", info->in.len);
  721. CHECKERROR(rv, __LINE__);
  722. }
  723. RC2_DestroyContext(rc2cx, PR_TRUE);
  724. return rv;
  725. }
  727. /*  RC2 CBC */
  728. static SECStatus
  729. rc2_cbc_test(blapitestInfo *info)
  730. {
  731. SECStatus rv;
  732. RC2Context *rc2cx;
  733. PRIntervalTime time1, time2;
  734. int i, numiter = info->repetitions;
  735. fillitem(&info->key, info->keysize, "tmp.key");
  736. fillitem(&info->in, info->bufsize, "tmp.pt");
  737. fillitem(&info->iv, info->bufsize, "tmp.iv");
  738. TIMESTART();
  739. for (i=0; i<numiter-1; i++) {
  740. rc2cx = RC2_CreateContext(info->key.data, info->key.len, info->iv.data, 
  741.                           NSS_RC2_CBC, info->key.len);
  742. RC2_DestroyContext(rc2cx, PR_TRUE);
  743. }
  744. rc2cx = RC2_CreateContext(info->key.data, info->key.len, info->iv.data, 
  745.                           NSS_RC2_CBC, info->key.len);
  746. TIMEFINISH("RC2 CBC CONTEXT CREATE", info->key.len);
  747. if (!rc2cx) {
  748. fprintf(stderr,"%s:  Failed to create encryption context!n", progName);
  749. return SECFailure;
  750. }
  751. info->out.len = 2*info->in.len;
  752. info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
  753. if (info->encrypt) {
  754. TIMESTART();
  755. for (i=0; i<numiter; i++)
  756. rv = RC2_Encrypt(rc2cx, info->out.data, &info->out.len, 
  757.                  info->out.len, info->in.data, info->in.len);
  758. TIMEFINISH("RC2 CBC ENCRYPT", info->in.len);
  759. if (info->performance) {
  760. /*  reset the context */
  761. RC2_DestroyContext(rc2cx, PR_TRUE);
  762. rc2cx = RC2_CreateContext(info->key.data, info->key.len, 
  763.                          info->iv.data, NSS_RC2_CBC, info->key.len);
  764. rv = RC2_Encrypt(rc2cx, info->out.data, &info->out.len, 
  765.                  info->out.len, info->in.data, info->in.len);
  766. }
  767. CHECKERROR(rv, __LINE__);
  768. if (rv) {
  769. fprintf(stderr, "%s:  Failed to encrypt!n", progName);
  770. CHECKERROR(rv, __LINE__);
  771. }
  772. } else {
  773. TIMESTART();
  774. for (i=0; i<numiter; i++)
  775. rv = RC2_Decrypt(rc2cx, info->out.data, &info->out.len, 
  776.                  info->out.len, info->in.data, info->in.len);
  777. TIMEFINISH("RC2 CBC DECRYPT", info->in.len);
  778. if (info->performance) {
  779. /*  reset the context */
  780. RC2_DestroyContext(rc2cx, PR_TRUE);
  781. rc2cx = RC2_CreateContext(info->key.data, info->key.len, 
  782.                          info->iv.data, NSS_RC2_CBC, info->key.len);
  783. rv = RC2_Decrypt(rc2cx, info->out.data, &info->out.len, 
  784.                  info->out.len, info->in.data, info->in.len);
  785. }
  786. if (rv) {
  787. fprintf(stderr, "%s:  Failed to decrypt!n", progName);
  788. CHECKERROR(rv, __LINE__);
  789. }
  790. }
  791. RC2_DestroyContext(rc2cx, PR_TRUE);
  792. return rv;
  793. }
  795. /************************
  796. **  RC4 
  797. ************************/
  799. static SECStatus
  800. rc4_test(blapitestInfo *info)
  801. {
  802. SECStatus rv;
  803. RC4Context *rc4cx;
  804. PRIntervalTime time1, time2;
  805. int i, numiter;
  806. numiter = info->repetitions;
  807. fillitem(&info->key, info->keysize, "tmp.key");
  808. fillitem(&info->in, info->bufsize, "tmp.pt");
  809. TIMESTART();
  810. for (i=0; i<numiter-1; i++) {
  811. rc4cx = RC4_CreateContext(info->key.data, info->key.len);
  812. RC4_DestroyContext(rc4cx, PR_TRUE);
  813. }
  814. rc4cx = RC4_CreateContext(info->key.data, info->key.len);
  815. TIMEFINISH("RC4 CONTEXT CREATE", info->key.len);
  816. if (!rc4cx) {
  817. fprintf(stderr,"%s:  Failed to create encryption context!n", progName);
  818. return SECFailure;
  819. }
  820. info->out.len = 2*info->in.len;
  821. info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
  822. if (info->encrypt) {
  823. TIMESTART();
  824. for (i=0; i<numiter; i++)
  825. rv = RC4_Encrypt(rc4cx, info->out.data, &info->out.len, 
  826.                  info->out.len, info->in.data, info->in.len);
  827. TIMEFINISH("RC4 ENCRYPT", info->in.len);
  828. if (info->performance) {
  829. /*  reset the context */
  830. RC4_DestroyContext(rc4cx, PR_TRUE);
  831. rc4cx = RC4_CreateContext(info->key.data, info->key.len);
  832. rv = RC4_Encrypt(rc4cx, info->out.data, &info->out.len, 
  833.                  info->out.len, info->in.data, info->in.len);
  834. }
  835. if (rv) {
  836. fprintf(stderr, "%s:  Failed to encrypt!n", progName);
  837. CHECKERROR(rv, __LINE__);
  838. }
  839. } else {
  840. TIMESTART();
  841. for (i=0; i<numiter; i++)
  842. rv = RC4_Decrypt(rc4cx, info->out.data, &info->out.len, 
  843.                  info->out.len, info->in.data, info->in.len);
  844. TIMEFINISH("RC4 DECRYPT", info->in.len);
  845. if (info->performance) {
  846. /*  reset the context */
  847. RC4_DestroyContext(rc4cx, PR_TRUE);
  848. rc4cx = RC4_CreateContext(info->key.data, info->key.len);
  849. rv = RC4_Decrypt(rc4cx, info->out.data, &info->out.len, 
  850.                  info->out.len, info->in.data, info->in.len);
  851. }
  852. if (rv) {
  853. fprintf(stderr, "%s:  Failed to decrypt!n", progName);
  854. CHECKERROR(rv, __LINE__);
  855. }
  856. }
  857. RC4_DestroyContext(rc4cx, PR_TRUE);
  858. return rv;
  859. }
  861. #if NSS_SOFTOKEN_DOES_RC5
  862. /************************
  863. **  RC5 
  864. ************************/
  866. /*  RC5 ECB */
  867. static SECStatus
  868. rc5_ecb_test(blapitestInfo *info)
  869. {
  870. SECStatus rv;
  871. RC5Context *rc5cx;
  872. PRIntervalTime time1, time2;
  873. int i, numiter;
  874. numiter = info->repetitions;
  875. fillitem(&info->key, info->keysize, "tmp.key");
  876. fillitem(&info->in, info->bufsize, "tmp.pt");
  877. TIMESTART();
  878. for (i=0; i<numiter-1; i++) {
  879. rc5cx = RC5_CreateContext(&info->key, info->rounds, info->wordsize, 
  880.                           NULL, NSS_RC5);
  881. RC5_DestroyContext(rc5cx, PR_TRUE);
  882. }
  883. rc5cx = RC5_CreateContext(&info->key, info->rounds, info->wordsize, 
  884.                           NULL, NSS_RC5);
  885. TIMEFINISH("RC5 ECB CONTEXT CREATE", info->key.len);
  886. if (!rc5cx) {
  887. fprintf(stderr,"%s:  Failed to create encryption context!n", progName);
  888. return SECFailure;
  889. }
  890. info->out.len = 2*info->in.len;
  891. info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
  892. if (info->encrypt) {
  893. TIMESTART();
  894. for (i=0; i<numiter; i++)
  895. rv = RC5_Encrypt(rc5cx, info->out.data, &info->out.len, 
  896.                  info->out.len, info->in.data, info->in.len);
  897. TIMEFINISH("RC5 ECB ENCRYPT", info->in.len);
  898. if (rv) {
  899. fprintf(stderr, "%s:  Failed to encrypt!n", progName);
  900. CHECKERROR(rv, __LINE__);
  901. }
  902. } else {
  903. TIMESTART();
  904. for (i=0; i<numiter; i++)
  905. rv = RC5_Decrypt(rc5cx, info->out.data, &info->out.len, 
  906.                  info->out.len, info->in.data, info->in.len);
  907. TIMEFINISH("RC5 ECB ENCRYPT", info->in.len);
  908. if (rv) {
  909. fprintf(stderr, "%s:  Failed to decrypt!n", progName);
  910. CHECKERROR(rv, __LINE__);
  911. }
  912. }
  913. RC5_DestroyContext(rc5cx, PR_TRUE);
  914. return rv;
  915. }
  917. /*  RC5 CBC */
  918. static SECStatus
  919. rc5_cbc_test(blapitestInfo *info)
  920. {
  921. SECStatus rv;
  922. RC5Context *rc5cx;
  923. PRIntervalTime time1, time2;
  924. int i, numiter;
  925. numiter = info->repetitions;
  926. fillitem(&info->key, info->keysize, "tmp.key");
  927. fillitem(&info->in, info->bufsize, "tmp.pt");
  928. fillitem(&info->iv, info->bufsize, "tmp.iv");
  929. TIMESTART();
  930. for (i=0; i<numiter-1; i++) {
  931. rc5cx = RC5_CreateContext(&info->key, info->rounds, info->wordsize, 
  932.                           info->iv.data, NSS_RC5_CBC);
  933. RC5_DestroyContext(rc5cx, PR_TRUE);
  934. }
  935. rc5cx = RC5_CreateContext(&info->key, info->rounds, info->wordsize, 
  936.                           info->iv.data, NSS_RC5_CBC);
  937. TIMEFINISH("RC5 CBC CONTEXT CREATE", info->key.len);
  938. if (!rc5cx) {
  939. fprintf(stderr,"%s:  Failed to create encryption context!n", progName);
  940. return SECFailure;
  941. }
  942. info->out.len = 2*info->in.len;
  943. info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
  944. if (info->encrypt) {
  945. TIMESTART();
  946. for (i=0; i<numiter; i++)
  947. rv = RC5_Encrypt(rc5cx, info->out.data, &info->out.len, 
  948.                  info->out.len, info->in.data, info->in.len);
  949. TIMEFINISH("RC5 CBC ENCRYPT", info->in.len);
  950. if (info->performance) {
  951. /*  reset the context */
  952. RC5_DestroyContext(rc5cx, PR_TRUE);
  953. rc5cx = RC5_CreateContext(&info->key, info->rounds, info->wordsize, 
  954.                           info->iv.data, NSS_RC5_CBC);
  955. rv = RC5_Encrypt(rc5cx, info->out.data, &info->out.len, 
  956.                  info->out.len, info->in.data, info->in.len);
  957. }
  958. if (rv) {
  959. fprintf(stderr, "%s:  Failed to encrypt!n", progName);
  960. CHECKERROR(rv, __LINE__);
  961. }
  962. } else {
  963. TIMESTART();
  964. for (i=0; i<numiter; i++)
  965. rv = RC5_Decrypt(rc5cx, info->out.data, &info->out.len, 
  966.                  info->out.len, info->in.data, info->in.len);
  967. TIMEFINISH("RC5 CBC DECRYPT", info->in.len);
  968. if (info->performance) {
  969. /*  reset the context */
  970. RC5_DestroyContext(rc5cx, PR_TRUE);
  971. rc5cx = RC5_CreateContext(&info->key, info->rounds, info->wordsize, 
  972.                           info->iv.data, NSS_RC5_CBC);
  973. rv = RC5_Decrypt(rc5cx, info->out.data, &info->out.len, 
  974.                  info->out.len, info->in.data, info->in.len);
  975. }
  976. if (rv) {
  977. fprintf(stderr, "%s:  Failed to decrypt!n", progName);
  978. CHECKERROR(rv, __LINE__);
  979. }
  980. }
  981. RC5_DestroyContext(rc5cx, PR_TRUE);
  982. return rv;
  983. }
  984. #endif
  986. static SECStatus
  987. rsa_test(blapitestInfo *info)
  988. {
  989. RSAPrivateKey *key;
  990. SECItem expitem;
  991. SECStatus rv;
  992. PRIntervalTime time1, time2;
  993. int i, j, numiter;
  994. unsigned int modLen;
  995. numiter = info->repetitions;
  996. fillitem(&info->in, info->bufsize, "tmp.pt");
  997. if (info->key.len > 0) {
  998. key = rsakey_from_filedata(&info->key);
  999. } else {
  1000. expitem.len = 4;
  1001. expitem.data = (unsigned char *)PORT_ZAlloc(4);
  1002. expitem.data[0] = (info->rsapubexp >> 24) & 0xff;
  1003. expitem.data[1] = (info->rsapubexp >> 16) & 0xff;
  1004. expitem.data[2] = (info->rsapubexp >>  8) & 0xff;
  1005. expitem.data[3] = (info->rsapubexp & 0xff);
  1006. TIMESTART();
  1007. for (i=0; i<numiter-1; i++) {
  1008. key = RSA_NewKey(info->keysize*8, &expitem);
  1009. PORT_FreeArena(key->arena, PR_TRUE);
  1010. }
  1011. key = RSA_NewKey(info->keysize*8, &expitem);
  1012. TIMEFINISH("RSA KEY GEN", info->keysize);
  1013. rsakey_to_file(key, "tmp.key");
  1014. }
  1015. if (key->modulus.data[0] == 0) {
  1016. /* integer value of input must be less than modulus */
  1017. if (info->in.data[0] >= key->modulus.data[1])
  1018. return SECFailure;
  1019. } else {
  1020. if (info->in.data[0] >= key->modulus.data[0])
  1021. return SECFailure;
  1022. }
  1023. modLen = key->modulus.len - !key->modulus.data[0];
  1024. if (info->in.len % modLen != 0) {
  1025. fprintf(stderr, "Input buffer must be a multiple of modulus length!n");
  1026. return SECFailure;
  1027. }
  1028. info->out.len = info->in.len; 
  1029. info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
  1030. if (info->encrypt) {
  1031. RSAPublicKey pubkey;
  1032. SECITEM_CopyItem(key->arena, &pubkey.modulus, &key->modulus);
  1033. SECITEM_CopyItem(key->arena, &pubkey.publicExponent, 
  1034.                              &key->publicExponent);
  1035. TIMESTART();
  1036. for (i=0; i<numiter; i++) {
  1037. for (j=0; j<info->in.len; j+=pubkey.modulus.len) {
  1038. rv = RSA_PublicKeyOp(&pubkey, &info->out.data[j], 
  1039.                               &info->in.data[j]);
  1040. }
  1041. }
  1042. TIMEFINISH("RSA ENCRYPT", info->in.len);
  1043. CHECKERROR(rv, __LINE__);
  1044. } else {
  1045. TIMESTART();
  1046. for (i=info->repetitions; i>0; i--) {
  1047. for (j=0; j<info->in.len; j+=key->modulus.len) {
  1048. rv = RSA_PrivateKeyOp(key, &info->out.data[j], 
  1049.                            &info->in.data[j]);
  1050. }
  1051. }
  1052. TIMEFINISH("RSA DECRYPT", info->in.len);
  1053. CHECKERROR(rv, __LINE__);
  1054. }
  1055. PORT_FreeArena(key->arena, PR_TRUE);
  1056. return SECSuccess;
  1057. }
  1059. static SECStatus
  1060. pqg_test(blapitestInfo *info)
  1061. {
  1062. SECStatus rv = SECSuccess;
  1063. PQGVerify *verify;
  1064. PRIntervalTime time1, time2;
  1065. int i, numiter;
  1066. numiter = info->repetitions;
  1067. if (info->pqg.len > 0) {
  1068. info->params = pqg_from_filedata(&info->pqg);
  1069. } else {
  1070. TIMESTART();
  1071. for (i=0; i<numiter-1; i++) {
  1072. rv = PQG_ParamGen(info->keysize, &info->params, &verify);
  1073. PORT_FreeArena(info->params->arena, PR_TRUE);
  1074. }
  1075. rv = PQG_ParamGen(info->keysize, &info->params, &verify);
  1076. TIMEFINISH("PQG PARAM GEN", info->keysize);
  1077. pqg_to_file(info->params, "tmp.pqg");
  1078. }
  1079. CHECKERROR(rv, __LINE__);
  1080. return rv;
  1081. }
  1083. static SECStatus
  1084. dsa_test(blapitestInfo *info)
  1085. {
  1086. DSAPrivateKey *key;
  1087. SECStatus rv = SECSuccess;
  1088. PRIntervalTime time1, time2;
  1089. int i, numiter;
  1090. numiter = info->repetitions;
  1091. fillitem(&info->in, info->bufsize, "tmp.pt");
  1092. if (info->key.len > 0) {
  1093. key = dsakey_from_filedata(&info->key);
  1094. } else {
  1095. pqg_test(info);
  1096. if (info->useseed) {
  1097. if (info->seed.len == 0)
  1098. get_and_write_random_bytes(&info->seed, DSA_SUBPRIME_LEN, 
  1099.                            "tmp.seed");
  1100. rv = DSA_NewKeyFromSeed(info->params, info->seed.data, &key);
  1101. } else {
  1102. rv = DSA_NewKey(info->params, &key);
  1103. }
  1104. CHECKERROR(rv, __LINE__);
  1105. dsakey_to_file(key, "tmp.key");
  1106. }
  1107. if (info->sign) {
  1108. info->out.len = DSA_SIGNATURE_LEN;
  1109. info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
  1110. if (info->usesigseed) {
  1111. if (info->sigseed.len == 0)
  1112. get_and_write_random_bytes(&info->sigseed, DSA_SUBPRIME_LEN,
  1113.                            "tmp.sigseed");
  1114. TIMESTART();
  1115. rv = DSA_SignDigestWithSeed(key, &info->out, &info->in, 
  1116.                             info->sigseed.data);
  1117. TIMEFINISH("DSA SIGN", info->in.len);
  1118. } else {
  1119. TIMESTART();
  1120. for (i=0; i<numiter; i++)
  1121. rv = DSA_SignDigest(key, &info->out, &info->in);
  1122. TIMEFINISH("DSA SIGN", info->in.len);
  1123. }
  1124. CHECKERROR(rv, __LINE__);
  1125. } else {
  1126. DSAPublicKey pubkey;
  1127. PRArenaPool *arena;
  1128. arena = key->params.arena;
  1129. SECITEM_CopyItem(arena, &pubkey.params.prime, &key->params.prime);
  1130. SECITEM_CopyItem(arena, &pubkey.params.subPrime, &key->params.subPrime);
  1131. SECITEM_CopyItem(arena, &pubkey.params.base, &key->params.base);
  1132. SECITEM_CopyItem(arena, &pubkey.publicValue, &key->publicValue);
  1133. TIMESTART();
  1134. for (i=0; i<numiter; i++)
  1135. rv = DSA_VerifyDigest(&pubkey, &info->out, &info->in);
  1136. TIMEFINISH("DSA VERIFY", info->in.len);
  1137. if (rv != SECSuccess) {
  1138. PR_fprintf(PR_STDOUT, "Signature failed verification!n");
  1139. CHECKERROR(rv, __LINE__);
  1140. } /*else {
  1141. PR_fprintf(PR_STDOUT, "Signature verified.n");
  1142. }*/
  1143. }
  1144. PORT_FreeArena(key->params.arena, PR_TRUE);
  1145. return SECSuccess;
  1146. }
  1148. static SECStatus
  1149. md5_multi_test(blapitestInfo *info)
  1150. {
  1151. SECStatus rv = SECSuccess;
  1152. MD5Context *md5cx;
  1153. unsigned int len;
  1154. MD5Context *foomd5cx;
  1155. unsigned char *foomd5;
  1156. int i;
  1157. if (info->in.len == 0) {
  1158. rv = get_and_write_random_bytes(&info->in, info->bufsize, "tmp.pt");
  1159. CHECKERROR(rv, __LINE__);
  1160. }
  1161. md5cx = MD5_NewContext();
  1162. if (!md5cx) {
  1163. PR_fprintf(PR_STDERR, 
  1164.    "%s:  Failed to create hash context!n", progName);
  1165. return SECFailure;
  1166. }
  1167. info->out.len = MD5_LENGTH;
  1168. info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
  1169. MD5_Begin(md5cx);
  1170. for (i=0; i<info->bufsize/8; i++) {
  1171. MD5_Update(md5cx, &info->in.data[i*8], 8);
  1172. len = MD5_FlattenSize(md5cx);
  1173. foomd5 = PORT_Alloc(len);
  1174. MD5_Flatten(md5cx, foomd5);
  1175. foomd5cx = MD5_Resurrect(foomd5, NULL);
  1176. rv = PORT_Memcmp(foomd5cx, md5cx, len);
  1177. if (rv != SECSuccess)
  1178. PR_fprintf(PR_STDERR, "%s:  MD5_Resurrect failed!n", progName);
  1179. MD5_DestroyContext(foomd5cx, PR_TRUE);
  1180. PORT_Free(foomd5);
  1181. }
  1182. MD5_End(md5cx, info->out.data, &len, MD5_LENGTH);
  1183. if (len != MD5_LENGTH)
  1184. PR_fprintf(PR_STDERR, "%s: Bad hash size %d.n", progName, len);
  1185. MD5_DestroyContext(md5cx, PR_TRUE);
  1186. return rv;
  1187. }
  1189. static SECStatus
  1190. md5_test(blapitestInfo *info)
  1191. {
  1192. SECStatus rv = SECSuccess;
  1193. PRIntervalTime time1, time2;
  1194. int i;
  1195. if (!info->hash) return SECFailure;
  1196. if (info->multihash) return md5_multi_test(info);
  1197. if (info->in.len == 0) {
  1198. rv = get_and_write_random_bytes(&info->in, info->bufsize, "tmp.pt");
  1199. CHECKERROR(rv, __LINE__);
  1200. }
  1201. info->out.len = MD5_LENGTH;
  1202. info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
  1203. TIMESTART();
  1204. for (i=info->repetitions; i>0; i--) {
  1205. MD5_HashBuf(info->out.data, info->in.data, info->in.len);
  1206. }
  1207. TIMEFINISH("MD5 HASH", info->in.len);
  1208. return rv;
  1209. }
  1211. static SECStatus
  1212. md2_multi_test(blapitestInfo *info)
  1213. {
  1214. SECStatus rv = SECSuccess;
  1215. MD2Context *md2cx;
  1216. unsigned int len;
  1217. MD2Context *foomd2cx;
  1218. unsigned char *foomd2;
  1219. int i;
  1220. if (!info->hash) return SECFailure;
  1221. if (info->in.len == 0) {
  1222. rv = get_and_write_random_bytes(&info->in, info->bufsize, "tmp.pt");
  1223. CHECKERROR(rv, __LINE__);
  1224. }
  1225. md2cx = MD2_NewContext();
  1226. if (!md2cx) {
  1227. PR_fprintf(PR_STDERR, 
  1228.    "%s:  Failed to create hash context!n", progName);
  1229. return SECFailure;
  1230. }
  1231. info->out.len = MD2_LENGTH;
  1232. info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
  1233. MD2_Begin(md2cx);
  1234. for (i=0; i<info->bufsize/8; i++) {
  1235. MD2_Update(md2cx, &info->in.data[i*8], 8);
  1236. len = MD2_FlattenSize(md2cx);
  1237. foomd2 = PORT_Alloc(len);
  1238. MD2_Flatten(md2cx, foomd2);
  1239. foomd2cx = MD2_Resurrect(foomd2, NULL);
  1240. rv = PORT_Memcmp(foomd2cx, md2cx, len);
  1241. if (rv != SECSuccess)
  1242. PR_fprintf(PR_STDERR, "%s:  MD2_Resurrect failed!n", progName);
  1243. MD2_DestroyContext(foomd2cx, PR_TRUE);
  1244. PORT_Free(foomd2);
  1245. }
  1246. MD2_End(md2cx, info->out.data, &len, MD2_LENGTH);
  1247. if (len != MD2_LENGTH)
  1248. PR_fprintf(PR_STDERR, "%s: Bad hash size %d.n", progName, len);
  1249. MD2_DestroyContext(md2cx, PR_TRUE);
  1250. return rv;
  1251. }
  1253. static SECStatus
  1254. md2_test(blapitestInfo *info)
  1255. {
  1256. unsigned int len;
  1257. MD2Context *cx = MD2_NewContext();
  1258. SECStatus rv = SECSuccess;
  1259. PRIntervalTime time1, time2;
  1260. int i;
  1261. if (!info->hash) return SECFailure;
  1262. if (info->multihash) return md2_multi_test(info);
  1263. if (info->in.len == 0) {
  1264. rv = get_and_write_random_bytes(&info->in, info->bufsize, "tmp.pt");
  1265. CHECKERROR(rv, __LINE__);
  1266. }
  1267. info->out.len = 16;
  1268. info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
  1269. info->in.data[info->in.len] = '';
  1270. TIMESTART();
  1271. for (i=0; i<info->repetitions; i++) {
  1272. MD2_Begin(cx);
  1273. MD2_Update(cx, info->in.data, info->in.len);
  1274. MD2_End(cx, info->out.data, &len, 16);
  1275. }
  1276. TIMEFINISH("MD2 HASH", info->in.len);
  1277. MD2_DestroyContext(cx, PR_TRUE);
  1278. return rv;
  1279. }
  1281. static SECStatus
  1282. sha1_multi_test(blapitestInfo *info)
  1283. {
  1284. SECStatus rv = SECSuccess;
  1285. SHA1Context *sha1cx;
  1286. unsigned int len;
  1287. SHA1Context *foosha1cx;
  1288. unsigned char *foosha1;
  1289. int i;
  1290. if (info->in.len == 0) {
  1291. rv = get_and_write_random_bytes(&info->in, info->bufsize, "tmp.pt");
  1292. CHECKERROR(rv, __LINE__);
  1293. }
  1294. sha1cx = SHA1_NewContext();
  1295. if (!sha1cx) {
  1296. PR_fprintf(PR_STDERR, 
  1297.    "%s:  Failed to create hash context!n", progName);
  1298. return SECFailure;
  1299. }
  1300. info->out.len = SHA1_LENGTH;
  1301. info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
  1302. SHA1_Begin(sha1cx);
  1303. for (i=0; i<info->bufsize/8; i++) {
  1304. SHA1_Update(sha1cx, &info->in.data[i*8], 8);
  1305. len = SHA1_FlattenSize(sha1cx);
  1306. foosha1 = PORT_Alloc(len);
  1307. SHA1_Flatten(sha1cx, foosha1);
  1308. foosha1cx = SHA1_Resurrect(foosha1, NULL);
  1309. rv = PORT_Memcmp(foosha1cx, sha1cx, len);
  1310. if (rv != SECSuccess)
  1311. PR_fprintf(PR_STDERR, "%s:  SHA1_Resurrect failed!n", progName);
  1312. SHA1_DestroyContext(foosha1cx, PR_TRUE);
  1313. PORT_Free(foosha1);
  1314. }
  1315. SHA1_End(sha1cx, info->out.data, &len, SHA1_LENGTH);
  1316. if (len != SHA1_LENGTH)
  1317. PR_fprintf(PR_STDERR, "%s: Bad hash size %d.n", progName, len);
  1318. SHA1_DestroyContext(sha1cx, PR_TRUE);
  1319. return rv;
  1320. }
  1322. static SECStatus
  1323. sha1_test(blapitestInfo *info)
  1324. {
  1325. unsigned int len;
  1326. SHA1Context *cx = SHA1_NewContext();
  1327. SECStatus rv = SECSuccess;
  1328. PRIntervalTime time1, time2;
  1329. int i;
  1330. if (!info->hash) return SECFailure;
  1331. if (info->multihash) return sha1_multi_test(info);
  1332. if (info->in.len == 0) {
  1333. rv = get_and_write_random_bytes(&info->in, info->bufsize, "tmp.pt");
  1334. CHECKERROR(rv, __LINE__);
  1335. }
  1336. info->out.len = SHA1_LENGTH;
  1337. info->out.data = (unsigned char *)PORT_ZAlloc(info->out.len);
  1338. info->in.data[info->in.len] = '';
  1339. TIMESTART();
  1340. for (i=info->repetitions; i>0; i--) {
  1341. SHA1_Begin(cx);
  1342. SHA1_Update(cx, info->in.data, info->in.len);
  1343. SHA1_End(cx, info->out.data, &len, SHA1_LENGTH);
  1344. }
  1345. TIMEFINISH("SHA1 HASH", info->in.len);
  1346. SHA1_DestroyContext(cx, PR_TRUE);
  1347. return rv;
  1348. }
  1350. typedef SECStatus (* blapitestCryptoFn)(blapitestInfo *);
  1352. static blapitestCryptoFn crypto_fns[] =
  1353. {
  1354. des_ecb_test,
  1355. des_cbc_test,
  1356. des_ede_ecb_test,
  1357. des_ede_cbc_test,
  1358. rc2_ecb_test,
  1359. rc2_cbc_test,
  1360. rc4_test,
  1361. #if NSS_SOFTOKEN_DOES_RC5
  1362. rc5_ecb_test,
  1363. rc5_cbc_test,
  1364. #endif
  1365. rsa_test,
  1366. NULL,
  1367. pqg_test,
  1368. dsa_test,
  1369. NULL,
  1370. md5_test,
  1371. md2_test,
  1372. sha1_test,
  1373. NULL
  1374. };
  1376. static char *mode_strings[] =
  1377. {
  1378. "des_ecb",
  1379. "des_cbc",
  1380. "des3_ecb",
  1381. "des3_cbc",
  1382. "rc2_ecb",
  1383. "rc2_cbc",
  1384. "rc4",
  1385. #if NSS_SOFTOKEN_DOES_RC5
  1386. "rc5_ecb",
  1387. "rc5_cbc",
  1388. #endif
  1389. "rsa",
  1390. "#endencrypt",
  1391. "pqg",
  1392. "dsa",
  1393. "#endsign",
  1394. "md5",
  1395. "md2",
  1396. "sha1",
  1397. "#endhash"
  1398. };
  1400. static void
  1401. printmodes(blapitestInfo *info)
  1402. {
  1403. int i = 0;
  1404. char *mode = mode_strings[0];
  1405. PR_fprintf(PR_STDERR, "Available modes: (specify with -m)n", progName);
  1406. while (mode[0] != '#') {
  1407. if (info->encrypt || info->decrypt)
  1408. fprintf(stderr, "%sn", mode);
  1409. mode = mode_strings[++i];
  1410. }
  1411. mode = mode_strings[++i];
  1412. while (mode[0] != '#') {
  1413. if (info->sign || info->verify)
  1414. fprintf(stderr, "%sn", mode);
  1415. mode = mode_strings[++i];
  1416. }
  1417. mode = mode_strings[++i];
  1418. while (mode[0] != '#') {
  1419. if (info->hash)
  1420. fprintf(stderr, "%sn", mode);
  1421. mode = mode_strings[++i];
  1422. }
  1423. }
  1425. static blapitestCryptoFn
  1426. get_test_mode(const char *modestring)
  1427. {
  1428. int i;
  1429. int nummodes = sizeof(mode_strings) / sizeof(char *);
  1430. for (i=0; i<nummodes; i++)
  1431. if (PL_strcmp(modestring, mode_strings[i]) == 0)
  1432. return crypto_fns[i];
  1433. PR_fprintf(PR_STDERR, "%s: invalid mode: %sn", progName, modestring);
  1434. return NULL;
  1435. }
  1437. static void
  1438. get_params(blapitestInfo *info, char *mode, int num)
  1439. {
  1440. SECItem *item;
  1441. /* XXX
  1442.  * this should use NSPR, but the string functions (strchr and atoi)
  1443.  * barf when the commented code below is used.
  1444. PRFileDesc *file;
  1445. */
  1446. FILE *file;
  1447. char filename[256];
  1448. char *mark, *param, *val;
  1449. int index = 0;
  1450. int len;
  1451. sprintf(filename, "%s/tests/%s/params%d", testdir, mode, num);
  1452. /*
  1453. file = PR_Open(filename, PR_RDONLY, 00440);
  1454. if (file)
  1455. SECU_FileToItem(item, file);
  1456. else
  1457. return;
  1458. param = (char *)item->data;
  1459. */
  1460. file = fopen(filename, "r");
  1461. if (!file) return;
  1462. param = malloc(100);
  1463. len = fread(param, 1, 100, file);
  1464. while (index < len) {
  1465. mark = PL_strchr(param, '=');
  1466. *mark = '';
  1467. val = mark + 1;
  1468. mark = PL_strchr(val, 'n');
  1469. *mark = '';
  1470. if (PL_strcmp(param, "rounds") == 0) {
  1471. info->rounds = atoi(val);
  1472. } else if (PL_strcmp(param, "wordsize") == 0) {
  1473. info->wordsize = atoi(val);
  1474. }
  1475. index += PL_strlen(param) + PL_strlen(val) + 2;
  1476. param = mark + 1;
  1477. }
  1478. }
  1480. static SECStatus
  1481. get_ascii_file_data(SECItem *item, char *mode, char *type, int num)
  1482. {
  1483. char filename[256];
  1484. PRFileDesc *file;
  1485. SECStatus rv;
  1486. sprintf(filename, "%s/tests/%s/%s%d", testdir, mode, type, num);
  1487. file = PR_Open(filename, PR_RDONLY, 00440);
  1488. if (!file) {
  1489. /* Not a failure if "mode" does not need "type". */
  1490. return SECSuccess;
  1491. }
  1492. if (((PL_strcmp(mode, "rsa") == 0 || PL_strcmp(mode, "dsa") == 0) && 
  1493.       PL_strcmp(type, "key") == 0) ||
  1494.    (PL_strcmp(mode, "dsa") == 0 && PL_strcmp(type, "plaintext") == 0)) {
  1495. rv = SECU_FileToItem(item, file);
  1496. atob(SECITEM_DupItem(item), item);
  1497. } else {
  1498. rv = SECU_TextFileToItem(item, file);
  1499. }
  1500. PR_Close(file);
  1501. return rv;
  1502. }
  1504. static SECStatus
  1505. blapi_selftest(char **modesToTest, int numModesToTest, 
  1506.                PRBool encrypt, PRBool decrypt)
  1507. {
  1508. blapitestCryptoFn cryptofn;
  1509. blapitestInfo info;
  1510. SECItem output = { 0, 0, 0 };
  1511. SECItem asciiOut = { 0, 0, 0 };
  1512. SECItem inpCopy = { 0, 0, 0 };
  1513. SECItem item = { 0, 0, 0 };
  1514. SECStatus rv;
  1515. char filename[256];
  1516. PRFileDesc *file;
  1517. char *mode;
  1518. int i, j, nummodes;
  1520. PORT_Memset(&info, 0, sizeof(info));
  1521. info.repetitions = 1;
  1522. info.useseed = PR_TRUE;
  1523. info.usesigseed = PR_TRUE;
  1524. if (modesToTest) {
  1525. /* user gave a list of modes to test */
  1526. nummodes = numModesToTest;
  1527. } else {
  1528. /* test all modes */
  1529. nummodes = sizeof(mode_strings) / sizeof(char *);
  1530. }
  1531. for (i=0; i<nummodes; i++) {
  1532. if (modesToTest) {
  1533. mode = modesToTest[i];
  1534. } else {
  1535. mode = mode_strings[i];
  1536. }
  1537. /* skip pqg - nothing to do for self-test. */
  1538. if (PL_strcmp(mode, "pqg") == 0)
  1539. continue;
  1540. cryptofn = get_test_mode(mode);
  1541. if (mode[0] == '#') continue;
  1542. /* get the number of tests in the directory */
  1543. sprintf(filename, "%s/tests/%s/%s", testdir, mode, "numtests");
  1544. file = PR_Open(filename, PR_RDONLY, 00440);
  1545. if (!file) {
  1546. fprintf(stderr, "File %s does not exist.n", filename);
  1547. return SECFailure;
  1548. }
  1549. memset(&item, 0, sizeof(item));
  1550. rv = SECU_FileToItem(&item, file);
  1551. PR_Close(file);
  1552. /* loop over the tests in the directory */
  1553. for (j=0; j<(int)(item.data[0] - '0'); j++) {
  1554. memset(&info.key, 0, sizeof(info.key));
  1555. memset(&info.iv, 0, sizeof(info.iv));
  1556. memset(&info.in, 0, sizeof(info.in));
  1557. memset(&info.seed, 0, sizeof(info.seed));
  1558. memset(&info.sigseed, 0, sizeof(info.sigseed));
  1559. rv = get_ascii_file_data(&info.key, mode, "key", j);
  1560. rv = get_ascii_file_data(&info.iv, mode, "iv", j);
  1561. rv = get_ascii_file_data(&info.in, mode, "plaintext", j);
  1562. #if 0
  1563. rv = get_ascii_file_data(&info.seed, mode, "keyseed", j);
  1564. #endif
  1565. rv = get_ascii_file_data(&info.sigseed, mode, "sigseed", j);
  1566. SECITEM_CopyItem(NULL, &inpCopy, &info.in);
  1567. get_params(&info, mode, j);
  1568. sprintf(filename, "%s/tests/%s/%s%d", testdir, mode, 
  1569.         "ciphertext", j);
  1570. file = PR_Open(filename, PR_RDONLY, 00440);
  1571. memset(&asciiOut, 0, sizeof(asciiOut));
  1572. rv = SECU_FileToItem(&asciiOut, file);
  1573. PR_Close(file);
  1574. rv = atob(&asciiOut, &output);
  1575. if (!encrypt) goto decrypt;
  1576. info.encrypt = info.hash = info.sign = PR_TRUE;
  1577. (*cryptofn)(&info);
  1578. if (SECITEM_CompareItem(&output, &info.out) != 0) {
  1579. printf("encrypt self-test for %s failed!n", mode);
  1580. } /*else {
  1581. printf("encrypt self-test for %s passed.n", mode);
  1582. }*/
  1583. decrypt:
  1584. if (!decrypt) continue;
  1585. if (PL_strcmp(mode, "md2") == 0 ||
  1586.     PL_strcmp(mode, "md5") == 0 ||
  1587.     PL_strcmp(mode, "sha1") == 0) {
  1588. continue; /* hashes only go once */
  1589. }
  1590. info.encrypt = info.hash = info.sign = PR_FALSE;
  1591. info.decrypt = info.verify = PR_TRUE;
  1592. if (PL_strcmp(mode, "dsa") == 0) {
  1593. if (info.out.len == 0)
  1594.     SECITEM_CopyItem(NULL, &info.out, &output);
  1595. rv = (*cryptofn)(&info);
  1596. if (rv != SECSuccess) {
  1597. printf("signature self-test for %s failed!n", mode);
  1598. } /*else {
  1599. printf("signature self-test for %s passed.n", mode);
  1600. }*/
  1601. } else {
  1602. SECITEM_ZfreeItem(&info.in, PR_FALSE);
  1603. SECITEM_ZfreeItem(&info.out, PR_FALSE);
  1604. SECITEM_CopyItem(NULL, &info.in, &output);
  1605. info.out.len = 0;
  1606. rv = (*cryptofn)(&info);
  1607. if (rv == SECSuccess) {
  1608. if (SECITEM_CompareItem(&inpCopy, &info.out) != 0) {
  1609. printf("decrypt self-test for %s failed!n", mode);
  1610. } /*else {
  1611. printf("decrypt self-test for %s passed.n", mode);
  1612. }*/
  1613. }
  1614. }
  1615. }
  1616. }
  1617. return SECSuccess;
  1618. }
  1620. static SECStatus
  1621. get_file_data(char *filename, SECItem *item, PRBool b64) 
  1622. {
  1623. SECStatus rv = SECSuccess;
  1624. PRFileDesc *file = PR_Open(filename, PR_RDONLY, 006600);
  1625. if (file) {
  1626. if (b64) {
  1627. SECItem asciiItem = { 0, 0, 0 };
  1628. rv = SECU_FileToItem(&asciiItem, file);
  1629. CHECKERROR(rv, __LINE__);
  1630. rv = atob(&asciiItem, item);
  1631. } else {
  1632. rv = SECU_FileToItem(item, file);
  1633. CHECKERROR(rv, __LINE__);
  1634. }
  1635. CHECKERROR(rv, __LINE__);
  1636. PR_Close(file);
  1637. }
  1638. return rv;
  1639. }
  1641. SECStatus
  1642. dump_file(char *mode, char *filename)
  1643. {
  1644. SECItem item;
  1645. if (PL_strcmp(mode, "rsa") == 0) {
  1646. } else if (PL_strcmp(mode, "pqg") == 0) {
  1647. PQGParams *pqg;
  1648. get_file_data(filename, &item, PR_TRUE);
  1649. pqg = pqg_from_filedata(&item);
  1650. dump_pqg(pqg);
  1651. } else if (PL_strcmp(mode, "dsa") == 0) {
  1652. DSAPrivateKey *key;
  1653. get_file_data(filename, &item, PR_TRUE);
  1654. key = dsakey_from_filedata(&item);
  1655. dump_dsakey(key);
  1656. }
  1657. return SECFailure;
  1658. }
  1660. int main(int argc, char **argv) 
  1661. {
  1662. char *infile, *outfile, *keyfile, *ivfile, *sigfile, *seedfile,
  1663.      *sigseedfile, *pqgfile;
  1664. PRBool b64 = PR_TRUE;
  1665. blapitestInfo info;
  1666. blapitestCryptoFn cryptofn = NULL;
  1667. PLOptState *optstate;
  1668. PLOptStatus status;
  1669. PRBool dofips = PR_FALSE;
  1670. PRBool doselftest = PR_FALSE;
  1671. PRBool zerobuffer = PR_FALSE;
  1672. char *dumpfile = NULL;
  1673. char *mode = NULL;
  1674. char *modesToTest[20];
  1675. int numModesToTest = 0;
  1676. SECStatus rv;
  1678. PORT_Memset(&info, 0, sizeof(info));
  1679. info.bufsize = 8;
  1680. info.keysize = DES_KEY_LENGTH;
  1681. info.rsapubexp = 17;
  1682. info.rounds = 10;
  1683. info.wordsize = 4;
  1684. infile=outfile=keyfile=pqgfile=ivfile=sigfile=seedfile=sigseedfile=NULL;
  1685. info.repetitions = 1;
  1686.     progName = strrchr(argv[0], '/');
  1687.     progName = progName ? progName+1 : argv[0];
  1688. optstate = PL_CreateOptState(argc, argv, 
  1689.     "DEFHP:STVab:d:ce:g:j:i:o:p:k:m:t:qr:s:v:w:xyz:");
  1690. while ((status = PL_GetNextOpt(optstate)) == PL_OPT_OK) {
  1691. switch (optstate->option) {
  1692. case 'D':  info.decrypt = PR_TRUE; break;
  1693. case 'E':  info.encrypt = PR_TRUE; break;
  1694. case 'F':  dofips = PR_TRUE; break;
  1695. case 'H':  info.hash = PR_TRUE; break;
  1696. case 'P':  dumpfile = PL_strdup(optstate->value); break;
  1697. case 'S':  info.sign = PR_TRUE; break;
  1698. case 'T':  doselftest = PR_TRUE; break;
  1699. case 'V':  info.verify = PR_TRUE; break;
  1700. case 'a':  b64 = PR_FALSE; break;
  1701. case 'b':  info.bufsize = PORT_Atoi(optstate->value); break;
  1702. case 'c':  info.multihash = PR_TRUE; break;
  1703. case 'd':  testdir = PL_strdup(optstate->value); break;
  1704. case 'e':  info.rsapubexp = PORT_Atoi(optstate->value); break;
  1705. case 'g':  info.keysize = PORT_Atoi(optstate->value); break;
  1706. case 'i':  infile  = PL_strdup(optstate->value); break;
  1707. case 'j':  pqgfile = PL_strdup(optstate->value); break;
  1708. case 'k':  keyfile = PL_strdup(optstate->value); break;
  1709. case 'm':  cryptofn = get_test_mode(optstate->value);
  1710.            mode = PL_strdup(optstate->value); 
  1711.            break;
  1712. case 'o':  outfile = PL_strdup(optstate->value); break;
  1713. case 'p':  info.performance = PR_TRUE; 
  1714.    info.repetitions = PORT_Atoi(optstate->value); 
  1715.    break;
  1716. case 'q':  zerobuffer = PR_TRUE; break;
  1717. case 'r':  info.rounds = PORT_Atoi(optstate->value); break;
  1718. case 's':  sigfile  = PL_strdup(optstate->value); break;
  1719. case 't':  sigseedfile = PL_strdup(optstate->value); break;
  1720. case 'v':  ivfile  = PL_strdup(optstate->value); break;
  1721. case 'w':  info.wordsize = PORT_Atoi(optstate->value); break;
  1722. case 'x':  info.useseed = PR_TRUE; break;
  1723. case 'y':  info.usesigseed = PR_TRUE; break;
  1724. case 'z':  seedfile  = PL_strdup(optstate->value); break;
  1725. case '': if (optstate->value[0] != '-')
  1726.    modesToTest[numModesToTest++] = 
  1727. PL_strdup(optstate->value);
  1728.    break;
  1729. default: break;
  1730. }
  1731. }
  1733. if (dumpfile)
  1734. return dump_file(mode, dumpfile);
  1736. if (doselftest) {
  1737. if (!info.encrypt && !info.decrypt) {
  1738. info.encrypt = info.decrypt = PR_TRUE;  /* do both */
  1739. }
  1740. if (numModesToTest > 0) {
  1741. return blapi_selftest(modesToTest, numModesToTest,
  1742.                       info.encrypt, info.decrypt);
  1743. } else {
  1744. return blapi_selftest(NULL, 0, info.encrypt, info.decrypt);
  1745. }
  1746. }
  1748. if (dofips) {
  1749. CK_RV foo = pk11_fipsPowerUpSelfTest();
  1750. PR_fprintf(PR_STDOUT, "CK_RV: %d.n", foo);
  1751. return 0;
  1752. }
  1754. if (!info.encrypt && !info.decrypt && !info.hash && 
  1755.     !info.sign && !info.verify)
  1756. Usage();
  1758. if (!cryptofn) {
  1759. printmodes(&info);
  1760. return -1;
  1761. }
  1763. if (info.decrypt && !infile)
  1764. Usage();
  1766. if (info.performance) {
  1767. char buf[256];
  1768. PRStatus stat;
  1769. stat = PR_GetSystemInfo(PR_SI_HOSTNAME, buf, sizeof(buf));
  1770. printf("HOST: %sn", buf);
  1771. stat = PR_GetSystemInfo(PR_SI_SYSNAME, buf, sizeof(buf));
  1772. printf("SYSTEM: %sn", buf);
  1773. stat = PR_GetSystemInfo(PR_SI_RELEASE, buf, sizeof(buf));
  1774. printf("RELEASE: %sn", buf);
  1775. stat = PR_GetSystemInfo(PR_SI_ARCHITECTURE, buf, sizeof(buf));
  1776. printf("ARCH: %sn", buf);
  1777. }
  1779. RNG_RNGInit();
  1780. RNG_SystemInfoForRNG();
  1782. if (keyfile) {
  1783. /* RSA and DSA keys are always b64 encoded. */
  1784. if (b64 || PL_strcmp(mode,"rsa")==0 || PL_strcmp(mode,"dsa")==0)
  1785. get_file_data(keyfile, &info.key, PR_TRUE);
  1786. else
  1787. get_file_data(keyfile, &info.key, b64);
  1788. }
  1789. if (ivfile)
  1790. get_file_data(ivfile, &info.iv, b64);
  1791. if (infile)
  1792. get_file_data(infile, &info.in, b64);
  1793. if (sigfile)
  1794. get_file_data(sigfile, &info.out, PR_TRUE);
  1795. if (seedfile) {
  1796. get_file_data(seedfile, &info.seed, b64);
  1797. info.useseed = PR_TRUE;
  1798. }
  1799. if (sigseedfile) {
  1800. get_file_data(sigseedfile, &info.sigseed, b64);
  1801. info.usesigseed = PR_TRUE;
  1802. }
  1803. if (pqgfile)
  1804. get_file_data(pqgfile, &info.pqg, PR_TRUE);
  1806. if (zerobuffer) {
  1807. PRFileDesc *ifile;
  1808. info.in.len = info.bufsize;
  1809. info.in.data = PORT_ZAlloc(info.in.len);
  1810. ifile = PR_Open("tmp.pt", PR_WRONLY|PR_CREATE_FILE, 00660);
  1811. rv = btoa_file(&info.in, ifile);
  1812. CHECKERROR((rv < 0), __LINE__);
  1813. PR_Close(ifile);
  1814. }
  1816. rv = (*cryptofn)(&info);
  1817. CHECKERROR(rv, __LINE__);
  1819. if (!sigfile && info.out.len > 0) {
  1820. PRFileDesc *ofile;
  1821. if (!outfile)
  1822. ofile = PR_Open("tmp.out", PR_WRONLY|PR_CREATE_FILE, 00660);
  1823. else
  1824. ofile = PR_Open(outfile, PR_WRONLY|PR_CREATE_FILE, 00660);
  1825. rv = btoa_file(&info.out, ofile);
  1826. PR_Close(ofile);
  1827. CHECKERROR((rv < 0), __LINE__);
  1828. }
  1830. RNG_RNGShutdown();
  1832. return SECSuccess;
  1833. }