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