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

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

CA认证

开发平台：

WINDOWS

pk11.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 "modutil.h"
  35. #include "secmodti.h"
  36. #include "pk11func.h"
  38. extern PK11DefaultArrayEntry PK11_DefaultArray[];
  39. extern int num_pk11_default_mechanisms;
  40. extern SECStatus PK11_UpdateSlotAttribute(PK11SlotInfo*, PK11DefaultArrayEntry*,
  41. PRBool);
  43. /*************************************************************************
  44.  *
  45.  * F i p s M o d e
  46.  * If arg=="true", enable FIPS mode on the internal module.  If arg=="false",
  47.  * disable FIPS mode on the internal module.
  48.  */
  49. Error
  50. FipsMode(char *arg)
  51. {
  53. char *internal_name;
  55. if(!PORT_Strcasecmp(arg, "true")) {
  56. if(!PK11_IsFIPS()) {
  57. internal_name = PR_smprintf("%s",
  58. SECMOD_GetInternalModule()->commonName);
  59. if(SECMOD_DeleteInternalModule(internal_name) != SECSuccess) {
  60. PR_smprintf_free(internal_name);
  61. PR_fprintf(PR_STDERR, errStrings[FIPS_SWITCH_FAILED_ERR]);
  62. return FIPS_SWITCH_FAILED_ERR;
  63. }
  64. PR_smprintf_free(internal_name);
  65. PR_fprintf(PR_STDOUT, msgStrings[FIPS_ENABLED_MSG]);
  66. } else {
  67. PR_fprintf(PR_STDERR, errStrings[FIPS_ALREADY_ON_ERR]);
  68. return FIPS_ALREADY_ON_ERR;
  69. }
  70. } else if(!PORT_Strcasecmp(arg, "false")) {
  71. if(PK11_IsFIPS()) {
  72. internal_name = PR_smprintf("%s",
  73. SECMOD_GetInternalModule()->commonName);
  74. if(SECMOD_DeleteInternalModule(internal_name) != SECSuccess) {
  75. PR_smprintf_free(internal_name);
  76. PR_fprintf(PR_STDERR, errStrings[FIPS_SWITCH_FAILED_ERR]);
  77. return FIPS_SWITCH_FAILED_ERR;
  78. }
  79. PR_smprintf_free(internal_name);
  80. PR_fprintf(PR_STDOUT, msgStrings[FIPS_DISABLED_MSG]);
  81. } else {
  82. PR_fprintf(PR_STDERR, errStrings[FIPS_ALREADY_OFF_ERR]);
  83. return FIPS_ALREADY_OFF_ERR;
  84. }
  85. } else {
  86. PR_fprintf(PR_STDERR, errStrings[INVALID_FIPS_ARG]);
  87. return INVALID_FIPS_ARG;
  88. }
  90. return SUCCESS;
  91. }
  93. /************************************************************************
  94.  * Cipher and Mechanism name-bitmask translation tables
  95.  */
  97. typedef struct {
  98. char *name;
  99. unsigned long mask;
  100. } MaskString;
  102. static MaskString mechanismStrings[] = {
  103. {"RSA", PUBLIC_MECH_RSA_FLAG},
  104. {"DSA", PUBLIC_MECH_DSA_FLAG},
  105. {"RC2", PUBLIC_MECH_RC2_FLAG},
  106. {"RC4", PUBLIC_MECH_RC4_FLAG},
  107. {"RC5", PUBLIC_MECH_RC5_FLAG},
  108. {"DES", PUBLIC_MECH_DES_FLAG},
  109. {"DH", PUBLIC_MECH_DH_FLAG},
  110. {"FORTEZZA", PUBLIC_MECH_FORTEZZA_FLAG},
  111. {"SHA1", PUBLIC_MECH_SHA1_FLAG},
  112. {"MD5", PUBLIC_MECH_MD5_FLAG},
  113. {"MD2", PUBLIC_MECH_MD2_FLAG},
  114. {"SSL", PUBLIC_MECH_SSL_FLAG},
  115. {"TLS", PUBLIC_MECH_TLS_FLAG},
  116. {"RANDOM", PUBLIC_MECH_RANDOM_FLAG},
  117. {"FRIENDLY", PUBLIC_MECH_FRIENDLY_FLAG}
  118. };
  119. static int numMechanismStrings = 13;
  121. static MaskString cipherStrings[] = {
  122. {"FORTEZZA", PUBLIC_CIPHER_FORTEZZA_FLAG}
  123. };
  124. static int numCipherStrings= 1;
  126. /* Maximum length of a colon-separated list of all the strings in an 
  127.  * array. */
  128. #define MAX_STRING_LIST_LEN 240 /* or less */
  130. /************************************************************************
  131.  * 
  132.  * g e t F l a g s F r o m S t r i n g
  133.  *
  134.  * Parses a mechanism list passed on the command line and converts it
  135.  * to an unsigned long bitmask.
  136.  * string is a colon-separated string of constants
  137.  * array is an array of MaskStrings.
  138.  * elements is the number of elements in array.
  139.  */
  140. static unsigned long
  141. getFlagsFromString(char *string, MaskString array[], int elements)
  142. {
  143. unsigned long ret = 0;
  144. short i = 0;
  145. char *cp;
  146. char *buf;
  147. char *end;
  149. if(!string || !string[0]) {
  150. return ret;
  151. }
  153. /* Make a temporary copy of the string */
  154. buf = PR_Malloc(strlen(string)+1);
  155. if(!buf) {
  156. out_of_memory();
  157. }
  158. strcpy(buf, string);
  160. /* Look at each element of the list passed in */
  161. for(cp=buf; cp && *cp; cp = (end ? end+1 : NULL) ) {
  162. /* Look at the string up to the next colon */
  163. end = strchr(cp, ':');
  164. if(end) {
  165. *end = '';
  166. }
  168. /* Find which element this is */
  169. for(i=0; i < elements; i++) {
  170. if( !PORT_Strcasecmp(cp, array[i].name) ) {
  171. break;
  172. }
  173. }
  174. if(i == elements) {
  175. /* Skip a bogus string, but print a warning message */
  176. PR_fprintf(PR_STDERR, errStrings[INVALID_CONSTANT_ERR], cp);
  177. continue;
  178. }
  179. ret |= array[i].mask;
  180. }
  182. PR_Free(buf);
  183. return ret;
  184. }
  186. /**********************************************************************
  187.  *
  188.  * g e t S t r i n g F r o m F l a g s
  189.  * 
  190.  * The return string's memory is owned by this function.  Copy it
  191.  * if you need it permanently or you want to change it.
  192.  */
  193. static char *
  194. getStringFromFlags(unsigned long flags, MaskString array[], int elements)
  195. {
  196. static char buf[MAX_STRING_LIST_LEN];
  197. int i;
  198. int count=0;
  200. buf[0] = '';
  201. for(i=0; i<elements; i++) {
  202. if( flags & array[i].mask ) {
  203. ++count;
  204. if(count!=1) {
  205. strcat(buf, ":");
  206. }
  207. strcat(buf, array[i].name);
  208. }
  209. }
  210. return buf;
  211. }
  213. /**********************************************************************
  214.  *
  215.  * A d d M o d u l e
  216.  *
  217.  * Add the named module, with the given library file, ciphers, and
  218.  * default mechanism flags
  219.  */
  220. Error
  221. AddModule(char *moduleName, char *libFile, char *cipherString,
  222. char *mechanismString)
  223. {
  224. unsigned long ciphers;
  225. unsigned long mechanisms;
  226. SECStatus status;
  228. mechanisms =
  229. getFlagsFromString(mechanismString, mechanismStrings,
  230.   numMechanismStrings);
  231. ciphers =
  232. getFlagsFromString(cipherString, cipherStrings, numCipherStrings);
  234. status =
  235. SECMOD_AddNewModule(moduleName, libFile,
  236.   SECMOD_PubMechFlagstoInternal(mechanisms),
  237.   SECMOD_PubCipherFlagstoInternal(ciphers) );
  239. if(status != SECSuccess) {
  240. PR_fprintf(PR_STDERR, errStrings[ADD_MODULE_FAILED_ERR], moduleName);
  241. return ADD_MODULE_FAILED_ERR;
  242. } else {
  243. PR_fprintf(PR_STDOUT, msgStrings[ADD_MODULE_SUCCESS_MSG], moduleName);
  244. return SUCCESS;
  245. }
  246. }
  248. /***********************************************************************
  249.  *
  250.  * D e l e t e M o d u l e
  251.  *
  252.  * Deletes the named module from the database.
  253.  */
  254. Error
  255. DeleteModule(char *moduleName)
  256. {
  257. SECStatus status;
  258. int type;
  260. status = SECMOD_DeleteModule(moduleName, &type);
  262. if(status != SECSuccess) {
  263. if(type == SECMOD_FIPS || type == SECMOD_INTERNAL) {
  264. PR_fprintf(PR_STDERR, errStrings[DELETE_INTERNAL_ERR]);
  265. return DELETE_INTERNAL_ERR;
  266. } else {
  267. PR_fprintf(PR_STDERR, errStrings[DELETE_FAILED_ERR], moduleName);
  268. return DELETE_FAILED_ERR;
  269. }
  270. }
  272. PR_fprintf(PR_STDOUT, msgStrings[DELETE_SUCCESS_MSG], moduleName);
  273. return SUCCESS;
  274. }
  276. /************************************************************************
  277.  *
  278.  * L i s t M o d u l e s
  279.  *
  280.  * Lists all the modules in the database, along with their slots and tokens.
  281.  */
  282. Error
  283. ListModules()
  284. {
  285. SECMODListLock *lock;
  286. SECMODModuleList *list;
  287. SECMODModuleList *mlp;
  288. Error ret=UNSPECIFIED_ERR;
  289. int count = 0, i;
  291. lock = SECMOD_GetDefaultModuleListLock();
  292. if(!lock) {
  293. PR_fprintf(PR_STDERR, errStrings[NO_LIST_LOCK_ERR]);
  294. return NO_LIST_LOCK_ERR;
  295. }
  297. SECMOD_GetReadLock(lock);
  299. list = SECMOD_GetDefaultModuleList();
  300. if(!list) {
  301. PR_fprintf(PR_STDERR, errStrings[NO_MODULE_LIST_ERR]);
  302. ret = NO_MODULE_LIST_ERR;
  303. goto loser;
  304. }
  306. PR_fprintf(PR_STDOUT,
  307. "nListing of PKCS #11 Modulesn"
  308. "-----------------------------------------------------------n");
  310. for(mlp=list; mlp != NULL; mlp = mlp->next) {
  311. ++count;
  312. if(count!=1) {
  313. PR_fprintf(PR_STDOUT, "n");
  314. }
  316. PR_fprintf(PR_STDOUT, "%3d. %sn", count, mlp->module->commonName);
  318. if(mlp->module->dllName) {
  319. PR_fprintf(PR_STDOUT, "tlibrary name: %sn", mlp->module->dllName);
  320. }
  322. if(mlp->module->slotCount == 0) {
  323. PR_fprintf(PR_STDOUT,
  324. "t slots: There are no slots attached to this modulen");
  325. } else {
  326. PR_fprintf(PR_STDOUT,
  327. "t slots: %d slot%s attachedn", mlp->module->slotCount,
  328. (mlp->module->slotCount==1 ? "" : "s") );
  329. }
  331. if(mlp->module->loaded == 0) {
  332. PR_fprintf(PR_STDOUT, "tstatus: Not loadedn");
  333. } else {
  334. PR_fprintf(PR_STDOUT, "tstatus: loadedn");
  335. }
  337. /* Print slot and token names */
  338. for (i = 0; i < mlp->module->slotCount; i++) {
  339. PK11SlotInfo *slot = mlp->module->slots[i];
  341. PR_fprintf(PR_STDOUT, "n");
  342. PR_fprintf(PR_STDOUT, "t slot: %sn", PK11_GetSlotName(slot));
  343. PR_fprintf(PR_STDOUT, "ttoken: %sn", PK11_GetTokenName(slot));
  344. }
  345.     }
  347. PR_fprintf(PR_STDOUT,
  348. "-----------------------------------------------------------n");
  350. ret = SUCCESS;
  352. loser:
  353. SECMOD_ReleaseReadLock(lock);
  354. return ret;
  355. }
  357. /* Strings describing PK11DisableReasons */
  358. static int numDisableReasonStr = 5;
  359. static char *disableReasonStr[] = {
  360. "no reason",
  361. "user disabled",
  362. "could not initialize token",
  363. "could not verify token",
  364. "token not present"
  365. };
  367. /***********************************************************************
  368.  *
  369.  * L i s t M o d u l e
  370.  *
  371.  * Lists detailed information about the named module.
  372.  */
  373. Error
  374. ListModule(char *moduleName)
  375. {
  376. SECMODModule *module;
  377. PK11SlotInfo *slot;
  378. int slotnum;
  379. CK_INFO modinfo;
  380. CK_SLOT_INFO slotinfo;
  381. CK_TOKEN_INFO tokeninfo;
  382. char *ciphers, *mechanisms;
  383. PK11DisableReasons reason;
  385. if(!moduleName) {
  386. return SUCCESS;
  387. }
  389. module = SECMOD_FindModule(moduleName);
  390. if(!module) {
  391. PR_fprintf(PR_STDERR, errStrings[NO_SUCH_MODULE_ERR], moduleName);
  392. return NO_SUCH_MODULE_ERR;
  393. }
  395. if(PK11_GetModInfo(module, &modinfo) != SECSuccess) {
  396. PR_fprintf(PR_STDERR, errStrings[MOD_INFO_ERR], moduleName);
  397. return MOD_INFO_ERR;
  398. }
  400. /* Module info */
  401. PR_fprintf(PR_STDOUT, 
  402. "n-----------------------------------------------------------n");
  403. PR_fprintf(PR_STDOUT, "Name: %sn", module->commonName);
  404. if(module->internal || !module->dllName) {
  405. PR_fprintf(PR_STDOUT, "Library file: **Internal ONLY module**n");
  406. } else {
  407. PR_fprintf(PR_STDOUT, "Library file: %sn", module->dllName);
  408. }
  410. PR_fprintf(PR_STDOUT, "Manufacturer: %.32sn", modinfo.manufacturerID);
  411. PR_fprintf(PR_STDOUT, "Description: %.32sn", modinfo.libraryDescription);
  412. PR_fprintf(PR_STDOUT, "PKCS #11 Version %d.%dn",
  413. modinfo.cryptokiVersion.major, modinfo.cryptokiVersion.minor);
  414. PR_fprintf(PR_STDOUT, "Library Version: %d.%dn",
  415. modinfo.libraryVersion.major, modinfo.libraryVersion.minor);
  417. /* Get cipher and mechanism flags */
  418. ciphers = getStringFromFlags(module->ssl[0], cipherStrings,
  419.   numCipherStrings);
  420. if(ciphers[0] == '') {
  421. ciphers = "None";
  422. }
  423. PR_fprintf(PR_STDOUT, "Cipher Enable Flags: %sn", ciphers);
  424. mechanisms = NULL;
  425. if(module->slotCount > 0) {
  426. mechanisms = getStringFromFlags(module->slots[0]->defaultFlags,
  427. mechanismStrings, numMechanismStrings);
  428. }
  429. if(mechanisms[0] =='') {
  430. mechanisms = "None";
  431. }
  432. PR_fprintf(PR_STDOUT, "Default Mechanism Flags: %sn", mechanisms);
  434. #define PAD "  "
  436. /* Loop over each slot */
  437. for(slotnum=0; slotnum < module->slotCount; slotnum++) {
  438. slot = module->slots[slotnum];
  439. if(PK11_GetSlotInfo(slot, &slotinfo) != SECSuccess) {
  440. PR_fprintf(PR_STDERR, errStrings[SLOT_INFO_ERR],
  441. PK11_GetSlotName(slot));
  442. return SLOT_INFO_ERR;
  443. }
  444. if(PK11_GetTokenInfo(slot, &tokeninfo) != SECSuccess) {
  445. PR_fprintf(PR_STDERR, errStrings[TOKEN_INFO_ERR],
  446.   slot->token_name);
  447. return TOKEN_INFO_ERR;
  448. }
  450. /* Slot Info */
  451. PR_fprintf(PR_STDOUT, "n"PAD"Slot: %sn", PK11_GetSlotName(slot));
  452. mechanisms = getStringFromFlags(slot->defaultFlags,
  453. mechanismStrings, numMechanismStrings);
  454. if(mechanisms[0] =='') {
  455.      mechanisms = "None";
  456. }
  457. PR_fprintf(PR_STDOUT, PAD"Slot Mechanism Flags: %sn", mechanisms);
  458. PR_fprintf(PR_STDOUT, PAD"Manufacturer: %.32sn",
  459. slotinfo.manufacturerID);
  460. if(slot->isHW) {
  461. PR_fprintf(PR_STDOUT, PAD"Type: Hardwaren");
  462. } else {
  463. PR_fprintf(PR_STDOUT, PAD"Type: Softwaren");
  464. }
  465. PR_fprintf(PR_STDOUT, PAD"Version Number: %d.%dn",
  466. slotinfo.hardwareVersion.major, slotinfo.hardwareVersion.minor);
  467. PR_fprintf(PR_STDOUT, PAD"Firmware Version: %d.%dn",
  468. slotinfo.firmwareVersion.major, slotinfo.firmwareVersion.minor);
  469. if(slot->disabled) {
  470. reason  = PK11_GetDisabledReason(slot);
  471. if(reason < numDisableReasonStr) {
  472. PR_fprintf(PR_STDOUT, PAD"Status: DISABLED (%s)n",
  473.   disableReasonStr[reason]);
  474. } else {
  475. PR_fprintf(PR_STDOUT, PAD"Status: DISABLEDn");
  476. }
  477. } else {
  478. PR_fprintf(PR_STDOUT, PAD"Status: Enabledn");
  479. }
  481. /* Token Info */
  482. PR_fprintf(PR_STDOUT, PAD"Token Name: %.32sn",
  483. tokeninfo.label);
  484. PR_fprintf(PR_STDOUT, PAD"Token Manufacturer: %.32sn",
  485. tokeninfo.manufacturerID);
  486. PR_fprintf(PR_STDOUT, PAD"Token Model: %.16sn", tokeninfo.model);
  487. PR_fprintf(PR_STDOUT, PAD"Token Serial Number: %.16sn",
  488. tokeninfo.serialNumber);
  489. PR_fprintf(PR_STDOUT, PAD"Token Version: %d.%dn",
  490. tokeninfo.hardwareVersion.major, tokeninfo.hardwareVersion.minor);
  491. PR_fprintf(PR_STDOUT, PAD"Token Firmware Version: %d.%dn",
  492. tokeninfo.firmwareVersion.major, tokeninfo.firmwareVersion.minor);
  493. if(tokeninfo.flags & CKF_WRITE_PROTECTED) {
  494. PR_fprintf(PR_STDOUT, PAD"Access: Write Protectedn");
  495. } else {
  496. PR_fprintf(PR_STDOUT, PAD"Access: NOT Write Protectedn");
  497. }
  498. if(tokeninfo.flags & CKF_LOGIN_REQUIRED) {
  499. PR_fprintf(PR_STDOUT, PAD"Login Type: Login requiredn");
  500. } else {
  501. PR_fprintf(PR_STDOUT, PAD
  502.   "Login Type: Public (no login required)n");
  503. }
  504. if(tokeninfo.flags & CKF_USER_PIN_INITIALIZED) {
  505. PR_fprintf(PR_STDOUT, PAD"User Pin: Initializedn");
  506. } else {
  507. PR_fprintf(PR_STDOUT, PAD"User Pin: NOT Initializedn");
  508. }
  509. }
  510. PR_fprintf(PR_STDOUT, 
  511. "n-----------------------------------------------------------n");
  512. return SUCCESS;
  513. }
  515. /************************************************************************
  516.  *
  517.  * C h a n g e P W
  518.  */
  519. Error
  520. ChangePW(char *tokenName, char *pwFile, char *newpwFile)
  521. {
  522. char *oldpw=NULL, *newpw=NULL, *newpw2=NULL;
  523. PK11SlotInfo *slot;
  524. Error ret=UNSPECIFIED_ERR;
  525. PRBool matching;
  527. slot = PK11_FindSlotByName(tokenName);
  528. if(!slot) {
  529. PR_fprintf(PR_STDERR, errStrings[NO_SUCH_TOKEN_ERR], tokenName);
  530. return NO_SUCH_TOKEN_ERR;
  531. }
  533. PK11_SetPasswordFunc(SECU_GetModulePassword);
  535. /* Get old password */
  536. if(! PK11_NeedUserInit(slot)) {
  537. if(pwFile) {
  538. oldpw = SECU_GetPasswordString(pwFile, "");
  539. if(PK11_CheckUserPassword(slot, oldpw) != SECSuccess) {
  540. PR_fprintf(PR_STDERR, errStrings[BAD_PW_ERR]);
  541. ret=BAD_PW_ERR;
  542. goto loser;
  543. }
  544. } else {
  545. for(matching=PR_FALSE; !matching; ) {
  546. oldpw = SECU_GetPasswordString(NULL, "Enter old password: ");
  547. if(PK11_CheckUserPassword(slot, oldpw) == SECSuccess) {
  548. matching = PR_TRUE;
  549. } else {
  550. PR_fprintf(PR_STDOUT, msgStrings[BAD_PW_MSG]);
  551. }
  552. }
  553. }
  554. }
  556. /* Get new password */
  557. if(newpwFile) {
  558. newpw = SECU_GetPasswordString(newpwFile, "");
  559. } else {
  560. for(matching=PR_FALSE; !matching; ) {
  561. newpw = SECU_GetPasswordString(NULL, "Enter new password: ");
  562. newpw2 = SECU_GetPasswordString(NULL, "Re-enter new password: ");
  563. if(strcmp(newpw, newpw2)) {
  564. PR_fprintf(PR_STDOUT, msgStrings[PW_MATCH_MSG]);
  565. } else {
  566. matching = PR_TRUE;
  567. }
  568. }
  569. }
  571. /* Change the password */
  572. if(PK11_NeedUserInit(slot)) {
  573. if(PK11_InitPin(slot, NULL /*ssopw*/, newpw) != SECSuccess) {
  574. PR_fprintf(PR_STDERR, errStrings[CHANGEPW_FAILED_ERR], tokenName);
  575. ret = CHANGEPW_FAILED_ERR;
  576. goto loser;
  577. }
  578. } else {
  579. if(PK11_ChangePW(slot, oldpw, newpw) != SECSuccess) {
  580. PR_fprintf(PR_STDERR, errStrings[CHANGEPW_FAILED_ERR], tokenName);
  581. ret = CHANGEPW_FAILED_ERR;
  582. goto loser;
  583. }
  584. }
  586. PR_fprintf(PR_STDOUT, msgStrings[CHANGEPW_SUCCESS_MSG], tokenName);
  587. ret = SUCCESS;
  589. loser:
  590. if(oldpw) {
  591. memset(oldpw, 0, strlen(oldpw));
  592. PORT_Free(oldpw);
  593. }
  594. if(newpw) {
  595. memset(newpw, 0, strlen(newpw));
  596. PORT_Free(newpw);
  597. }
  598. if(newpw2) {
  599. memset(newpw2, 0, strlen(newpw));
  600. PORT_Free(newpw2);
  601. }
  602. return ret;
  603. }
  605. /***********************************************************************
  606.  *
  607.  * E n a b l e M o d u l e
  608.  *
  609.  * If enable==PR_TRUE, enables the module or slot.
  610.  * If enable==PR_FALSE, disables the module or slot.
  611.  * moduleName is the name of the module.
  612.  * slotName is the name of the slot.  It is optional.
  613.  */
  614. Error
  615. EnableModule(char *moduleName, char *slotName, PRBool enable)
  616. {
  617. int i;
  618. SECMODModule *module;
  619. PK11SlotInfo *slot = NULL;
  620. PRBool found = PR_FALSE;
  622. module = SECMOD_FindModule(moduleName);
  623. if(!module) {
  624. PR_fprintf(PR_STDERR, errStrings[NO_SUCH_MODULE_ERR], moduleName);
  625. return NO_SUCH_MODULE_ERR;
  626. }
  628. for(i=0; i < module->slotCount; i++) {
  629. slot = module->slots[i];
  630. if(slotName && strcmp(PK11_GetSlotName(slot), slotName)) {
  631. /* Not the right slot */
  632. continue;
  633. }
  634. if(enable) {
  635. if(! PK11_UserEnableSlot(slot)) {
  636. PR_fprintf(PR_STDERR, errStrings[ENABLE_FAILED_ERR],
  637. "enable", PK11_GetSlotName(slot));
  638. return ENABLE_FAILED_ERR;
  639. } else {
  640. found = PR_TRUE;
  641. PR_fprintf(PR_STDOUT, msgStrings[ENABLE_SUCCESS_MSG],
  642. PK11_GetSlotName(slot), "enabled");
  643. }
  644. } else {
  645. if(! PK11_UserDisableSlot(slot)) {
  646. PR_fprintf(PR_STDERR, errStrings[ENABLE_FAILED_ERR],
  647. "disable", PK11_GetSlotName(slot));
  648. return ENABLE_FAILED_ERR;
  649. } else {
  650. found = PR_TRUE;
  651. PR_fprintf(PR_STDOUT, msgStrings[ENABLE_SUCCESS_MSG],
  652. PK11_GetSlotName(slot), "disabled");
  653. }
  654. }
  655. }
  657. if(slotName && !found) {
  658. PR_fprintf(PR_STDERR, errStrings[NO_SUCH_SLOT_ERR], slotName);
  659. return NO_SUCH_SLOT_ERR;
  660. }
  662. /* Delete and re-add module to save changes */
  663. if( SECMOD_DeletePermDB(module) != SECSuccess ) {
  664. PR_fprintf(PR_STDERR, errStrings[UPDATE_MOD_FAILED_ERR], moduleName);
  665. return UPDATE_MOD_FAILED_ERR;
  666. }
  667. if( SECMOD_AddPermDB(module) != SECSuccess ) {
  668. /* We're in big trouble here */
  669. PR_fprintf(PR_STDERR, errStrings[UPDATE_MOD_FAILED_ERR], moduleName);
  670. return UPDATE_MOD_FAILED_ERR;
  671. }
  673. return SUCCESS;
  674. }
  676. /*************************************************************************
  677.  *
  678.  * S e t D e f a u l t M o d u l e
  679.  *
  680.  */
  681. Error
  682. SetDefaultModule(char *moduleName, char *slotName, char *mechanisms)
  683. {
  684. SECMODModule *module;
  685. PK11SlotInfo *slot;
  686. int s, i;
  687. unsigned long mechFlags = getFlagsFromString(mechanisms, mechanismStrings,
  688. numMechanismStrings);
  689. PRBool found = PR_FALSE;
  690. Error errcode = UNSPECIFIED_ERR;
  692. mechFlags =  SECMOD_PubMechFlagstoInternal(mechFlags);
  694. module = SECMOD_FindModule(moduleName);
  695. if(!module) {
  696. PR_fprintf(PR_STDERR, errStrings[NO_SUCH_MODULE_ERR], moduleName);
  697. errcode = NO_SUCH_MODULE_ERR;
  698. goto loser;
  699. }
  701. /* Go through each slot */
  702. for(s=0; s < module->slotCount; s++) {
  703. slot = module->slots[s];
  705. if ((slotName != NULL) &&
  706. !((strcmp(PK11_GetSlotName(slot),slotName) == 0) ||
  707. (strcmp(PK11_GetTokenName(slot),slotName) == 0)) ) {
  708.     /* we are only interested in changing the one slot */
  709.     continue;
  710. }
  712. found = PR_TRUE;
  714. /* Go through each mechanism */
  715. for(i=0; i < num_pk11_default_mechanisms; i++) {
  716. if(PK11_DefaultArray[i].flag & mechFlags) {
  717. /* Enable this default mechanism */
  718. PK11_UpdateSlotAttribute(slot, &(PK11_DefaultArray[i]),
  719. PR_TRUE);
  720. }
  721. }
  722. }
  723. if (slotName && !found) {
  724. PR_fprintf(PR_STDERR, errStrings[NO_SUCH_SLOT_ERR], slotName);
  725. errcode = NO_SUCH_SLOT_ERR;
  726. goto loser;
  727. }
  729. /* Delete and re-add module to save changes */
  730. if( SECMOD_DeletePermDB(module) != SECSuccess ) {
  731. PR_fprintf(PR_STDERR, errStrings[DEFAULT_FAILED_ERR],
  732.   moduleName);
  733. errcode = DEFAULT_FAILED_ERR;
  734. goto loser;
  735. }
  736. if( SECMOD_AddPermDB(module) != SECSuccess ) {
  737. /* We're in big trouble here */
  738. PR_fprintf(PR_STDERR, errStrings[DEFAULT_FAILED_ERR],
  739.   moduleName);
  740. errcode = DEFAULT_FAILED_ERR;
  741. goto loser;
  742. }
  744. PR_fprintf(PR_STDOUT, msgStrings[DEFAULT_SUCCESS_MSG]);
  746. errcode = SUCCESS;
  747. loser:
  748. return errcode;
  749. }
  751. /************************************************************************
  752.  *
  753.  * U n s e t D e f a u l t M o d u l e
  754.  */
  755. Error
  756. UnsetDefaultModule(char *moduleName, char *slotName, char *mechanisms)
  757. {
  758. SECMODModule * module;
  759. PK11SlotInfo *slot;
  760. int s, i;
  761. unsigned long mechFlags = getFlagsFromString(mechanisms,
  762. mechanismStrings, numMechanismStrings);
  763. PRBool found = PR_FALSE;
  765. mechFlags =  SECMOD_PubMechFlagstoInternal(mechFlags);
  767. module = SECMOD_FindModule(moduleName);
  768. if(!module) {
  769. PR_fprintf(PR_STDERR, errStrings[NO_SUCH_MODULE_ERR], moduleName);
  770. return NO_SUCH_MODULE_ERR;
  771. }
  773. for(s=0; s < module->slotCount; s++) {
  774. slot = module->slots[s];
  775. if ((slotName != NULL) &&
  776. !((strcmp(PK11_GetSlotName(slot),slotName) == 0) ||
  777. (strcmp(PK11_GetTokenName(slot),slotName) == 0)) ) {
  778.     /* we are only interested in changing the one slot */
  779.     continue;
  780. }
  781. for(i=0; i <num_pk11_default_mechanisms; i++) {
  782. if(PK11_DefaultArray[i].flag & mechFlags) {
  783. PK11_UpdateSlotAttribute(slot, &(PK11_DefaultArray[i]),
  784. PR_FALSE);
  785. }
  786. }
  787. }
  788. if (slotName && !found) {
  789. PR_fprintf(PR_STDERR, errStrings[NO_SUCH_SLOT_ERR], slotName);
  790. return NO_SUCH_SLOT_ERR;
  791. }
  793. /* Delete and re-add module to save changes */
  794. if( SECMOD_DeletePermDB(module) != SECSuccess ) {
  795. PR_fprintf(PR_STDERR, errStrings[UNDEFAULT_FAILED_ERR],
  796.   moduleName);
  797. return UNDEFAULT_FAILED_ERR;
  798. }
  799. if( SECMOD_AddPermDB(module) != SECSuccess ) {
  800. /* We're in big trouble here */
  801. PR_fprintf(PR_STDERR, errStrings[UNDEFAULT_FAILED_ERR],
  802.   moduleName);
  803. return UNDEFAULT_FAILED_ERR;
  804. }
  806. PR_fprintf(PR_STDOUT, msgStrings[UNDEFAULT_SUCCESS_MSG]);
  807. return SUCCESS;
  808. }