1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21/*
22 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23 * Use is subject to license terms.
24 */
25
26/*
27 * Copyright (c) 2018, Joyent, Inc.
28 */
29
30/*
31 * mdb dcmds for selected structures from
32 * usr/src/uts/common/sys/crypto/spi.h
33 *
34 * Also the mdb module housekeeping
35 */
36
37#include <sys/mdb_modapi.h>
38#include <sys/modctl.h>
39#include <sys/crypto/api.h>
40#include <sys/crypto/common.h>
41#include <sys/crypto/spi.h>
42#include <sys/crypto/impl.h>
43#include "crypto_cmds.h"
44
45
46const mdb_bitmask_t extf_flags[] = {
47	{ "NIL", (ulong_t)-1, 0L },
48	{ "CRYPTO_EXTF_RNG", CRYPTO_EXTF_RNG, CRYPTO_EXTF_RNG },
49	{ "CRYPTO_EXTF_WRITE_PROTECTED", CRYPTO_EXTF_WRITE_PROTECTED,
50		CRYPTO_EXTF_WRITE_PROTECTED },
51	{ "CRYPTO_EXTF_LOGIN_REQUIRED", CRYPTO_EXTF_LOGIN_REQUIRED,
52		CRYPTO_EXTF_LOGIN_REQUIRED },
53	{ "CRYPTO_EXTF_USER_PIN_INITIALIZED", CRYPTO_EXTF_USER_PIN_INITIALIZED,
54		CRYPTO_EXTF_USER_PIN_INITIALIZED },
55	{ "CRYPTO_EXTF_CLOCK_ON_TOKEN", CRYPTO_EXTF_CLOCK_ON_TOKEN,
56		CRYPTO_EXTF_CLOCK_ON_TOKEN },
57	{ "CRYPTO_EXTF_PROTECTED_AUTHENTICATION_PATH",
58		CRYPTO_EXTF_PROTECTED_AUTHENTICATION_PATH,
59		CRYPTO_EXTF_PROTECTED_AUTHENTICATION_PATH },
60	{ "CRYPTO_EXTF_DUAL_CRYPTO_OPERATIONS",
61		CRYPTO_EXTF_DUAL_CRYPTO_OPERATIONS,
62		CRYPTO_EXTF_DUAL_CRYPTO_OPERATIONS },
63	{ "CRYPTO_EXTF_TOKEN_INITIALIZED", CRYPTO_EXTF_TOKEN_INITIALIZED,
64		CRYPTO_EXTF_TOKEN_INITIALIZED },
65	{ "CRYPTO_EXTF_USER_PIN_COUNT_LOW", CRYPTO_EXTF_USER_PIN_COUNT_LOW,
66		CRYPTO_EXTF_USER_PIN_COUNT_LOW },
67	{ "CRYPTO_EXTF_USER_PIN_FINAL_TRY", CRYPTO_EXTF_USER_PIN_FINAL_TRY,
68		CRYPTO_EXTF_USER_PIN_FINAL_TRY },
69	{ "CRYPTO_EXTF_USER_PIN_LOCKED", CRYPTO_EXTF_USER_PIN_LOCKED,
70		CRYPTO_EXTF_USER_PIN_LOCKED },
71	{ "CRYPTO_EXTF_USER_PIN_TO_BE_CHANGED",
72		CRYPTO_EXTF_USER_PIN_TO_BE_CHANGED,
73		CRYPTO_EXTF_USER_PIN_TO_BE_CHANGED },
74	{ "CRYPTO_EXTF_SO_PIN_COUNT_LOW", CRYPTO_EXTF_SO_PIN_COUNT_LOW,
75		CRYPTO_EXTF_SO_PIN_COUNT_LOW },
76	{ "CRYPTO_EXTF_SO_PIN_FINAL_TRY", CRYPTO_EXTF_SO_PIN_FINAL_TRY,
77		CRYPTO_EXTF_SO_PIN_FINAL_TRY },
78	{ "CRYPTO_EXTF_SO_PIN_LOCKED", CRYPTO_EXTF_SO_PIN_LOCKED,
79		CRYPTO_EXTF_SO_PIN_LOCKED },
80	{ "CRYPTO_EXTF_SO_PIN_TO_BE_CHANGED", CRYPTO_EXTF_SO_PIN_TO_BE_CHANGED,
81		CRYPTO_EXTF_SO_PIN_TO_BE_CHANGED },
82	{ NULL, 0, 0 }
83};
84
85/*ARGSUSED*/
86int
87crypto_provider_ext_info(uintptr_t addr, uint_t flags, int argc,
88    const mdb_arg_t *argv)
89{
90	crypto_provider_ext_info_t ext_prov;
91	/*
92	 * 33 is 1 + MAX(CRYPTO_EXT_SIZE_LABEL, CRYPTO_EXT_SIZE_MANUF,
93	 *		 CRYPTO_EXT_SIZE_MODEL, CRYPTO_EXT_SIZE_SERIAL)
94	 */
95	char scratch[33];
96
97	if (!(flags & DCMD_ADDRSPEC))
98		return (DCMD_USAGE);
99
100	if (mdb_vread(&ext_prov, sizeof (crypto_provider_ext_info_t), addr)
101	    == -1) {
102		mdb_warn("cannot read addr");
103		return (DCMD_ERR);
104	}
105	bcopy(ext_prov.ei_label, scratch, CRYPTO_EXT_SIZE_LABEL);
106	scratch[CRYPTO_EXT_SIZE_LABEL] = '\0';
107	mdb_printf("ei_label\t\t%s\n", scratch);
108
109	bcopy(ext_prov.ei_manufacturerID, scratch, CRYPTO_EXT_SIZE_MANUF);
110	scratch[CRYPTO_EXT_SIZE_MANUF] = '\0';
111	mdb_printf("ei_manufacturerID\t%s\n", scratch);
112
113	bcopy(ext_prov.ei_model, scratch, CRYPTO_EXT_SIZE_MODEL);
114	scratch[CRYPTO_EXT_SIZE_MODEL] = '\0';
115	mdb_printf("ei_model\t\t%s\n", scratch);
116
117	bcopy(ext_prov.ei_serial_number, scratch, CRYPTO_EXT_SIZE_SERIAL);
118	scratch[CRYPTO_EXT_SIZE_SERIAL] = '\0';
119	mdb_printf("ei_serial_number\t%s\n", scratch);
120
121	mdb_printf("ei_flags\t0x%x:\t<%lb>\n", ext_prov.ei_flags,
122	    ext_prov.ei_flags, extf_flags);
123	mdb_printf("ei_max_session_count\t%lu\n",
124	    ext_prov.ei_max_session_count);
125	mdb_printf("ei_max_pin_len\t\t%lu\n", ext_prov.ei_max_pin_len);
126	mdb_printf("ei_min_pin_len\t\t%lu\n", ext_prov.ei_min_pin_len);
127	mdb_printf("ei_total_public_memory\t%lu\n",
128	    ext_prov.ei_total_public_memory);
129	mdb_printf("ei_free_public_memory\t%lu\n",
130	    ext_prov.ei_free_public_memory);
131	mdb_printf("ei_total_private_memory\t%lu\n",
132	    ext_prov.ei_total_private_memory);
133	mdb_printf("ei_free_private_memory\t%lu\n",
134	    ext_prov.ei_free_private_memory);
135	mdb_printf("ei_hardware_version\tmajor %c minor %c\n",
136	    ext_prov.ei_hardware_version.cv_major,
137	    ext_prov.ei_hardware_version.cv_minor);
138	mdb_printf("ei_firmware_version\tmajor %c minor %c\n",
139	    ext_prov.ei_firmware_version.cv_major,
140	    ext_prov.ei_firmware_version.cv_minor);
141	mdb_printf("ei_time\t%s\n", ext_prov.ei_time);
142	return (DCMD_OK);
143}
144
145const mdb_bitmask_t mech_bits[] = {
146	{ "NIL", (uint32_t)-1, 0 },
147	{ "CRYPTO_FG_ENCRYPT", CRYPTO_FG_ENCRYPT, CRYPTO_FG_ENCRYPT },
148	{ "CRYPTO_FG_DECRYPT", CRYPTO_FG_DECRYPT, CRYPTO_FG_DECRYPT },
149	{ "CRYPTO_FG_DIGEST", CRYPTO_FG_DIGEST, CRYPTO_FG_DIGEST },
150	{ "CRYPTO_FG_SIGN", CRYPTO_FG_SIGN, CRYPTO_FG_SIGN },
151	{ "CRYPTO_FG_SIGN_RECOVER", CRYPTO_FG_SIGN_RECOVER,
152		CRYPTO_FG_SIGN_RECOVER },
153	{ "CRYPTO_FG_VERIFY", CRYPTO_FG_VERIFY, CRYPTO_FG_VERIFY },
154	{ "CRYPTO_FG_VERIFY_RECOVER", CRYPTO_FG_VERIFY_RECOVER,
155		CRYPTO_FG_VERIFY_RECOVER },
156	{ "CRYPTO_FG_GENERATE", CRYPTO_FG_GENERATE, CRYPTO_FG_GENERATE },
157	{ "CRYPTO_FG_GENERATE_KEY_PAIR", CRYPTO_FG_GENERATE_KEY_PAIR,
158		CRYPTO_FG_GENERATE_KEY_PAIR },
159	{ "CRYPTO_FG_WRAP", CRYPTO_FG_WRAP, CRYPTO_FG_WRAP },
160	{ "CRYPTO_FG_UNWRAP", CRYPTO_FG_UNWRAP, CRYPTO_FG_UNWRAP },
161	{ "CRYPTO_FG_DERIVE", CRYPTO_FG_DERIVE, CRYPTO_FG_DERIVE },
162	{ "CRYPTO_FG_MAC", CRYPTO_FG_MAC, CRYPTO_FG_MAC },
163	{ "CRYPTO_FG_ENCRYPT_MAC", CRYPTO_FG_ENCRYPT_MAC,
164		CRYPTO_FG_ENCRYPT_MAC },
165	{ "CRYPTO_FG_MAC_DECRYPT", CRYPTO_FG_MAC_DECRYPT,
166		CRYPTO_FG_MAC_DECRYPT },
167	{ "CRYPTO_FG_ENCRYPT_ATOMIC", CRYPTO_FG_ENCRYPT_ATOMIC,
168		CRYPTO_FG_ENCRYPT_ATOMIC },
169	{ "CRYPTO_FG_DECRYPT_ATOMIC", CRYPTO_FG_DECRYPT_ATOMIC,
170		CRYPTO_FG_DECRYPT_ATOMIC },
171	{ "CRYPTO_FG_MAC_ATOMIC", CRYPTO_FG_MAC_ATOMIC, CRYPTO_FG_MAC_ATOMIC },
172	{ "CRYPTO_FG_DIGEST_ATOMIC", CRYPTO_FG_DIGEST_ATOMIC,
173		CRYPTO_FG_DIGEST_ATOMIC },
174	{ "CRYPTO_FG_SIGN_ATOMIC", CRYPTO_FG_SIGN_ATOMIC,
175		CRYPTO_FG_SIGN_ATOMIC },
176	{ "CRYPTO_FG_SIGN_RECOVER_ATOMIC", CRYPTO_FG_SIGN_RECOVER_ATOMIC,
177		CRYPTO_FG_SIGN_RECOVER_ATOMIC },
178	{ "CRYPTO_FG_VERIFY_ATOMIC", CRYPTO_FG_VERIFY_ATOMIC,
179		CRYPTO_FG_VERIFY_ATOMIC },
180	{ "CRYPTO_FG_VERIFY_RECOVER_ATOMIC", CRYPTO_FG_VERIFY_RECOVER_ATOMIC,
181		CRYPTO_FG_VERIFY_RECOVER_ATOMIC },
182	{ "CRYPTO_FG_ENCRYPT_MAC_ATOMIC", CRYPTO_FG_ENCRYPT_MAC_ATOMIC,
183		CRYPTO_FG_ENCRYPT_MAC_ATOMIC },
184	{ "CRYPTO_FG_MAC_DECRYPT_ATOMIC", CRYPTO_FG_MAC_DECRYPT_ATOMIC,
185		CRYPTO_FG_MAC_DECRYPT_ATOMIC },
186	{ "CRYPTO_FG_RANDOM", CRYPTO_FG_RANDOM, CRYPTO_FG_RANDOM},
187	{ NULL, 0, 0 }
188};
189
190/*ARGSUSED*/
191int
192crypto_mech_info(uintptr_t addr, uint_t flags, int argc,
193    const mdb_arg_t *argv)
194{
195	crypto_mech_info_t minfo;
196	const char *unit = "bits";
197
198	if (!(flags & DCMD_ADDRSPEC))
199		return (DCMD_USAGE);
200
201	if (mdb_vread(&minfo, sizeof (crypto_mech_info_t), addr)
202	    == -1) {
203		mdb_warn("cannot read addr %p", addr);
204		return (DCMD_ERR);
205	}
206	mdb_printf("cm_mech_name_t\t%s\n", minfo.cm_mech_name);
207	mdb_printf("cm_mech_number\t%lld\n", minfo.cm_mech_number);
208	mdb_printf("cm_func_group_mask\t0x%x:\t<%b>\n",
209	    minfo.cm_func_group_mask, minfo.cm_func_group_mask, mech_bits);
210	if (minfo.cm_keysize_unit & CRYPTO_KEYSIZE_UNIT_IN_BYTES)
211		unit = "bytes";
212	mdb_printf("cm_min_key_length\t%lu %s\n", minfo.cm_min_key_length,
213	    unit);
214	mdb_printf("cm_max_key_length\t%lu %s\n", minfo.cm_max_key_length,
215	    unit);
216
217	return (DCMD_OK);
218}
219
220/*
221 * MDB module linkage information:
222 *
223 * We declare a list of structures describing our dcmds, and a function
224 * named _mdb_init to return a pointer to our module information.
225 */
226
227static const mdb_dcmd_t dcmds[] = {
228
229	/* spi.c */
230	{ "crypto_provider_ext_info", ":",
231	    "module-private crypto provider info",
232	    crypto_provider_ext_info, NULL },
233	{ "crypto_mech_info", ":",
234	    "print as crypto_mech_info",
235	    crypto_mech_info, NULL },
236
237	/* common.c */
238	{ "crypto_mechanism", ":",
239	    "details about a crypto mechanism", crypto_mechanism, NULL },
240	{ "crypto_data", ":",
241	    "print as crypto_data",
242	    crypto_data, NULL },
243	{ "crypto_dual_data", ":",
244	    "print as crypto_dual_data",
245	    crypto_dual_data, NULL },
246	{ "crypto_key", ":",
247	    "print as crypto_key", crypto_key, NULL },
248
249
250	/* impl.c */
251	{ "kcf_provider_desc", ":",
252	    "crypto provider description struct", kcf_provider_desc, NULL },
253
254	{ "prov_tab", "",
255	    "global table of crypto providers ", prov_tab, NULL },
256
257	{ "policy_tab", "",
258	    "print global policy_tab", policy_tab, NULL },
259
260	/* sched_impl.c */
261	{ "kcf_areq_node", ":[-v]",
262	    "print asynchronous crypto request struct, [ verbose ]",
263		kcf_areq_node, NULL },
264
265	{ "kcf_global_swq", "?[-v]",
266	    "global or addr global crypto queue.  [ -v = verbose ]",
267		kcf_global_swq, NULL },
268	{ "crypto_find_reqid", "?[-v] reqid",
269	    "look for reqid, print if found [ -v = verbose ]",
270		crypto_find_reqid, NULL },
271
272	{ "kcf_reqid_table", ":[-v]",
273	    "print contents of a request ID hash table [ -v = verbose ]",
274		kcf_reqid_table_dcmd, NULL },
275
276	{ "kcf_soft_conf_entry", "?",
277	    "head or addr of configured software crypto providers",
278		kcf_soft_conf_entry, NULL },
279
280	{ "kcf_policy_desc", ":", "policy descriptors for crypto",
281		kcf_policy_desc, NULL },
282	{ NULL }
283};
284
285static const mdb_walker_t walkers[] = {
286	{ "an_next", "walk kcf_areq_node's by an_next",
287		areq_first_walk_init, an_next_walk_step, areq_walk_fini },
288	{ "an_prev", "walk kcf_areq_node's by an_prev",
289		areq_last_walk_init, an_prev_walk_step, areq_walk_fini },
290	{ "an_idnext", "walk kcf_areq_node's by an_idnext",
291		an_idnext_walk_init, an_idnext_walk_step, areq_walk_fini },
292	{ "an_idprev", "walk kcf_areq_node's by an_idprev",
293		an_idprev_walk_init, an_idprev_walk_step, areq_walk_fini },
294	{ "an_ctxchain_next",
295		"walk kcf_areq_node's by an_ctxchain_next",
296		an_ctxchain_walk_init, an_ctxchain_walk_step, areq_walk_fini },
297	{ "kcf_reqid_table", "table of asynchronous crypto requests",
298		reqid_table_walk_init, reqid_table_walk_step,
299		    reqid_table_walk_fini },
300	{ "soft_conf_entry", "table of software providers or addr",
301		soft_conf_walk_init, soft_conf_walk_step,
302		    soft_conf_walk_fini },
303	{ NULL }
304};
305
306
307static const mdb_modinfo_t modinfo = {
308	MDB_API_VERSION, dcmds, walkers
309};
310
311const mdb_modinfo_t *
312_mdb_init(void)
313{
314	return (&modinfo);
315}
316