PUBLIC void sys_init()
{
ext_init();
puts("+----------+");
puts("| WARNING! |");
puts("+----------+\n");
puts("This PDComal load module has not been tailored for any OS, and thus contains");
puts("a very limited system interface only.\n");
}
static void john_run(void)
{
if (options.flags & FLG_TEST_CHK)
exit_status = benchmark_all() ? 1 : 0;
else
if (options.flags & FLG_MAKECHR_CHK)
do_makechars(&database, options.charset);
else
if (options.flags & FLG_CRACKING_CHK) {
if (!(options.flags & FLG_STDOUT)) {
status_init(NULL, 1);
log_init(LOG_NAME, options.loader.activepot, options.session);
john_log_format();
if (cfg_get_bool(SECTION_OPTIONS, NULL, "Idle", 1))
log_event("- Configured to use otherwise idle "
"processor cycles only");
}
tty_init(options.flags & FLG_STDIN_CHK);
if (options.flags & FLG_SINGLE_CHK)
do_single_crack(&database);
else
if ((options.flags & FLG_GIJOHN_CHK) && FLG_EXTERNAL_CHK)
{
do
{
do_external_crack(&database);
if (!aborted_gijohn) ext_init("gijohn");
}
while (crk_db->password_count && !aborted_gijohn);
}
else
if (options.flags & FLG_WORDLIST_CHK)
do_wordlist_crack(&database, options.wordlist,
(options.flags & FLG_RULES) != 0);
else
if (options.flags & FLG_INC_CHK)
do_incremental_crack(&database, options.charset);
else
if (options.flags & FLG_MKV_CHK)
do_markov_crack(&database, options.mkv_level, options.mkv_start, options.mkv_end, options.mkv_maxlen);
else
if ((options.flags & FLG_EXTERNAL_CHK) && FLG_GIJOHN_CHK)
do_external_crack(&database);
else
if (options.flags & FLG_BATCH_CHK)
do_batch_crack(&database);
status_print();
tty_done();
}
}
int main(void)
{
log_init();
ext_init();
mallocer_init();
mutex_init();
log_set_level(LOG_DEBUG, NULL);
log_set_file("mallocer_check.log");
malloc_check();
realloc_check();
mutex_fini();
mallocer_fini();
ext_fini();
log_fini();
return EXIT_SUCCESS;
}
static void all_init(void)
{
log_init();
files_init();
ext_init();
cli_init();
mallocer_init(); // as all users do not init it...
ref_init(); // as all users do not init it...
hash_init(); // as all users do not init it...
redim_array_init(); // if there are no users then some ext functions used by the www interface won't be defined
os_detect_init(); // dummy function just to include os_detect in junkie (that does not use it, but plugins may want to)
// Openssl don't like to be inited several times so let's do it once and for all
SSL_load_error_strings();
SSL_library_init();
OpenSSL_add_all_algorithms();
for (unsigned i = 0; i < NB_ELEMS(initers); i++) {
initers[i].init();
}
ext_rebind();
}
int main(int argc, char *argv[])
{
STACK_OF(X509_EXTENSION) * sk = NULL;
X509_EXTENSION *hash_ext = NULL;
X509_EXTENSION *nvctr_ext = NULL;
X509_EXTENSION *trusted_key_ext = NULL;
X509_EXTENSION *non_trusted_key_ext = NULL;
FILE *file = NULL;
int i, tz_nvctr_nid, ntz_nvctr_nid, hash_nid, pk_nid;
int c, opt_idx = 0;
unsigned int err_code;
unsigned char md[SHA256_DIGEST_LENGTH];
const EVP_MD *md_info;
NOTICE("CoT Generation Tool: %s\n", build_msg);
NOTICE("Target platform: %s\n", platform_msg);
/* Set default options */
key_alg = KEY_ALG_RSA;
while (1) {
/* getopt_long stores the option index here. */
c = getopt_long(argc, argv, "ahknp", long_opt, &opt_idx);
/* Detect the end of the options. */
if (c == -1) {
break;
}
switch (c) {
case 'a':
key_alg = get_key_alg(optarg);
if (key_alg < 0) {
ERROR("Invalid key algorithm '%s'\n", optarg);
exit(1);
}
break;
case 'h':
print_help(argv[0]);
break;
case 'k':
save_keys = 1;
break;
case 'n':
new_keys = 1;
break;
case 'p':
print_cert = 1;
break;
case BL2_ID:
certs[BL2_CERT].bin = strdup(optarg);
break;
case BL30_ID:
certs[BL30_CERT].bin = strdup(optarg);
break;
case BL31_ID:
certs[BL31_CERT].bin = strdup(optarg);
break;
case BL32_ID:
certs[BL32_CERT].bin = strdup(optarg);
break;
case BL33_ID:
certs[BL33_CERT].bin = strdup(optarg);
break;
case BL2_CERT_ID:
certs[BL2_CERT].fn = strdup(optarg);
break;
case TRUSTED_KEY_CERT_ID:
certs[TRUSTED_KEY_CERT].fn = strdup(optarg);
break;
case BL30_KEY_CERT_ID:
certs[BL30_KEY_CERT].fn = strdup(optarg);
break;
case BL30_CERT_ID:
certs[BL30_CERT].fn = strdup(optarg);
break;
case BL31_KEY_CERT_ID:
certs[BL31_KEY_CERT].fn = strdup(optarg);
break;
case BL31_CERT_ID:
certs[BL31_CERT].fn = strdup(optarg);
break;
case BL32_KEY_CERT_ID:
certs[BL32_KEY_CERT].fn = strdup(optarg);
break;
case BL32_CERT_ID:
certs[BL32_CERT].fn = strdup(optarg);
break;
case BL33_KEY_CERT_ID:
certs[BL33_KEY_CERT].fn = strdup(optarg);
break;
case BL33_CERT_ID:
certs[BL33_CERT].fn = strdup(optarg);
break;
case ROT_KEY_ID:
keys[ROT_KEY].fn = strdup(optarg);
break;
case TRUSTED_WORLD_KEY_ID:
keys[TRUSTED_WORLD_KEY].fn = strdup(optarg);
break;
case NON_TRUSTED_WORLD_KEY_ID:
keys[NON_TRUSTED_WORLD_KEY].fn = strdup(optarg);
break;
case BL30_KEY_ID:
keys[BL30_KEY].fn = strdup(optarg);
break;
case BL31_KEY_ID:
keys[BL31_KEY].fn = strdup(optarg);
break;
case BL32_KEY_ID:
keys[BL32_KEY].fn = strdup(optarg);
break;
case BL33_KEY_ID:
keys[BL33_KEY].fn = strdup(optarg);
break;
case '?':
default:
printf("%s\n", optarg);
exit(1);
}
}
/* Set the value of the NVCounters */
tf_nvcounter = NVCOUNTER_VALUE;
non_tf_nvcounter = NVCOUNTER_VALUE;
/* Check command line arguments */
check_cmd_params();
/* Register the new types and OIDs for the extensions */
if (ext_init(tbb_ext) != 0) {
ERROR("Cannot initialize TBB extensions\n");
exit(1);
}
/* Indicate SHA256 as image hash algorithm in the certificate
* extension */
md_info = EVP_sha256();
/* Get non-volatile counters NIDs */
CHECK_OID(tz_nvctr_nid, TZ_FW_NVCOUNTER_OID);
CHECK_OID(ntz_nvctr_nid, NTZ_FW_NVCOUNTER_OID);
/* Load private keys from files (or generate new ones) */
for (i = 0 ; i < NUM_KEYS ; i++) {
/* First try to load the key from disk */
if (key_load(&keys[i], &err_code)) {
/* Key loaded successfully */
continue;
}
/* Key not loaded. Check the error code */
if (err_code == KEY_ERR_MALLOC) {
/* Cannot allocate memory. Abort. */
ERROR("Malloc error while loading '%s'\n", keys[i].fn);
exit(1);
} else if (err_code == KEY_ERR_LOAD) {
/* File exists, but it does not contain a valid private
* key. Abort. */
ERROR("Error loading '%s'\n", keys[i].fn);
exit(1);
}
/* File does not exist, could not be opened or no filename was
* given */
if (new_keys) {
/* Try to create a new key */
NOTICE("Creating new key for '%s'\n", keys[i].desc);
if (!key_create(&keys[i], key_alg)) {
ERROR("Error creating key '%s'\n", keys[i].desc);
exit(1);
}
} else {
if (err_code == KEY_ERR_OPEN) {
ERROR("Error opening '%s'\n", keys[i].fn);
} else {
ERROR("Key '%s' not specified\n", keys[i].desc);
}
exit(1);
}
}
/* *********************************************************************
* BL2 certificate (Trusted Boot Firmware certificate):
* - Self-signed with OEM ROT private key
* - Extensions:
* - TrustedFirmwareNVCounter (TODO)
* - BL2 hash
**********************************************************************/
CHECK_NULL(sk, sk_X509_EXTENSION_new_null());
/* Add the NVCounter as a critical extension */
CHECK_NULL(nvctr_ext, ext_new_nvcounter(tz_nvctr_nid, EXT_CRIT,
tf_nvcounter));
sk_X509_EXTENSION_push(sk, nvctr_ext);
/* Add hash of BL2 as an extension */
if (!sha_file(certs[BL2_CERT].bin, md)) {
ERROR("Cannot calculate the hash of %s\n", certs[BL2_CERT].bin);
exit(1);
}
CHECK_OID(hash_nid, BL2_HASH_OID);
CHECK_NULL(hash_ext, ext_new_hash(hash_nid, EXT_CRIT, md_info, md,
SHA256_DIGEST_LENGTH));
sk_X509_EXTENSION_push(sk, hash_ext);
/* Create certificate. Signed with ROT key */
if (!cert_new(&certs[BL2_CERT], VAL_DAYS, 0, sk)) {
ERROR("Cannot create %s\n", certs[BL2_CERT].cn);
exit(1);
}
sk_X509_EXTENSION_free(sk);
/* *********************************************************************
* Trusted Key certificate:
* - Self-signed with OEM ROT private key
* - Extensions:
* - TrustedFirmwareNVCounter (TODO)
* - TrustedWorldPK
* - NonTrustedWorldPK
**********************************************************************/
CHECK_NULL(sk, sk_X509_EXTENSION_new_null());
CHECK_NULL(nvctr_ext, ext_new_nvcounter(tz_nvctr_nid, EXT_CRIT,
tf_nvcounter));
sk_X509_EXTENSION_push(sk, nvctr_ext);
CHECK_OID(pk_nid, TZ_WORLD_PK_OID);
CHECK_NULL(trusted_key_ext, ext_new_key(pk_nid, EXT_CRIT,
keys[TRUSTED_WORLD_KEY].key));
sk_X509_EXTENSION_push(sk, trusted_key_ext);
CHECK_OID(pk_nid, NTZ_WORLD_PK_OID);
CHECK_NULL(non_trusted_key_ext, ext_new_key(pk_nid, EXT_CRIT,
keys[NON_TRUSTED_WORLD_KEY].key));
sk_X509_EXTENSION_push(sk, non_trusted_key_ext);
if (!cert_new(&certs[TRUSTED_KEY_CERT], VAL_DAYS, 0, sk)) {
ERROR("Cannot create %s\n", certs[TRUSTED_KEY_CERT].cn);
exit(1);
}
sk_X509_EXTENSION_free(sk);
/* *********************************************************************
* BL30 Key certificate (Trusted SCP Firmware Key certificate):
* - Self-signed with Trusted World key
* - Extensions:
* - TrustedFirmwareNVCounter (TODO)
* - SCPFirmwareContentCertPK
**********************************************************************/
if (bl30_present) {
CHECK_NULL(sk, sk_X509_EXTENSION_new_null());
CHECK_NULL(nvctr_ext, ext_new_nvcounter(tz_nvctr_nid, EXT_CRIT,
tf_nvcounter));
sk_X509_EXTENSION_push(sk, nvctr_ext);
CHECK_OID(pk_nid, BL30_CONTENT_CERT_PK_OID);
CHECK_NULL(trusted_key_ext, ext_new_key(pk_nid, EXT_CRIT,
keys[BL30_KEY].key));
sk_X509_EXTENSION_push(sk, trusted_key_ext);
if (!cert_new(&certs[BL30_KEY_CERT], VAL_DAYS, 0, sk)) {
ERROR("Cannot create %s\n", certs[BL30_KEY_CERT].cn);
exit(1);
}
sk_X509_EXTENSION_free(sk);
}
/* *********************************************************************
* BL30 certificate (SCP Firmware Content certificate):
* - Signed with Trusted World Key
* - Extensions:
* - TrustedFirmwareNVCounter (TODO)
* - SCPFirmwareHash
**********************************************************************/
if (bl30_present) {
CHECK_NULL(sk, sk_X509_EXTENSION_new_null());
CHECK_NULL(nvctr_ext, ext_new_nvcounter(tz_nvctr_nid, EXT_CRIT,
tf_nvcounter));
sk_X509_EXTENSION_push(sk, nvctr_ext);
if (!sha_file(certs[BL30_CERT].bin, md)) {
ERROR("Cannot calculate the hash of %s\n",
certs[BL30_CERT].bin);
exit(1);
}
CHECK_OID(hash_nid, BL30_HASH_OID);
CHECK_NULL(hash_ext, ext_new_hash(hash_nid, EXT_CRIT, md_info,
md, SHA256_DIGEST_LENGTH));
sk_X509_EXTENSION_push(sk, hash_ext);
if (!cert_new(&certs[BL30_CERT], VAL_DAYS, 0, sk)) {
ERROR("Cannot create %s\n", certs[BL30_CERT].cn);
exit(1);
}
sk_X509_EXTENSION_free(sk);
}
/* *********************************************************************
* BL31 Key certificate (Trusted SoC Firmware Key certificate):
* - Self-signed with Trusted World key
* - Extensions:
* - TrustedFirmwareNVCounter (TODO)
* - SoCFirmwareContentCertPK
**********************************************************************/
CHECK_NULL(sk, sk_X509_EXTENSION_new_null());
CHECK_NULL(nvctr_ext, ext_new_nvcounter(tz_nvctr_nid, EXT_CRIT,
tf_nvcounter));
sk_X509_EXTENSION_push(sk, nvctr_ext);
CHECK_OID(pk_nid, BL31_CONTENT_CERT_PK_OID);
CHECK_NULL(trusted_key_ext, ext_new_key(pk_nid, EXT_CRIT,
keys[BL31_KEY].key));
sk_X509_EXTENSION_push(sk, trusted_key_ext);
if (!cert_new(&certs[BL31_KEY_CERT], VAL_DAYS, 0, sk)) {
ERROR("Cannot create %s\n", certs[BL31_KEY_CERT].cn);
exit(1);
}
sk_X509_EXTENSION_free(sk);
/* *********************************************************************
* BL31 certificate (SOC Firmware Content certificate):
* - Signed with Trusted World Key
* - Extensions:
* - TrustedFirmwareNVCounter (TODO)
* - BL31 hash
**********************************************************************/
CHECK_NULL(sk, sk_X509_EXTENSION_new_null());
CHECK_NULL(nvctr_ext, ext_new_nvcounter(tz_nvctr_nid, EXT_CRIT,
tf_nvcounter));
sk_X509_EXTENSION_push(sk, nvctr_ext);
if (!sha_file(certs[BL31_CERT].bin, md)) {
ERROR("Cannot calculate the hash of %s\n", certs[BL31_CERT].bin);
exit(1);
}
CHECK_OID(hash_nid, BL31_HASH_OID);
CHECK_NULL(hash_ext, ext_new_hash(hash_nid, EXT_CRIT, md_info, md,
SHA256_DIGEST_LENGTH));
sk_X509_EXTENSION_push(sk, hash_ext);
if (!cert_new(&certs[BL31_CERT], VAL_DAYS, 0, sk)) {
ERROR("Cannot create %s\n", certs[BL31_CERT].cn);
exit(1);
}
sk_X509_EXTENSION_free(sk);
/* *********************************************************************
* BL32 Key certificate (Trusted OS Firmware Key certificate):
* - Self-signed with Trusted World key
* - Extensions:
* - TrustedFirmwareNVCounter (TODO)
* - TrustedOSFirmwareContentCertPK
**********************************************************************/
if (bl32_present) {
CHECK_NULL(sk, sk_X509_EXTENSION_new_null());
CHECK_NULL(nvctr_ext, ext_new_nvcounter(tz_nvctr_nid, EXT_CRIT,
tf_nvcounter));
sk_X509_EXTENSION_push(sk, nvctr_ext);
CHECK_OID(pk_nid, BL32_CONTENT_CERT_PK_OID);
CHECK_NULL(trusted_key_ext, ext_new_key(pk_nid, EXT_CRIT,
keys[BL32_KEY].key));
sk_X509_EXTENSION_push(sk, trusted_key_ext);
if (!cert_new(&certs[BL32_KEY_CERT], VAL_DAYS, 0, sk)) {
ERROR("Cannot create %s\n", certs[BL32_KEY_CERT].cn);
exit(1);
}
sk_X509_EXTENSION_free(sk);
}
/* *********************************************************************
* BL32 certificate (TrustedOS Firmware Content certificate):
* - Signed with Trusted World Key
* - Extensions:
* - TrustedFirmwareNVCounter (TODO)
* - BL32 hash
**********************************************************************/
if (bl32_present) {
CHECK_NULL(sk, sk_X509_EXTENSION_new_null());
CHECK_NULL(nvctr_ext, ext_new_nvcounter(tz_nvctr_nid, EXT_CRIT,
tf_nvcounter));
sk_X509_EXTENSION_push(sk, nvctr_ext);
if (!sha_file(certs[BL32_CERT].bin, md)) {
ERROR("Cannot calculate the hash of %s\n",
certs[BL32_CERT].bin);
exit(1);
}
CHECK_OID(hash_nid, BL32_HASH_OID);
CHECK_NULL(hash_ext, ext_new_hash(hash_nid, EXT_CRIT, md_info,
md, SHA256_DIGEST_LENGTH));
sk_X509_EXTENSION_push(sk, hash_ext);
if (!cert_new(&certs[BL32_CERT], VAL_DAYS, 0, sk)) {
ERROR("Cannot create %s\n", certs[BL32_CERT].cn);
exit(1);
}
sk_X509_EXTENSION_free(sk);
}
/* *********************************************************************
* BL33 Key certificate (Non Trusted Firmware Key certificate):
* - Self-signed with Non Trusted World key
* - Extensions:
* - NonTrustedFirmwareNVCounter (TODO)
* - NonTrustedFirmwareContentCertPK
**********************************************************************/
CHECK_NULL(sk, sk_X509_EXTENSION_new_null());
CHECK_NULL(nvctr_ext, ext_new_nvcounter(ntz_nvctr_nid, EXT_CRIT,
non_tf_nvcounter));
sk_X509_EXTENSION_push(sk, nvctr_ext);
CHECK_OID(pk_nid, BL33_CONTENT_CERT_PK_OID);
CHECK_NULL(non_trusted_key_ext, ext_new_key(pk_nid, EXT_CRIT,
keys[BL33_KEY].key));
sk_X509_EXTENSION_push(sk, non_trusted_key_ext);
if (!cert_new(&certs[BL33_KEY_CERT], VAL_DAYS, 0, sk)) {
ERROR("Cannot create %s\n", certs[BL33_KEY_CERT].cn);
exit(1);
}
sk_X509_EXTENSION_free(sk);
/* *********************************************************************
* BL33 certificate (Non-Trusted World Content certificate):
* - Signed with Non-Trusted World Key
* - Extensions:
* - NonTrustedFirmwareNVCounter (TODO)
* - BL33 hash
**********************************************************************/
CHECK_NULL(sk, sk_X509_EXTENSION_new_null());
CHECK_NULL(nvctr_ext, ext_new_nvcounter(ntz_nvctr_nid, EXT_CRIT,
non_tf_nvcounter));
sk_X509_EXTENSION_push(sk, nvctr_ext);
if (!sha_file(certs[BL33_CERT].bin, md)) {
ERROR("Cannot calculate the hash of %s\n", certs[BL33_CERT].bin);
exit(1);
}
CHECK_OID(hash_nid, BL33_HASH_OID);
CHECK_NULL(hash_ext, ext_new_hash(hash_nid, EXT_CRIT, md_info, md,
SHA256_DIGEST_LENGTH));
sk_X509_EXTENSION_push(sk, hash_ext);
if (!cert_new(&certs[BL33_CERT], VAL_DAYS, 0, sk)) {
ERROR("Cannot create %s\n", certs[BL33_CERT].cn);
exit(1);
}
sk_X509_EXTENSION_free(sk);
/* Print the certificates */
if (print_cert) {
for (i = 0 ; i < NUM_CERTIFICATES ; i++) {
if (!certs[i].x) {
continue;
}
printf("\n\n=====================================\n\n");
X509_print_fp(stdout, certs[i].x);
}
}
/* Save created certificates to files */
for (i = 0 ; i < NUM_CERTIFICATES ; i++) {
if (certs[i].x && certs[i].fn) {
file = fopen(certs[i].fn, "w");
if (file != NULL) {
i2d_X509_fp(file, certs[i].x);
fclose(file);
} else {
ERROR("Cannot create file %s\n", certs[i].fn);
}
}
}
/* Save keys */
if (save_keys) {
for (i = 0 ; i < NUM_KEYS ; i++) {
if (!key_store(&keys[i])) {
ERROR("Cannot save %s\n", keys[i].desc);
}
}
}
X509_EXTENSION_free(hash_ext);
X509_EXTENSION_free(nvctr_ext);
X509_EXTENSION_free(trusted_key_ext);
X509_EXTENSION_free(non_trusted_key_ext);
#ifndef OPENSSL_NO_ENGINE
ENGINE_cleanup();
#endif
CRYPTO_cleanup_all_ex_data();
return 0;
}
static void john_load(void)
{
struct list_entry *current;
#ifndef _MSC_VER
umask(077);
#endif
if (options.flags & FLG_EXTERNAL_CHK)
ext_init(options.external, NULL);
if (options.flags & FLG_MAKECHR_CHK) {
options.loader.flags |= DB_CRACKED;
ldr_init_database(&database, &options.loader);
if (options.flags & FLG_PASSWD) {
ldr_show_pot_file(&database, pers_opts.activepot);
database.options->flags |= DB_PLAINTEXTS;
if ((current = options.passwd->head))
do {
ldr_show_pw_file(&database, current->data);
} while ((current = current->next));
} else {
database.options->flags |= DB_PLAINTEXTS;
ldr_show_pot_file(&database, pers_opts.activepot);
}
return;
}
if (options.flags & FLG_STDOUT) {
ldr_init_database(&database, &options.loader);
database.format = &dummy_format;
memset(&dummy_format, 0, sizeof(dummy_format));
dummy_format.params.plaintext_length = options.length;
dummy_format.params.flags = FMT_CASE | FMT_8_BIT;
if (pers_opts.report_utf8 || pers_opts.target_enc == UTF_8)
dummy_format.params.flags |= FMT_UTF8;
dummy_format.params.label = "stdout";
dummy_format.methods.clear_keys = &fmt_default_clear_keys;
pers_opts.target_enc = pers_opts.input_enc;
john_load_conf_db();
}
if (options.flags & FLG_PASSWD) {
int total;
#if FMT_MAIN_VERSION > 11
int i = 0;
#endif
if (options.flags & FLG_SHOW_CHK) {
options.loader.flags |= DB_CRACKED;
ldr_init_database(&database, &options.loader);
ldr_show_pot_file(&database, pers_opts.activepot);
if ((current = options.passwd->head))
do {
ldr_show_pw_file(&database, current->data);
} while ((current = current->next));
if (john_main_process)
printf("%s%d password hash%s cracked, %d left\n",
database.guess_count ? "\n" : "",
database.guess_count,
database.guess_count != 1 ? "es" : "",
database.password_count -
database.guess_count);
return;
}
if (options.flags & (FLG_SINGLE_CHK | FLG_BATCH_CHK) &&
status.pass <= 1)
options.loader.flags |= DB_WORDS;
else
if (mem_saving_level) {
options.loader.flags &= ~DB_LOGIN;
options.max_wordfile_memory = 1;
}
ldr_init_database(&database, &options.loader);
if ((current = options.passwd->head))
do {
ldr_load_pw_file(&database, current->data);
} while ((current = current->next));
/* Process configuration options that depend on db/format */
john_load_conf_db();
if ((options.flags & FLG_CRACKING_CHK) &&
database.password_count) {
log_init(LOG_NAME, NULL, options.session);
if (status_restored_time)
log_event("Continuing an interrupted session");
else
log_event("Starting a new session");
log_event("Loaded a total of %s", john_loaded_counts());
/* make sure the format is properly initialized */
#if HAVE_OPENCL
if (!(options.gpu_devices->count && options.fork &&
strstr(database.format->params.label, "-opencl")))
#endif
fmt_init(database.format);
if (john_main_process)
printf("Loaded %s (%s%s%s [%s])\n",
john_loaded_counts(),
database.format->params.label,
database.format->params.format_name[0] ? ", " : "",
database.format->params.format_name,
database.format->params.algorithm_name);
// Tell External our max length
if (options.flags & FLG_EXTERNAL_CHK)
ext_init(options.external, &database);
}
total = database.password_count;
ldr_load_pot_file(&database, pers_opts.activepot);
ldr_fix_database(&database);
if (!database.password_count) {
log_discard();
if (john_main_process)
printf("No password hashes %s (see FAQ)\n",
total ? "left to crack" : "loaded");
#if FMT_MAIN_VERSION > 11
/* skip tunable cost reporting if no hashes were loaded */
i = FMT_TUNABLE_COSTS;
#endif
} else
if (database.password_count < total) {
log_event("Remaining %s", john_loaded_counts());
if (john_main_process)
printf("Remaining %s\n", john_loaded_counts());
}
#if FMT_MAIN_VERSION > 11
for ( ; i < FMT_TUNABLE_COSTS && database.format->methods.tunable_cost_value[i] != NULL; i++) {
if (database.min_cost[i] < database.max_cost[i]) {
log_event("Loaded hashes with cost %d (%s)"
" varying from %u to %u",
i+1, database.format->params.tunable_cost_name[i],
database.min_cost[i], database.max_cost[i]);
if (john_main_process)
printf("Loaded hashes with cost %d (%s)"
" varying from %u to %u\n",
i+1, database.format->params.tunable_cost_name[i],
database.min_cost[i], database.max_cost[i]);
}
else { // if (database.min_cost[i] == database.max_cost[i]) {
log_event("Cost %d (%s) is %u for all loaded hashes",
i+1, database.format->params.tunable_cost_name[i],
database.min_cost[i]);
}
}
#endif
if ((options.flags & FLG_PWD_REQ) && !database.salts) exit(0);
if (options.regen_lost_salts)
build_fake_salts_for_regen_lost(database.salts);
}
/* Nefarious hack and memory leak. Among other problems, we'd want
ldr_drop_database() after this, but it's built with mem_alloc_tiny()
so it's not trivial. Works like a champ though. */
if (options.flags & FLG_LOOPBACK_CHK &&
database.format != &fmt_LM) {
struct db_main loop_db;
struct fmt_main *save_list = fmt_list;
char *save_pot = pers_opts.activepot;
fmt_list = &fmt_LM;
options.loader.flags |= DB_CRACKED;
ldr_init_database(&loop_db, &options.loader);
pers_opts.activepot = options.wordlist ?
options.wordlist : pers_opts.activepot;
ldr_show_pot_file(&loop_db, pers_opts.activepot);
loop_db.options->flags |= DB_PLAINTEXTS;
if ((current = options.passwd->head))
do {
ldr_show_pw_file(&loop_db, current->data);
} while ((current = current->next));
if (loop_db.plaintexts->count) {
log_event("- Reassembled %d split passwords for "
"loopback", loop_db.plaintexts->count);
if (john_main_process && options.verbosity > 3)
fprintf(stderr,
"Reassembled %d split passwords for "
"loopback\n",
loop_db.plaintexts->count);
}
database.plaintexts = loop_db.plaintexts;
options.loader.flags &= ~DB_CRACKED;
pers_opts.activepot = save_pot;
fmt_list = save_list;
}
#ifdef _OPENMP
john_omp_show_info();
#endif
if (options.node_count) {
if (options.node_min != options.node_max) {
log_event("- Node numbers %u-%u of %u%s",
options.node_min, options.node_max,
#ifndef HAVE_MPI
options.node_count, options.fork ? " (fork)" : "");
#else
options.node_count, options.fork ? " (fork)" :
mpi_p > 1 ? " (MPI)" : "");
#endif
if (john_main_process)
fprintf(stderr, "Node numbers %u-%u of %u%s\n",
options.node_min, options.node_max,
#ifndef HAVE_MPI
options.node_count, options.fork ? " (fork)" : "");
#else
options.node_count, options.fork ? " (fork)" :
mpi_p > 1 ? " (MPI)" : "");
#endif
} else {
static void john_load(void)
{
struct list_entry *current;
#ifndef _MSC_VER
umask(077);
#endif
if (options.flags & FLG_EXTERNAL_CHK)
ext_init(options.external, NULL);
if (options.flags & FLG_MAKECHR_CHK) {
options.loader.flags |= DB_CRACKED;
ldr_init_database(&database, &options.loader);
if (options.flags & FLG_PASSWD) {
ldr_show_pot_file(&database, options.loader.activepot);
database.options->flags |= DB_PLAINTEXTS;
if ((current = options.passwd->head))
do {
ldr_show_pw_file(&database, current->data);
} while ((current = current->next));
} else {
database.options->flags |= DB_PLAINTEXTS;
ldr_show_pot_file(&database, options.loader.activepot);
}
return;
}
if (options.flags & FLG_STDOUT) {
ldr_init_database(&database, &options.loader);
database.format = &dummy_format;
memset(&dummy_format, 0, sizeof(dummy_format));
dummy_format.params.plaintext_length = options.length;
dummy_format.params.flags = FMT_CASE | FMT_8_BIT;
}
if (options.flags & FLG_PASSWD) {
int total;
if (options.flags & FLG_SHOW_CHK) {
options.loader.flags |= DB_CRACKED;
ldr_init_database(&database, &options.loader);
ldr_show_pot_file(&database, options.loader.activepot);
if ((current = options.passwd->head))
do {
ldr_show_pw_file(&database, current->data);
} while ((current = current->next));
printf("%s%d password hash%s cracked, %d left\n",
database.guess_count ? "\n" : "",
database.guess_count,
database.guess_count != 1 ? "es" : "",
database.password_count -
database.guess_count);
return;
}
if (options.flags & (FLG_SINGLE_CHK | FLG_BATCH_CHK) &&
status.pass <= 1)
options.loader.flags |= DB_WORDS;
else
if (mem_saving_level) {
options.loader.flags &= ~DB_LOGIN;
options.loader.max_wordfile_memory = 0;
}
ldr_init_database(&database, &options.loader);
if ((current = options.passwd->head))
do {
ldr_load_pw_file(&database, current->data);
} while ((current = current->next));
// Unicode (UTF-16) formats may lack UTF-8 support (initially)
if (options.utf8 && database.password_count &&
database.format->params.flags & FMT_UNICODE &&
!(database.format->params.flags & FMT_UTF8)) {
fprintf(stderr, "This format does not yet support UTF-8 conversion\n");
error();
}
if ((options.flags & FLG_CRACKING_CHK) &&
database.password_count) {
log_init(LOG_NAME, NULL, options.session);
if (status_restored_time)
log_event("Continuing an interrupted session");
else
log_event("Starting a new session");
log_event("Loaded a total of %s", john_loaded_counts());
/* make sure the format is properly initialized */
fmt_init(database.format);
printf("Loaded %s (%s [%s])\n",
john_loaded_counts(),
database.format->params.format_name,
database.format->params.algorithm_name);
// Tell External our max length
if (options.flags & FLG_EXTERNAL_CHK)
ext_init(options.external, &database);
}
if (database.password_count) {
if (database.format->params.flags & FMT_UNICODE)
options.store_utf8 = cfg_get_bool(SECTION_OPTIONS,
NULL, "UnicodeStoreUTF8", 0);
else
options.store_utf8 = cfg_get_bool(SECTION_OPTIONS,
NULL, "CPstoreUTF8", 0);
}
if (!options.utf8) {
if (options.report_utf8 && options.log_passwords)
log_event("- Passwords in this logfile are UTF-8 encoded");
if (options.store_utf8)
log_event("- Passwords will be stored UTF-8 encoded in .pot file");
}
total = database.password_count;
ldr_load_pot_file(&database, options.loader.activepot);
ldr_fix_database(&database);
if (!database.password_count) {
log_discard();
printf("No password hashes %s (see FAQ)\n",
total ? "left to crack" : "loaded");
} else
if (database.password_count < total) {
log_event("Remaining %s", john_loaded_counts());
printf("Remaining %s\n", john_loaded_counts());
}
if (options.regen_lost_salts) {
extern void build_fake_salts_for_regen_lost(struct db_salt *);
build_fake_salts_for_regen_lost(database.salts);
}
if ((options.flags & FLG_PWD_REQ) && !database.salts) exit(0);
}
}
static void john_load(void)
{
struct list_entry *current;
#if !defined (_MSC_VER)
umask(077);
#endif
if ((options.flags & FLG_EXTERNAL_CHK) && FLG_GIJOHN_CHK)
ext_init(options.external);
if ((options.flags & FLG_GIJOHN_CHK) && FLG_EXTERNAL_CHK)
{
ext_init("gijohn");
}
if (options.flags & FLG_MAKECHR_CHK) {
options.loader.flags |= DB_CRACKED;
ldr_init_database(&database, &options.loader);
if (options.flags & FLG_PASSWD) {
ldr_show_pot_file(&database, options.loader.activepot);
database.options->flags |= DB_PLAINTEXTS;
if ((current = options.passwd->head))
do {
ldr_show_pw_file(&database, current->data);
} while ((current = current->next));
} else {
database.options->flags |= DB_PLAINTEXTS;
ldr_show_pot_file(&database, options.loader.activepot);
}
return;
}
if (options.flags & FLG_STDOUT) {
ldr_init_database(&database, &options.loader);
database.format = &dummy_format;
memset(&dummy_format, 0, sizeof(dummy_format));
dummy_format.params.plaintext_length = options.length;
dummy_format.params.flags = FMT_CASE | FMT_8_BIT;
}
if (options.flags & FLG_PASSWD) {
if (options.flags & FLG_SHOW_CHK) {
options.loader.flags |= DB_CRACKED;
ldr_init_database(&database, &options.loader);
ldr_show_pot_file(&database, options.loader.activepot);
if ((current = options.passwd->head))
do {
ldr_show_pw_file(&database, current->data);
} while ((current = current->next));
printf("%s%d password hash%s cracked, %d left\n",
database.guess_count ? "\n" : "",
database.guess_count,
database.guess_count != 1 ? "es" : "",
database.password_count -
database.guess_count);
return;
}
if (options.flags & (FLG_SINGLE_CHK | FLG_BATCH_CHK) &&
status.pass <= 1)
options.loader.flags |= DB_WORDS;
else
if (mem_saving_level) {
options.loader.flags &= ~DB_LOGIN;
options.loader.max_wordfile_memory = 0;
}
ldr_init_database(&database, &options.loader);
if ((current = options.passwd->head))
do {
ldr_load_pw_file(&database, current->data);
} while ((current = current->next));
if ((options.flags & FLG_CRACKING_CHK) &&
database.password_count) {
log_init(LOG_NAME, NULL, options.session);
if (status_restored_time)
log_event("Continuing an interrupted session");
else
log_event("Starting a new session");
log_event("Loaded a total of %s", john_loaded_counts());
}
ldr_load_pot_file(&database, options.loader.activepot);
ldr_fix_database(&database);
if (database.password_count) {
log_event("Remaining %s", john_loaded_counts());
printf("Loaded %s (%s [%s])\n",
john_loaded_counts(),
database.format->params.format_name,
database.format->params.algorithm_name);
} else {
log_discard();
puts("No password hashes loaded");
}
if ((options.flags & FLG_PWD_REQ) && !database.salts) exit(0);
}
}