xref: /titanic_44/usr/src/cmd/cmd-crypto/pktool/delete.c (revision 448b8615fe9e8af757530284920a235430ead7e8)
17711facfSdinak /*
27711facfSdinak  * CDDL HEADER START
37711facfSdinak  *
47711facfSdinak  * The contents of this file are subject to the terms of the
599ebb4caSwyllys  * Common Development and Distribution License (the "License").
699ebb4caSwyllys  * You may not use this file except in compliance with the License.
77711facfSdinak  *
87711facfSdinak  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97711facfSdinak  * or http://www.opensolaris.org/os/licensing.
107711facfSdinak  * See the License for the specific language governing permissions
117711facfSdinak  * and limitations under the License.
127711facfSdinak  *
137711facfSdinak  * When distributing Covered Code, include this CDDL HEADER in each
147711facfSdinak  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157711facfSdinak  * If applicable, add the following below this CDDL HEADER, with the
167711facfSdinak  * fields enclosed by brackets "[]" replaced with your own identifying
177711facfSdinak  * information: Portions Copyright [yyyy] [name of copyright owner]
187711facfSdinak  *
197711facfSdinak  * CDDL HEADER END
207711facfSdinak  */
217711facfSdinak /*
22*448b8615Swyllys  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
237711facfSdinak  * Use is subject to license terms.
247711facfSdinak  */
257711facfSdinak 
267711facfSdinak #pragma ident	"%Z%%M%	%I%	%E% SMI"
277711facfSdinak 
287711facfSdinak /*
297711facfSdinak  * This file implements the token object delete operation for this tool.
307711facfSdinak  * It loads the PKCS#11 modules, finds the object to delete, deletes it,
317711facfSdinak  * and cleans up.  User must be R/W logged into the token.
327711facfSdinak  */
337711facfSdinak 
347711facfSdinak #include <stdio.h>
357711facfSdinak #include <string.h>
367711facfSdinak #include <cryptoutil.h>
377711facfSdinak #include <security/cryptoki.h>
387711facfSdinak #include "common.h"
3999ebb4caSwyllys #include <kmfapi.h>
4099ebb4caSwyllys 
4199ebb4caSwyllys static KMF_RETURN
4230a5e8faSwyllys pk_destroy_keys(void *handle, KMF_ATTRIBUTE *attrlist, int numattr)
4399ebb4caSwyllys {
4499ebb4caSwyllys 	int i;
4599ebb4caSwyllys 	KMF_RETURN rv = KMF_OK;
4630a5e8faSwyllys 	uint32_t *numkeys;
4730a5e8faSwyllys 	KMF_KEY_HANDLE *keys = NULL;
4830a5e8faSwyllys 	int del_num = 0;
4930a5e8faSwyllys 	KMF_ATTRIBUTE delete_attlist[16];
5030a5e8faSwyllys 	KMF_KEYSTORE_TYPE kstype;
5130a5e8faSwyllys 	uint32_t len;
5230a5e8faSwyllys 	boolean_t destroy = B_TRUE;
5330a5e8faSwyllys 	KMF_CREDENTIAL cred;
5430a5e8faSwyllys 	char *slotlabel = NULL;
5599ebb4caSwyllys 
5630a5e8faSwyllys 	len = sizeof (kstype);
5730a5e8faSwyllys 	rv = kmf_get_attr(KMF_KEYSTORE_TYPE_ATTR, attrlist, numattr,
5830a5e8faSwyllys 	    &kstype, &len);
5930a5e8faSwyllys 	if (rv != KMF_OK)
6030a5e8faSwyllys 		return (rv);
6199ebb4caSwyllys 
6230a5e8faSwyllys 	kmf_set_attr_at_index(delete_attlist, del_num,
6330a5e8faSwyllys 	    KMF_KEYSTORE_TYPE_ATTR, &kstype, sizeof (kstype));
6430a5e8faSwyllys 	del_num++;
6530a5e8faSwyllys 
6630a5e8faSwyllys 	/* "destroy" is optional. Default is TRUE */
6730a5e8faSwyllys 	(void) kmf_get_attr(KMF_DESTROY_BOOL_ATTR, attrlist, numattr,
6830a5e8faSwyllys 	    (void *)&destroy, NULL);
6930a5e8faSwyllys 
7030a5e8faSwyllys 	kmf_set_attr_at_index(delete_attlist, del_num,
7130a5e8faSwyllys 	    KMF_DESTROY_BOOL_ATTR, &destroy, sizeof (boolean_t));
7230a5e8faSwyllys 	del_num++;
7330a5e8faSwyllys 
7430a5e8faSwyllys 	switch (kstype) {
7599ebb4caSwyllys 	case KMF_KEYSTORE_NSS:
7630a5e8faSwyllys 		rv = kmf_get_attr(KMF_CREDENTIAL_ATTR, attrlist, numattr,
7730a5e8faSwyllys 		    (void *)&cred, NULL);
7830a5e8faSwyllys 		if (rv == KMF_OK) {
7930a5e8faSwyllys 			if (cred.credlen > 0) {
8030a5e8faSwyllys 				kmf_set_attr_at_index(delete_attlist, del_num,
8130a5e8faSwyllys 				    KMF_CREDENTIAL_ATTR, &cred,
8230a5e8faSwyllys 				    sizeof (KMF_CREDENTIAL));
8330a5e8faSwyllys 				del_num++;
8430a5e8faSwyllys 			}
8530a5e8faSwyllys 		}
8630a5e8faSwyllys 
8730a5e8faSwyllys 		slotlabel = kmf_get_attr_ptr(KMF_TOKEN_LABEL_ATTR, attrlist,
8830a5e8faSwyllys 		    numattr);
8930a5e8faSwyllys 		if (slotlabel != NULL) {
9030a5e8faSwyllys 			kmf_set_attr_at_index(delete_attlist, del_num,
9130a5e8faSwyllys 			    KMF_TOKEN_LABEL_ATTR, slotlabel,
9230a5e8faSwyllys 			    strlen(slotlabel));
9330a5e8faSwyllys 			del_num++;
9430a5e8faSwyllys 		}
9599ebb4caSwyllys 		break;
9699ebb4caSwyllys 	case KMF_KEYSTORE_OPENSSL:
9799ebb4caSwyllys 		break;
9899ebb4caSwyllys 	case KMF_KEYSTORE_PK11TOKEN:
9930a5e8faSwyllys 		rv = kmf_get_attr(KMF_CREDENTIAL_ATTR, attrlist, numattr,
10030a5e8faSwyllys 		    (void *)&cred, NULL);
10130a5e8faSwyllys 		if (rv == KMF_OK) {
10230a5e8faSwyllys 			if (cred.credlen > 0) {
10330a5e8faSwyllys 				kmf_set_attr_at_index(delete_attlist, del_num,
10430a5e8faSwyllys 				    KMF_CREDENTIAL_ATTR, &cred,
10530a5e8faSwyllys 				    sizeof (KMF_CREDENTIAL));
10630a5e8faSwyllys 				del_num++;
10730a5e8faSwyllys 			}
10830a5e8faSwyllys 		}
10999ebb4caSwyllys 		break;
11099ebb4caSwyllys 	default:
11199ebb4caSwyllys 		return (PK_ERR_USAGE);
11299ebb4caSwyllys 	}
11399ebb4caSwyllys 
11430a5e8faSwyllys 	numkeys = kmf_get_attr_ptr(KMF_COUNT_ATTR, attrlist, numattr);
11530a5e8faSwyllys 	if (numkeys == NULL)
11630a5e8faSwyllys 		return (PK_ERR_USAGE);
11730a5e8faSwyllys 
11830a5e8faSwyllys 	keys = kmf_get_attr_ptr(KMF_KEY_HANDLE_ATTR, attrlist, numattr);
11930a5e8faSwyllys 	if (keys == NULL)
12030a5e8faSwyllys 		return (PK_ERR_USAGE);
12130a5e8faSwyllys 
12230a5e8faSwyllys 	for (i = 0; rv == KMF_OK && i < *numkeys; i++) {
12330a5e8faSwyllys 		int num = del_num;
12430a5e8faSwyllys 
12530a5e8faSwyllys 		kmf_set_attr_at_index(delete_attlist, num,
12630a5e8faSwyllys 		    KMF_KEY_HANDLE_ATTR, &keys[i], sizeof (KMF_KEY_HANDLE));
12730a5e8faSwyllys 		num++;
12830a5e8faSwyllys 
12930a5e8faSwyllys 		rv = kmf_delete_key_from_keystore(handle, num, delete_attlist);
13099ebb4caSwyllys 	}
13199ebb4caSwyllys 	return (rv);
13299ebb4caSwyllys }
13399ebb4caSwyllys 
13499ebb4caSwyllys static KMF_RETURN
13530a5e8faSwyllys pk_delete_keys(KMF_HANDLE_T kmfhandle, KMF_ATTRIBUTE *attlist, int numattr,
13630a5e8faSwyllys 	char *desc, int *keysdeleted)
13799ebb4caSwyllys {
13899ebb4caSwyllys 	KMF_RETURN rv = KMF_OK;
13999ebb4caSwyllys 	uint32_t numkeys = 0;
14030a5e8faSwyllys 	int num = numattr;
14199ebb4caSwyllys 
14299ebb4caSwyllys 	*keysdeleted = 0;
14399ebb4caSwyllys 	numkeys = 0;
14430a5e8faSwyllys 
14530a5e8faSwyllys 	kmf_set_attr_at_index(attlist, num,
14630a5e8faSwyllys 	    KMF_COUNT_ATTR, &numkeys, sizeof (uint32_t));
14730a5e8faSwyllys 	num++;
14830a5e8faSwyllys 
14930a5e8faSwyllys 	rv = kmf_find_key(kmfhandle, num, attlist);
15030a5e8faSwyllys 
15199ebb4caSwyllys 	if (rv == KMF_OK && numkeys > 0) {
15299ebb4caSwyllys 		KMF_KEY_HANDLE *keys = NULL;
15399ebb4caSwyllys 		char prompt[1024];
15499ebb4caSwyllys 
15599ebb4caSwyllys 		(void) snprintf(prompt, sizeof (prompt),
15699ebb4caSwyllys 		    gettext("%d %s key(s) found, do you want "
15799ebb4caSwyllys 		    "to delete them (y/N) ?"), numkeys,
15899ebb4caSwyllys 		    (desc != NULL ? desc : ""));
15999ebb4caSwyllys 
16099ebb4caSwyllys 		if (!yesno(prompt,
16199ebb4caSwyllys 		    gettext("Respond with yes or no.\n"),
16299ebb4caSwyllys 		    B_FALSE)) {
1632cbed729Swyllys 			*keysdeleted = numkeys;
16499ebb4caSwyllys 			return (KMF_OK);
16599ebb4caSwyllys 		}
16699ebb4caSwyllys 		keys = (KMF_KEY_HANDLE *)malloc(numkeys *
16799ebb4caSwyllys 		    sizeof (KMF_KEY_HANDLE));
16899ebb4caSwyllys 		if (keys == NULL)
16999ebb4caSwyllys 			return (KMF_ERR_MEMORY);
17099ebb4caSwyllys 		(void) memset(keys, 0, numkeys *
17199ebb4caSwyllys 		    sizeof (KMF_KEY_HANDLE));
17299ebb4caSwyllys 
17330a5e8faSwyllys 		kmf_set_attr_at_index(attlist, num,
17430a5e8faSwyllys 		    KMF_KEY_HANDLE_ATTR, keys, sizeof (KMF_KEY_HANDLE));
17530a5e8faSwyllys 		num++;
17630a5e8faSwyllys 
17730a5e8faSwyllys 		rv = kmf_find_key(kmfhandle, num, attlist);
17899ebb4caSwyllys 		if (rv == KMF_OK) {
17930a5e8faSwyllys 			rv = pk_destroy_keys(kmfhandle, attlist, num);
18099ebb4caSwyllys 		}
18199ebb4caSwyllys 
18299ebb4caSwyllys 		free(keys);
18399ebb4caSwyllys 	}
18499ebb4caSwyllys 
18599ebb4caSwyllys 	if (rv == KMF_ERR_KEY_NOT_FOUND) {
18699ebb4caSwyllys 		rv = KMF_OK;
18799ebb4caSwyllys 	}
18899ebb4caSwyllys 
18999ebb4caSwyllys 	*keysdeleted = numkeys;
19099ebb4caSwyllys 	return (rv);
19199ebb4caSwyllys }
19299ebb4caSwyllys 
19399ebb4caSwyllys static KMF_RETURN
19430a5e8faSwyllys pk_delete_certs(KMF_HANDLE_T kmfhandle, KMF_ATTRIBUTE *attlist, int numattr)
19599ebb4caSwyllys {
19699ebb4caSwyllys 	KMF_RETURN rv = KMF_OK;
19799ebb4caSwyllys 	uint32_t numcerts = 0;
19830a5e8faSwyllys 	int num = numattr;
19999ebb4caSwyllys 
20030a5e8faSwyllys 	kmf_set_attr_at_index(attlist, num,
20130a5e8faSwyllys 	    KMF_COUNT_ATTR, &numcerts, sizeof (uint32_t));
20230a5e8faSwyllys 	num++;
20330a5e8faSwyllys 
20430a5e8faSwyllys 	rv = kmf_find_cert(kmfhandle, num, attlist);
20599ebb4caSwyllys 	if (rv == KMF_OK && numcerts > 0) {
20699ebb4caSwyllys 		char prompt[1024];
20799ebb4caSwyllys 		(void) snprintf(prompt, sizeof (prompt),
20899ebb4caSwyllys 		    gettext("%d certificate(s) found, do you want "
20999ebb4caSwyllys 		    "to delete them (y/N) ?"), numcerts);
21099ebb4caSwyllys 
21199ebb4caSwyllys 		if (!yesno(prompt,
21299ebb4caSwyllys 		    gettext("Respond with yes or no.\n"),
21399ebb4caSwyllys 		    B_FALSE)) {
21499ebb4caSwyllys 			return (KMF_OK);
21599ebb4caSwyllys 		}
21699ebb4caSwyllys 
21730a5e8faSwyllys 		/*
21830a5e8faSwyllys 		 * Use numattr because delete cert does not require
21930a5e8faSwyllys 		 * KMF_COUNT_ATTR attribute.
22030a5e8faSwyllys 		 */
22130a5e8faSwyllys 		rv = kmf_delete_cert_from_keystore(kmfhandle, numattr, attlist);
22299ebb4caSwyllys 
22399ebb4caSwyllys 	} else if (rv == KMF_ERR_CERT_NOT_FOUND) {
22499ebb4caSwyllys 		rv = KMF_OK;
22599ebb4caSwyllys 	}
22699ebb4caSwyllys 
22799ebb4caSwyllys 	return (rv);
22899ebb4caSwyllys }
22999ebb4caSwyllys 
23099ebb4caSwyllys static KMF_RETURN
23199ebb4caSwyllys delete_nss_keys(KMF_HANDLE_T kmfhandle, char *dir, char *prefix,
23299ebb4caSwyllys 	char *token, int oclass, char *objlabel,
23399ebb4caSwyllys 	KMF_CREDENTIAL *tokencred)
23499ebb4caSwyllys {
23599ebb4caSwyllys 	KMF_RETURN rv = KMF_OK;
23699ebb4caSwyllys 	char *keytype = NULL;
23799ebb4caSwyllys 	int nk, numkeys = 0;
23830a5e8faSwyllys 	KMF_KEYSTORE_TYPE kstype = KMF_KEYSTORE_NSS;
23930a5e8faSwyllys 	int numattr = 0;
24030a5e8faSwyllys 	KMF_ATTRIBUTE attrlist[16];
24130a5e8faSwyllys 	KMF_KEY_CLASS keyclass;
24299ebb4caSwyllys 
24399ebb4caSwyllys 	rv = configure_nss(kmfhandle, dir, prefix);
24499ebb4caSwyllys 	if (rv != KMF_OK)
24599ebb4caSwyllys 		return (rv);
24699ebb4caSwyllys 
24730a5e8faSwyllys 	kmf_set_attr_at_index(attrlist, numattr, KMF_KEYSTORE_TYPE_ATTR,
24830a5e8faSwyllys 	    &kstype, sizeof (kstype));
24930a5e8faSwyllys 	numattr++;
25030a5e8faSwyllys 
25130a5e8faSwyllys 	if (objlabel != NULL) {
25230a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_KEYLABEL_ATTR,
25330a5e8faSwyllys 		    objlabel, strlen(objlabel));
25430a5e8faSwyllys 		numattr++;
25530a5e8faSwyllys 	}
25630a5e8faSwyllys 
25730a5e8faSwyllys 	if (tokencred->credlen > 0) {
25830a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_CREDENTIAL_ATTR,
25930a5e8faSwyllys 		    tokencred, sizeof (KMF_CREDENTIAL));
26030a5e8faSwyllys 		numattr++;
26130a5e8faSwyllys 	}
26230a5e8faSwyllys 
26330a5e8faSwyllys 	if (token && strlen(token)) {
26430a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_TOKEN_LABEL_ATTR,
26530a5e8faSwyllys 		    token, strlen(token));
26630a5e8faSwyllys 		numattr++;
26730a5e8faSwyllys 	}
26899ebb4caSwyllys 
26999ebb4caSwyllys 	if (oclass & PK_PRIKEY_OBJ) {
27030a5e8faSwyllys 		int num = numattr;
27130a5e8faSwyllys 
27230a5e8faSwyllys 		keyclass = KMF_ASYM_PRI;
27330a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, num, KMF_KEYCLASS_ATTR,
27430a5e8faSwyllys 		    &keyclass, sizeof (keyclass));
27530a5e8faSwyllys 		num++;
27630a5e8faSwyllys 
27799ebb4caSwyllys 		keytype = "private";
27830a5e8faSwyllys 		rv = pk_delete_keys(kmfhandle, attrlist, num, keytype, &nk);
27999ebb4caSwyllys 		numkeys += nk;
28099ebb4caSwyllys 	}
28199ebb4caSwyllys 	if (rv == KMF_OK && (oclass & PK_SYMKEY_OBJ)) {
28230a5e8faSwyllys 		int num = numattr;
28330a5e8faSwyllys 
28430a5e8faSwyllys 		keyclass = KMF_SYMMETRIC;
28530a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, num, KMF_KEYCLASS_ATTR,
28630a5e8faSwyllys 		    &keyclass, sizeof (keyclass));
28730a5e8faSwyllys 		num++;
28830a5e8faSwyllys 
28999ebb4caSwyllys 		keytype = "symmetric";
29030a5e8faSwyllys 		rv = pk_delete_keys(kmfhandle, attrlist, num, keytype, &nk);
29199ebb4caSwyllys 		numkeys += nk;
29299ebb4caSwyllys 	}
29399ebb4caSwyllys 	if (rv == KMF_OK && (oclass & PK_PUBKEY_OBJ)) {
29430a5e8faSwyllys 		int num = numattr;
29530a5e8faSwyllys 
29630a5e8faSwyllys 		keyclass = KMF_ASYM_PUB;
29730a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, num, KMF_KEYCLASS_ATTR,
29830a5e8faSwyllys 		    &keyclass, sizeof (keyclass));
29930a5e8faSwyllys 		num++;
30030a5e8faSwyllys 
30199ebb4caSwyllys 		keytype = "public";
30230a5e8faSwyllys 		rv = pk_delete_keys(kmfhandle, attrlist, num, keytype, &nk);
30399ebb4caSwyllys 		numkeys += nk;
30499ebb4caSwyllys 	}
30599ebb4caSwyllys 	if (rv == KMF_OK && numkeys == 0)
30699ebb4caSwyllys 		rv = KMF_ERR_KEY_NOT_FOUND;
30799ebb4caSwyllys 
30899ebb4caSwyllys 	return (rv);
30999ebb4caSwyllys }
31099ebb4caSwyllys 
31199ebb4caSwyllys 
31299ebb4caSwyllys static KMF_RETURN
31399ebb4caSwyllys delete_nss_certs(KMF_HANDLE_T kmfhandle,
31499ebb4caSwyllys 	char *dir, char *prefix,
31599ebb4caSwyllys 	char *token, char *objlabel,
31699ebb4caSwyllys 	KMF_BIGINT *serno, char *issuer, char *subject,
31799ebb4caSwyllys 	KMF_CERT_VALIDITY find_criteria_flag)
31899ebb4caSwyllys {
31999ebb4caSwyllys 	KMF_RETURN rv = KMF_OK;
32030a5e8faSwyllys 	KMF_KEYSTORE_TYPE kstype = KMF_KEYSTORE_NSS;
32130a5e8faSwyllys 	int numattr = 0;
32230a5e8faSwyllys 	KMF_ATTRIBUTE attrlist[16];
32399ebb4caSwyllys 
32499ebb4caSwyllys 	rv = configure_nss(kmfhandle, dir, prefix);
32599ebb4caSwyllys 	if (rv != KMF_OK)
32699ebb4caSwyllys 		return (rv);
32799ebb4caSwyllys 
32830a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_KEYSTORE_TYPE_ATTR,
32930a5e8faSwyllys 		    &kstype, sizeof (kstype));
33030a5e8faSwyllys 		numattr++;
33199ebb4caSwyllys 
33230a5e8faSwyllys 		if (objlabel != NULL) {
33330a5e8faSwyllys 			kmf_set_attr_at_index(attrlist, numattr,
33430a5e8faSwyllys 			    KMF_CERT_LABEL_ATTR, objlabel,
33530a5e8faSwyllys 			    strlen(objlabel));
33630a5e8faSwyllys 			numattr++;
33730a5e8faSwyllys 		}
33899ebb4caSwyllys 
33930a5e8faSwyllys 		if (issuer != NULL) {
34030a5e8faSwyllys 			kmf_set_attr_at_index(attrlist, numattr,
34130a5e8faSwyllys 			    KMF_ISSUER_NAME_ATTR, issuer,
34230a5e8faSwyllys 			    strlen(issuer));
34330a5e8faSwyllys 			numattr++;
34430a5e8faSwyllys 		}
34530a5e8faSwyllys 
34630a5e8faSwyllys 		if (subject != NULL) {
34730a5e8faSwyllys 			kmf_set_attr_at_index(attrlist, numattr,
34830a5e8faSwyllys 			    KMF_SUBJECT_NAME_ATTR, subject,
34930a5e8faSwyllys 			    strlen(subject));
35030a5e8faSwyllys 			numattr++;
35130a5e8faSwyllys 		}
35230a5e8faSwyllys 
35330a5e8faSwyllys 		if (serno != NULL) {
35430a5e8faSwyllys 			kmf_set_attr_at_index(attrlist, numattr,
35530a5e8faSwyllys 			    KMF_BIGINT_ATTR, serno,
35630a5e8faSwyllys 			    sizeof (KMF_BIGINT));
35730a5e8faSwyllys 			numattr++;
35830a5e8faSwyllys 		}
35930a5e8faSwyllys 
36030a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr,
36130a5e8faSwyllys 		    KMF_CERT_VALIDITY_ATTR, &find_criteria_flag,
36230a5e8faSwyllys 		    sizeof (KMF_CERT_VALIDITY));
36330a5e8faSwyllys 		numattr++;
36430a5e8faSwyllys 
36530a5e8faSwyllys 		if (token != NULL) {
36630a5e8faSwyllys 			kmf_set_attr_at_index(attrlist, numattr,
36730a5e8faSwyllys 			    KMF_TOKEN_LABEL_ATTR, token,
36830a5e8faSwyllys 			    strlen(token));
36930a5e8faSwyllys 			numattr++;
37030a5e8faSwyllys 		}
37130a5e8faSwyllys 
37230a5e8faSwyllys 	rv = pk_delete_certs(kmfhandle, attrlist, numattr);
37399ebb4caSwyllys 
37499ebb4caSwyllys 	return (rv);
37599ebb4caSwyllys }
37699ebb4caSwyllys 
37799ebb4caSwyllys static KMF_RETURN
37899ebb4caSwyllys delete_nss_crl(void *kmfhandle,
37999ebb4caSwyllys 	char *dir, char *prefix, char *token,
38030a5e8faSwyllys 	char *issuer, char *subject)
38199ebb4caSwyllys {
38299ebb4caSwyllys 	KMF_RETURN rv = KMF_OK;
38330a5e8faSwyllys 	int numattr = 0;
38430a5e8faSwyllys 	KMF_ATTRIBUTE attrlist[8];
38530a5e8faSwyllys 	KMF_KEYSTORE_TYPE kstype = KMF_KEYSTORE_NSS;
38699ebb4caSwyllys 
38799ebb4caSwyllys 	rv = configure_nss(kmfhandle, dir, prefix);
38899ebb4caSwyllys 	if (rv != KMF_OK)
38999ebb4caSwyllys 		return (rv);
39099ebb4caSwyllys 
39130a5e8faSwyllys 	kmf_set_attr_at_index(attrlist, numattr, KMF_KEYSTORE_TYPE_ATTR,
39230a5e8faSwyllys 	    &kstype, sizeof (kstype));
39330a5e8faSwyllys 	numattr++;
39499ebb4caSwyllys 
39530a5e8faSwyllys 	if (token != NULL) {
39630a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_TOKEN_LABEL_ATTR,
39730a5e8faSwyllys 		    token, strlen(token));
39830a5e8faSwyllys 		numattr++;
39930a5e8faSwyllys 	}
40030a5e8faSwyllys 	if (issuer != NULL) {
40130a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_ISSUER_NAME_ATTR,
40230a5e8faSwyllys 		    issuer, strlen(issuer));
40330a5e8faSwyllys 		numattr++;
40430a5e8faSwyllys 	}
40530a5e8faSwyllys 	if (subject != NULL) {
40630a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_SUBJECT_NAME_ATTR,
40730a5e8faSwyllys 		    subject, strlen(subject));
40830a5e8faSwyllys 		numattr++;
40930a5e8faSwyllys 	}
41099ebb4caSwyllys 
41130a5e8faSwyllys 	rv = kmf_delete_crl(kmfhandle, numattr, attrlist);
41299ebb4caSwyllys 
41399ebb4caSwyllys 	return (rv);
41499ebb4caSwyllys }
41599ebb4caSwyllys 
41699ebb4caSwyllys static KMF_RETURN
41799ebb4caSwyllys delete_pk11_keys(KMF_HANDLE_T kmfhandle,
41899ebb4caSwyllys 	char *token, int oclass, char *objlabel,
41999ebb4caSwyllys 	KMF_CREDENTIAL *tokencred)
42099ebb4caSwyllys {
42199ebb4caSwyllys 	KMF_RETURN rv = KMF_OK;
42299ebb4caSwyllys 	int nk, numkeys = 0;
42330a5e8faSwyllys 	KMF_KEYSTORE_TYPE kstype = KMF_KEYSTORE_PK11TOKEN;
42430a5e8faSwyllys 	int numattr = 0;
42530a5e8faSwyllys 	KMF_ATTRIBUTE attrlist[16];
42630a5e8faSwyllys 	KMF_KEY_CLASS keyclass;
42730a5e8faSwyllys 	boolean_t token_bool = B_TRUE;
42830a5e8faSwyllys 	boolean_t private;
42999ebb4caSwyllys 	/*
43099ebb4caSwyllys 	 * Symmetric keys and RSA/DSA private keys are always
43199ebb4caSwyllys 	 * created with the "CKA_PRIVATE" field == TRUE, so
43299ebb4caSwyllys 	 * make sure we search for them with it also set.
43399ebb4caSwyllys 	 */
43499ebb4caSwyllys 	if (oclass & (PK_SYMKEY_OBJ | PK_PRIKEY_OBJ))
43599ebb4caSwyllys 		oclass |= PK_PRIVATE_OBJ;
43699ebb4caSwyllys 
43799ebb4caSwyllys 	rv = select_token(kmfhandle, token, FALSE);
43899ebb4caSwyllys 	if (rv != KMF_OK) {
43999ebb4caSwyllys 		return (rv);
44099ebb4caSwyllys 	}
44199ebb4caSwyllys 
44230a5e8faSwyllys 	kmf_set_attr_at_index(attrlist, numattr, KMF_KEYSTORE_TYPE_ATTR,
44330a5e8faSwyllys 	    &kstype, sizeof (kstype));
44430a5e8faSwyllys 	numattr++;
44530a5e8faSwyllys 
44630a5e8faSwyllys 	if (objlabel != NULL) {
44730a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_KEYLABEL_ATTR,
44830a5e8faSwyllys 		    objlabel, strlen(objlabel));
44930a5e8faSwyllys 		numattr++;
45030a5e8faSwyllys 	}
45130a5e8faSwyllys 
45230a5e8faSwyllys 	if (tokencred != NULL && tokencred->credlen > 0) {
45330a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_CREDENTIAL_ATTR,
45430a5e8faSwyllys 		    tokencred, sizeof (KMF_CREDENTIAL));
45530a5e8faSwyllys 		numattr++;
45630a5e8faSwyllys 	}
45730a5e8faSwyllys 
45830a5e8faSwyllys 	private = ((oclass & PK_PRIVATE_OBJ) > 0);
45930a5e8faSwyllys 
46030a5e8faSwyllys 	kmf_set_attr_at_index(attrlist, numattr, KMF_PRIVATE_BOOL_ATTR,
46130a5e8faSwyllys 	    &private, sizeof (private));
46230a5e8faSwyllys 	numattr++;
46330a5e8faSwyllys 
46430a5e8faSwyllys 	kmf_set_attr_at_index(attrlist, numattr, KMF_TOKEN_BOOL_ATTR,
46530a5e8faSwyllys 	    &token_bool, sizeof (token_bool));
46630a5e8faSwyllys 	numattr++;
46799ebb4caSwyllys 
46899ebb4caSwyllys 	if (oclass & PK_PRIKEY_OBJ) {
46930a5e8faSwyllys 		int num = numattr;
47030a5e8faSwyllys 
47130a5e8faSwyllys 		keyclass = KMF_ASYM_PRI;
47230a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, num, KMF_KEYCLASS_ATTR,
47330a5e8faSwyllys 		    &keyclass, sizeof (keyclass));
47430a5e8faSwyllys 		num++;
47530a5e8faSwyllys 
47630a5e8faSwyllys 		rv = pk_delete_keys(kmfhandle, attrlist, num, "private", &nk);
47799ebb4caSwyllys 		numkeys += nk;
47899ebb4caSwyllys 	}
47999ebb4caSwyllys 
48099ebb4caSwyllys 	if (rv == KMF_OK && (oclass & PK_SYMKEY_OBJ)) {
48130a5e8faSwyllys 		int num = numattr;
48230a5e8faSwyllys 
48330a5e8faSwyllys 		keyclass = KMF_SYMMETRIC;
48430a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, num, KMF_KEYCLASS_ATTR,
48530a5e8faSwyllys 		    &keyclass, sizeof (keyclass));
48630a5e8faSwyllys 		num++;
48730a5e8faSwyllys 
48830a5e8faSwyllys 		rv = pk_delete_keys(kmfhandle, attrlist, num, "symmetric", &nk);
48999ebb4caSwyllys 		numkeys += nk;
49099ebb4caSwyllys 	}
49199ebb4caSwyllys 
49299ebb4caSwyllys 	if (rv == KMF_OK && (oclass & PK_PUBKEY_OBJ)) {
49330a5e8faSwyllys 		int num = numattr;
49430a5e8faSwyllys 
4952cbed729Swyllys 		private = B_FALSE;
49630a5e8faSwyllys 		keyclass = KMF_ASYM_PUB;
49730a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, num, KMF_KEYCLASS_ATTR,
49830a5e8faSwyllys 		    &keyclass, sizeof (keyclass));
49930a5e8faSwyllys 		num++;
50030a5e8faSwyllys 
50130a5e8faSwyllys 		rv = pk_delete_keys(kmfhandle, attrlist, num, "public", &nk);
50299ebb4caSwyllys 		numkeys += nk;
50399ebb4caSwyllys 	}
50499ebb4caSwyllys 	if (rv == KMF_OK && numkeys == 0)
50599ebb4caSwyllys 		rv = KMF_ERR_KEY_NOT_FOUND;
50699ebb4caSwyllys 
50799ebb4caSwyllys 	return (rv);
50899ebb4caSwyllys }
50999ebb4caSwyllys 
51099ebb4caSwyllys static KMF_RETURN
51199ebb4caSwyllys delete_pk11_certs(KMF_HANDLE_T kmfhandle,
51299ebb4caSwyllys 	char *token, char *objlabel,
51399ebb4caSwyllys 	KMF_BIGINT *serno, char *issuer, char *subject,
51499ebb4caSwyllys 	KMF_CERT_VALIDITY find_criteria_flag)
51599ebb4caSwyllys {
51699ebb4caSwyllys 	KMF_RETURN kmfrv;
51730a5e8faSwyllys 	KMF_KEYSTORE_TYPE kstype = KMF_KEYSTORE_PK11TOKEN;
51830a5e8faSwyllys 	int numattr = 0;
51930a5e8faSwyllys 	KMF_ATTRIBUTE attrlist[16];
52099ebb4caSwyllys 
52199ebb4caSwyllys 	kmfrv = select_token(kmfhandle, token, FALSE);
52299ebb4caSwyllys 
52399ebb4caSwyllys 	if (kmfrv != KMF_OK) {
52499ebb4caSwyllys 		return (kmfrv);
52599ebb4caSwyllys 	}
52699ebb4caSwyllys 
52730a5e8faSwyllys 	kmf_set_attr_at_index(attrlist, numattr, KMF_KEYSTORE_TYPE_ATTR,
52830a5e8faSwyllys 	    &kstype, sizeof (kstype));
52930a5e8faSwyllys 	numattr++;
53099ebb4caSwyllys 
53130a5e8faSwyllys 	if (objlabel != NULL) {
53230a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_CERT_LABEL_ATTR,
53330a5e8faSwyllys 		    objlabel, strlen(objlabel));
53430a5e8faSwyllys 		numattr++;
53530a5e8faSwyllys 	}
53630a5e8faSwyllys 
53730a5e8faSwyllys 	if (issuer != NULL) {
53830a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_ISSUER_NAME_ATTR,
53930a5e8faSwyllys 		    issuer, strlen(issuer));
54030a5e8faSwyllys 		numattr++;
54130a5e8faSwyllys 	}
54230a5e8faSwyllys 
54330a5e8faSwyllys 	if (subject != NULL) {
54430a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_SUBJECT_NAME_ATTR,
54530a5e8faSwyllys 		    subject, strlen(subject));
54630a5e8faSwyllys 		numattr++;
54730a5e8faSwyllys 	}
54830a5e8faSwyllys 
54930a5e8faSwyllys 	if (serno != NULL) {
55030a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_BIGINT_ATTR,
55130a5e8faSwyllys 		    serno, sizeof (KMF_BIGINT));
55230a5e8faSwyllys 		numattr++;
55330a5e8faSwyllys 	}
55430a5e8faSwyllys 
55530a5e8faSwyllys 	kmf_set_attr_at_index(attrlist, numattr, KMF_CERT_VALIDITY_ATTR,
55630a5e8faSwyllys 	    &find_criteria_flag, sizeof (KMF_CERT_VALIDITY));
55730a5e8faSwyllys 	numattr++;
55830a5e8faSwyllys 
55930a5e8faSwyllys 	kmfrv = pk_delete_certs(kmfhandle, attrlist, numattr);
56099ebb4caSwyllys 
56199ebb4caSwyllys 	return (kmfrv);
56299ebb4caSwyllys }
56399ebb4caSwyllys 
56499ebb4caSwyllys static KMF_RETURN
56599ebb4caSwyllys delete_file_certs(KMF_HANDLE_T kmfhandle,
56699ebb4caSwyllys 	char *dir, char *filename, KMF_BIGINT *serial, char *issuer,
56799ebb4caSwyllys 	char *subject, KMF_CERT_VALIDITY find_criteria_flag)
56899ebb4caSwyllys {
56999ebb4caSwyllys 	KMF_RETURN rv;
57030a5e8faSwyllys 	KMF_KEYSTORE_TYPE kstype = KMF_KEYSTORE_OPENSSL;
57130a5e8faSwyllys 	int numattr = 0;
57230a5e8faSwyllys 	KMF_ATTRIBUTE attrlist[16];
57399ebb4caSwyllys 
57430a5e8faSwyllys 	kmf_set_attr_at_index(attrlist, numattr, KMF_KEYSTORE_TYPE_ATTR,
57530a5e8faSwyllys 	    &kstype, sizeof (kstype));
57630a5e8faSwyllys 	numattr++;
57799ebb4caSwyllys 
57830a5e8faSwyllys 	if (issuer != NULL) {
57930a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_ISSUER_NAME_ATTR,
58030a5e8faSwyllys 		    issuer, strlen(issuer));
58130a5e8faSwyllys 		numattr++;
58230a5e8faSwyllys 	}
58399ebb4caSwyllys 
58430a5e8faSwyllys 	if (subject != NULL) {
58530a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_SUBJECT_NAME_ATTR,
58630a5e8faSwyllys 		    subject, strlen(subject));
58730a5e8faSwyllys 		numattr++;
58830a5e8faSwyllys 	}
58930a5e8faSwyllys 
59030a5e8faSwyllys 	if (serial != NULL) {
59130a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_BIGINT_ATTR,
59230a5e8faSwyllys 		    serial, sizeof (KMF_BIGINT));
59330a5e8faSwyllys 		numattr++;
59430a5e8faSwyllys 	}
59530a5e8faSwyllys 
59630a5e8faSwyllys 	if (dir != NULL) {
59730a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_DIRPATH_ATTR,
59830a5e8faSwyllys 		    dir, strlen(dir));
59930a5e8faSwyllys 		numattr++;
60030a5e8faSwyllys 	}
60130a5e8faSwyllys 
60230a5e8faSwyllys 	if (filename != NULL) {
60330a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_CERT_FILENAME_ATTR,
60430a5e8faSwyllys 		    filename, strlen(filename));
60530a5e8faSwyllys 		numattr++;
60630a5e8faSwyllys 	}
60730a5e8faSwyllys 
60830a5e8faSwyllys 	kmf_set_attr_at_index(attrlist, numattr, KMF_CERT_VALIDITY_ATTR,
60930a5e8faSwyllys 	    &find_criteria_flag, sizeof (KMF_CERT_VALIDITY));
61030a5e8faSwyllys 	numattr++;
61130a5e8faSwyllys 
61230a5e8faSwyllys 	rv = pk_delete_certs(kmfhandle, attrlist, numattr);
61399ebb4caSwyllys 
61499ebb4caSwyllys 	return (rv);
61599ebb4caSwyllys }
61699ebb4caSwyllys 
61799ebb4caSwyllys static KMF_RETURN
61899ebb4caSwyllys delete_file_keys(KMF_HANDLE_T kmfhandle, int oclass,
61999ebb4caSwyllys 	char *dir, char *infile)
62099ebb4caSwyllys {
62199ebb4caSwyllys 	KMF_RETURN rv = KMF_OK;
62299ebb4caSwyllys 	char *keytype = "";
62399ebb4caSwyllys 	int nk, numkeys = 0;
62430a5e8faSwyllys 	KMF_KEYSTORE_TYPE kstype = KMF_KEYSTORE_OPENSSL;
62530a5e8faSwyllys 	int numattr = 0;
62630a5e8faSwyllys 	KMF_ATTRIBUTE attrlist[16];
62730a5e8faSwyllys 	KMF_KEY_CLASS keyclass;
62899ebb4caSwyllys 
62930a5e8faSwyllys 	kmf_set_attr_at_index(attrlist, numattr, KMF_KEYSTORE_TYPE_ATTR,
63030a5e8faSwyllys 	    &kstype, sizeof (kstype));
63130a5e8faSwyllys 	numattr++;
63230a5e8faSwyllys 
63330a5e8faSwyllys 	if (dir != NULL) {
63430a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_DIRPATH_ATTR,
63530a5e8faSwyllys 		    dir, strlen(dir));
63630a5e8faSwyllys 		numattr++;
63730a5e8faSwyllys 	}
63830a5e8faSwyllys 
63930a5e8faSwyllys 	if (infile != NULL) {
64030a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_KEY_FILENAME_ATTR,
64130a5e8faSwyllys 		    infile, strlen(infile));
64230a5e8faSwyllys 		numattr++;
64330a5e8faSwyllys 	}
64499ebb4caSwyllys 
64599ebb4caSwyllys 	if (oclass & (PK_PUBKEY_OBJ | PK_PRIKEY_OBJ)) {
64630a5e8faSwyllys 		int num = numattr;
64730a5e8faSwyllys 
64830a5e8faSwyllys 		keyclass = KMF_ASYM_PRI;
64930a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, num, KMF_KEYCLASS_ATTR,
65030a5e8faSwyllys 		    &keyclass, sizeof (keyclass));
65130a5e8faSwyllys 		num++;
65230a5e8faSwyllys 
65399ebb4caSwyllys 		keytype = "Asymmetric";
65430a5e8faSwyllys 		rv = pk_delete_keys(kmfhandle, attrlist, num, keytype, &nk);
65599ebb4caSwyllys 		numkeys += nk;
65699ebb4caSwyllys 	}
65799ebb4caSwyllys 	if (rv == KMF_OK && (oclass & PK_SYMKEY_OBJ)) {
65830a5e8faSwyllys 		int num = numattr;
65930a5e8faSwyllys 
66030a5e8faSwyllys 		keyclass = KMF_SYMMETRIC;
66130a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, num, KMF_KEYCLASS_ATTR,
66230a5e8faSwyllys 		    &keyclass, sizeof (keyclass));
66330a5e8faSwyllys 		num++;
66430a5e8faSwyllys 
66599ebb4caSwyllys 		keytype = "symmetric";
66630a5e8faSwyllys 		rv = pk_delete_keys(kmfhandle, attrlist, num, keytype, &nk);
66799ebb4caSwyllys 		numkeys += nk;
66899ebb4caSwyllys 	}
66999ebb4caSwyllys 	if (rv == KMF_OK && numkeys == 0)
67099ebb4caSwyllys 		rv = KMF_ERR_KEY_NOT_FOUND;
67199ebb4caSwyllys 
67299ebb4caSwyllys 	return (rv);
67399ebb4caSwyllys }
67499ebb4caSwyllys 
67599ebb4caSwyllys static KMF_RETURN
676*448b8615Swyllys delete_file_crl(void *kmfhandle, char *filename)
67799ebb4caSwyllys {
67899ebb4caSwyllys 	KMF_RETURN rv;
67930a5e8faSwyllys 	int numattr = 0;
68030a5e8faSwyllys 	KMF_ATTRIBUTE attrlist[4];
68130a5e8faSwyllys 	KMF_KEYSTORE_TYPE kstype = KMF_KEYSTORE_OPENSSL;
68299ebb4caSwyllys 
683*448b8615Swyllys 	if (filename == NULL || strlen(filename) == 0)
684*448b8615Swyllys 		return (KMF_ERR_BAD_PARAMETER);
685*448b8615Swyllys 
68630a5e8faSwyllys 	kmf_set_attr_at_index(attrlist, numattr, KMF_KEYSTORE_TYPE_ATTR,
68730a5e8faSwyllys 	    &kstype, sizeof (kstype));
68830a5e8faSwyllys 	numattr++;
68999ebb4caSwyllys 
69030a5e8faSwyllys 	if (filename) {
69130a5e8faSwyllys 		kmf_set_attr_at_index(attrlist, numattr, KMF_CRL_FILENAME_ATTR,
69230a5e8faSwyllys 		    filename, strlen(filename));
69330a5e8faSwyllys 		numattr++;
69430a5e8faSwyllys 	}
69599ebb4caSwyllys 
69630a5e8faSwyllys 	rv = kmf_delete_crl(kmfhandle, numattr, attrlist);
69799ebb4caSwyllys 
69899ebb4caSwyllys 	return (rv);
69999ebb4caSwyllys }
7007711facfSdinak 
7017711facfSdinak /*
7027711facfSdinak  * Delete token objects.
7037711facfSdinak  */
7047711facfSdinak int
7057711facfSdinak pk_delete(int argc, char *argv[])
7067711facfSdinak {
7077711facfSdinak 	int		opt;
70849e21299Sdinak 	extern int	optind_av;
70949e21299Sdinak 	extern char	*optarg_av;
71049e21299Sdinak 	char		*token_spec = NULL;
71199ebb4caSwyllys 	char		*subject = NULL;
71299ebb4caSwyllys 	char		*issuer = NULL;
71399ebb4caSwyllys 	char		*dir = NULL;
71499ebb4caSwyllys 	char		*prefix = NULL;
71599ebb4caSwyllys 	char		*infile = NULL;
71699ebb4caSwyllys 	char		*object_label = NULL;
71799ebb4caSwyllys 	char		*serstr = NULL;
7187711facfSdinak 
71999ebb4caSwyllys 	int		oclass = 0;
72099ebb4caSwyllys 	KMF_BIGINT	serial = { NULL, 0 };
72199ebb4caSwyllys 	KMF_HANDLE_T	kmfhandle = NULL;
72299ebb4caSwyllys 	KMF_KEYSTORE_TYPE	kstype = 0;
72399ebb4caSwyllys 	KMF_RETURN	kmfrv;
72499ebb4caSwyllys 	int		rv = 0;
72599ebb4caSwyllys 	char			*find_criteria = NULL;
72699ebb4caSwyllys 	KMF_CERT_VALIDITY	find_criteria_flag = KMF_ALL_CERTS;
72799ebb4caSwyllys 	KMF_CREDENTIAL	tokencred = {NULL, 0};
7287711facfSdinak 
7297711facfSdinak 	/* Parse command line options.  Do NOT i18n/l10n. */
73049e21299Sdinak 	while ((opt = getopt_av(argc, argv,
73199ebb4caSwyllys 	    "T:(token)y:(objtype)l:(label)"
73299ebb4caSwyllys 	    "k:(keystore)s:(subject)n:(nickname)"
73399ebb4caSwyllys 	    "d:(dir)p:(prefix)S:(serial)i:(issuer)"
73499ebb4caSwyllys 	    "c:(criteria)"
73599ebb4caSwyllys 	    "f:(infile)")) != EOF) {
73699ebb4caSwyllys 
73799ebb4caSwyllys 		if (EMPTYSTRING(optarg_av))
73899ebb4caSwyllys 			return (PK_ERR_USAGE);
7397711facfSdinak 		switch (opt) {
74049e21299Sdinak 		case 'T':	/* token specifier */
74149e21299Sdinak 			if (token_spec)
74249e21299Sdinak 				return (PK_ERR_USAGE);
74349e21299Sdinak 			token_spec = optarg_av;
7447711facfSdinak 			break;
74549e21299Sdinak 		case 'y':	/* object type:  public, private, both */
74699ebb4caSwyllys 			if (oclass)
74749e21299Sdinak 				return (PK_ERR_USAGE);
74899ebb4caSwyllys 			oclass = OT2Int(optarg_av);
74999ebb4caSwyllys 			if (oclass == -1)
75099ebb4caSwyllys 				return (PK_ERR_USAGE);
7517711facfSdinak 			break;
7527711facfSdinak 		case 'l':	/* objects with specific label */
75399ebb4caSwyllys 		case 'n':
7547711facfSdinak 			if (object_label)
7557711facfSdinak 				return (PK_ERR_USAGE);
75699ebb4caSwyllys 			object_label = (char *)optarg_av;
75799ebb4caSwyllys 			break;
75899ebb4caSwyllys 		case 'k':
75999ebb4caSwyllys 			kstype = KS2Int(optarg_av);
76099ebb4caSwyllys 			if (kstype == 0)
76199ebb4caSwyllys 				return (PK_ERR_USAGE);
76299ebb4caSwyllys 			break;
76399ebb4caSwyllys 		case 's':
76499ebb4caSwyllys 			subject = optarg_av;
76599ebb4caSwyllys 			break;
76699ebb4caSwyllys 		case 'i':
76799ebb4caSwyllys 			issuer = optarg_av;
76899ebb4caSwyllys 			break;
76999ebb4caSwyllys 		case 'd':
77099ebb4caSwyllys 			dir = optarg_av;
77199ebb4caSwyllys 			break;
77299ebb4caSwyllys 		case 'p':
77399ebb4caSwyllys 			prefix = optarg_av;
77499ebb4caSwyllys 			break;
77599ebb4caSwyllys 		case 'S':
77699ebb4caSwyllys 			serstr = optarg_av;
77799ebb4caSwyllys 			break;
77899ebb4caSwyllys 		case 'f':
77999ebb4caSwyllys 			infile = optarg_av;
78099ebb4caSwyllys 			break;
78199ebb4caSwyllys 		case 'c':
78299ebb4caSwyllys 			find_criteria = optarg_av;
78399ebb4caSwyllys 			if (!strcasecmp(find_criteria, "valid"))
78499ebb4caSwyllys 				find_criteria_flag =
78599ebb4caSwyllys 				    KMF_NONEXPIRED_CERTS;
78699ebb4caSwyllys 			else if (!strcasecmp(find_criteria, "expired"))
78799ebb4caSwyllys 				find_criteria_flag = KMF_EXPIRED_CERTS;
78899ebb4caSwyllys 			else if (!strcasecmp(find_criteria, "both"))
78999ebb4caSwyllys 				find_criteria_flag = KMF_ALL_CERTS;
79099ebb4caSwyllys 			else
79199ebb4caSwyllys 				return (PK_ERR_USAGE);
7927711facfSdinak 			break;
7937711facfSdinak 		default:
7947711facfSdinak 			return (PK_ERR_USAGE);
7957711facfSdinak 			break;
7967711facfSdinak 		}
7977711facfSdinak 	}
7987711facfSdinak 
79999ebb4caSwyllys 	/* Assume keystore = PKCS#11 if not specified */
80099ebb4caSwyllys 	if (kstype == 0)
80199ebb4caSwyllys 		kstype = KMF_KEYSTORE_PK11TOKEN;
80299ebb4caSwyllys 
80399ebb4caSwyllys 	/* if PUBLIC or PRIVATE obj was given, the old syntax was used. */
80499ebb4caSwyllys 	if ((oclass & (PK_PUBLIC_OBJ | PK_PRIVATE_OBJ)) &&
80599ebb4caSwyllys 	    kstype != KMF_KEYSTORE_PK11TOKEN) {
80699ebb4caSwyllys 
80799ebb4caSwyllys 		(void) fprintf(stderr, gettext("The objtype parameter "
80899ebb4caSwyllys 		    "is only relevant if keystore=pkcs11\n"));
80949e21299Sdinak 		return (PK_ERR_USAGE);
81049e21299Sdinak 	}
81149e21299Sdinak 
8127711facfSdinak 
8137711facfSdinak 	/* No additional args allowed. */
81449e21299Sdinak 	argc -= optind_av;
81549e21299Sdinak 	argv += optind_av;
8167711facfSdinak 	if (argc)
8177711facfSdinak 		return (PK_ERR_USAGE);
8187711facfSdinak 	/* Done parsing command line options. */
8197711facfSdinak 
82099ebb4caSwyllys 	if (kstype == KMF_KEYSTORE_PK11TOKEN && token_spec == NULL) {
82199ebb4caSwyllys 		token_spec = PK_DEFAULT_PK11TOKEN;
82299ebb4caSwyllys 	} else if (kstype == KMF_KEYSTORE_NSS && token_spec == NULL) {
82399ebb4caSwyllys 		token_spec = DEFAULT_NSS_TOKEN;
8247711facfSdinak 	}
8257711facfSdinak 
82699ebb4caSwyllys 	if (serstr != NULL) {
82799ebb4caSwyllys 		uchar_t *bytes = NULL;
82899ebb4caSwyllys 		size_t bytelen;
82999ebb4caSwyllys 
83030a5e8faSwyllys 		rv = kmf_hexstr_to_bytes((uchar_t *)serstr, &bytes, &bytelen);
83199ebb4caSwyllys 		if (rv != KMF_OK || bytes == NULL) {
83299ebb4caSwyllys 			(void) fprintf(stderr, gettext("serial number "
83399ebb4caSwyllys 			    "must be specified as a hex number "
83499ebb4caSwyllys 			    "(ex: 0x0102030405ffeeddee)\n"));
83599ebb4caSwyllys 			return (PK_ERR_USAGE);
83699ebb4caSwyllys 		}
83799ebb4caSwyllys 		serial.val = bytes;
83899ebb4caSwyllys 		serial.len = bytelen;
8392cbed729Swyllys 		/* If serial number was given, it must be a cert search */
8402cbed729Swyllys 		if (oclass == 0)
8412cbed729Swyllys 			oclass = PK_CERT_OBJ;
8427711facfSdinak 	}
8432cbed729Swyllys 	/*
8442cbed729Swyllys 	 * If no object type was given but subject or issuer was,
8452cbed729Swyllys 	 * it must be a certificate we are looking to delete.
8462cbed729Swyllys 	 */
8472cbed729Swyllys 	if ((issuer != NULL || subject != NULL) && oclass == 0)
8482cbed729Swyllys 		oclass = PK_CERT_OBJ;
8492cbed729Swyllys 	/* If no object class specified, delete everything but CRLs */
8502cbed729Swyllys 	if (oclass == 0)
8512cbed729Swyllys 		oclass = PK_CERT_OBJ | PK_KEY_OBJ;
8527711facfSdinak 
85399ebb4caSwyllys 	if ((kstype == KMF_KEYSTORE_PK11TOKEN ||
85499ebb4caSwyllys 	    kstype == KMF_KEYSTORE_NSS) &&
85599ebb4caSwyllys 	    (oclass & (PK_KEY_OBJ | PK_PRIVATE_OBJ))) {
85699ebb4caSwyllys 
85799ebb4caSwyllys 		(void) get_token_password(kstype, token_spec,
85899ebb4caSwyllys 		    &tokencred);
8597711facfSdinak 	}
8607711facfSdinak 
86130a5e8faSwyllys 	if ((kmfrv = kmf_initialize(&kmfhandle, NULL, NULL)) != KMF_OK)
86299ebb4caSwyllys 		return (kmfrv);
8637711facfSdinak 
86499ebb4caSwyllys 	switch (kstype) {
86599ebb4caSwyllys 		case KMF_KEYSTORE_PK11TOKEN:
86699ebb4caSwyllys 			if (oclass & PK_KEY_OBJ) {
86799ebb4caSwyllys 				kmfrv = delete_pk11_keys(kmfhandle,
86899ebb4caSwyllys 				    token_spec, oclass,
86930a5e8faSwyllys 				    object_label, &tokencred);
8707711facfSdinak 				/*
87199ebb4caSwyllys 				 * If deleting groups of objects, it is OK
87299ebb4caSwyllys 				 * to ignore the "key not found" case so that
87399ebb4caSwyllys 				 * we can continue to find other objects.
8747711facfSdinak 				 */
87599ebb4caSwyllys 				if (kmfrv == KMF_ERR_KEY_NOT_FOUND &&
87699ebb4caSwyllys 				    (oclass != PK_KEY_OBJ))
87799ebb4caSwyllys 					kmfrv = KMF_OK;
87899ebb4caSwyllys 				if (kmfrv != KMF_OK)
87999ebb4caSwyllys 					break;
8807711facfSdinak 			}
88199ebb4caSwyllys 			if (oclass & (PK_CERT_OBJ | PK_PUBLIC_OBJ)) {
88299ebb4caSwyllys 				kmfrv = delete_pk11_certs(kmfhandle,
88330a5e8faSwyllys 				    token_spec, object_label,
88499ebb4caSwyllys 				    &serial, issuer,
88599ebb4caSwyllys 				    subject, find_criteria_flag);
88699ebb4caSwyllys 				/*
88799ebb4caSwyllys 				 * If cert delete failed, but we are looking at
88899ebb4caSwyllys 				 * other objects, then it is OK.
88999ebb4caSwyllys 				 */
89099ebb4caSwyllys 				if (kmfrv == KMF_ERR_CERT_NOT_FOUND &&
89199ebb4caSwyllys 				    (oclass & (PK_CRL_OBJ | PK_KEY_OBJ)))
89299ebb4caSwyllys 					kmfrv = KMF_OK;
89399ebb4caSwyllys 				if (kmfrv != KMF_OK)
89499ebb4caSwyllys 					break;
8957711facfSdinak 			}
89699ebb4caSwyllys 			if (oclass & PK_CRL_OBJ)
89799ebb4caSwyllys 				kmfrv = delete_file_crl(kmfhandle,
898*448b8615Swyllys 				    infile);
89999ebb4caSwyllys 			break;
90099ebb4caSwyllys 		case KMF_KEYSTORE_NSS:
90199ebb4caSwyllys 			if (oclass & PK_KEY_OBJ) {
90299ebb4caSwyllys 				kmfrv = delete_nss_keys(kmfhandle,
90399ebb4caSwyllys 				    dir, prefix, token_spec,
90499ebb4caSwyllys 				    oclass, (char  *)object_label,
90599ebb4caSwyllys 				    &tokencred);
90699ebb4caSwyllys 				if (kmfrv != KMF_OK)
90799ebb4caSwyllys 					break;
90899ebb4caSwyllys 			}
90999ebb4caSwyllys 			if (oclass & PK_CERT_OBJ) {
91099ebb4caSwyllys 				kmfrv = delete_nss_certs(kmfhandle,
91199ebb4caSwyllys 				    dir, prefix, token_spec,
91299ebb4caSwyllys 				    (char  *)object_label,
91399ebb4caSwyllys 				    &serial, issuer, subject,
91499ebb4caSwyllys 				    find_criteria_flag);
91599ebb4caSwyllys 				if (kmfrv != KMF_OK)
91699ebb4caSwyllys 					break;
91799ebb4caSwyllys 			}
91899ebb4caSwyllys 			if (oclass & PK_CRL_OBJ)
91999ebb4caSwyllys 				kmfrv = delete_nss_crl(kmfhandle,
92099ebb4caSwyllys 				    dir, prefix, token_spec,
92199ebb4caSwyllys 				    (char  *)object_label, subject);
92299ebb4caSwyllys 			break;
92399ebb4caSwyllys 		case KMF_KEYSTORE_OPENSSL:
92499ebb4caSwyllys 			if (oclass & PK_KEY_OBJ) {
92599ebb4caSwyllys 				kmfrv = delete_file_keys(kmfhandle, oclass,
92699ebb4caSwyllys 				    dir, infile);
92799ebb4caSwyllys 				if (kmfrv != KMF_OK)
92899ebb4caSwyllys 					break;
92999ebb4caSwyllys 			}
93099ebb4caSwyllys 			if (oclass & (PK_CERT_OBJ)) {
93199ebb4caSwyllys 				kmfrv = delete_file_certs(kmfhandle,
93299ebb4caSwyllys 				    dir, infile, &serial, issuer,
93399ebb4caSwyllys 				    subject, find_criteria_flag);
93499ebb4caSwyllys 				if (kmfrv != KMF_OK)
93599ebb4caSwyllys 					break;
93699ebb4caSwyllys 			}
93799ebb4caSwyllys 			if (oclass & PK_CRL_OBJ)
93899ebb4caSwyllys 				kmfrv = delete_file_crl(kmfhandle,
939*448b8615Swyllys 				    infile);
94099ebb4caSwyllys 			break;
94199ebb4caSwyllys 		default:
94299ebb4caSwyllys 			rv = PK_ERR_USAGE;
94399ebb4caSwyllys 			break;
9447711facfSdinak 	}
9457711facfSdinak 
94699ebb4caSwyllys 	if (kmfrv != KMF_OK) {
94799ebb4caSwyllys 		display_error(kmfhandle, kmfrv,
94899ebb4caSwyllys 		    gettext("Error deleting objects"));
9497711facfSdinak 	}
9507711facfSdinak 
95199ebb4caSwyllys 	if (serial.val != NULL)
95299ebb4caSwyllys 		free(serial.val);
95330a5e8faSwyllys 	(void) kmf_finalize(kmfhandle);
95499ebb4caSwyllys 	return (kmfrv);
9557711facfSdinak }
956