Added new option: --hash-info

docs/changes.txt

@@ -15,6 +15,12 @@
 - Added hash-mode: RSA/DSA/EC/OPENSSH Private Keys
 - Added hash-mode: sha1(sha1($pass).$salt)
 
+##
+## Features
+##
+
+- Added option --hash-info to print generic information on hash types supported
+
 ##
 ## Bugs
 ##

include/terminal.h

@@ -41,6 +41,8 @@ int tty_fix(void);
 
 void compress_terminal_line_length (char *out_buf, const size_t keep_from_beginning, const size_t keep_from_end);
 
+void hash_info                          (hashcat_ctx_t *hashcat_ctx);
+
 void example_hashes                     (hashcat_ctx_t *hashcat_ctx);
 
 void backend_info                       (hashcat_ctx_t *hashcat_ctx);

include/types.h

@@ -595,6 +595,7 @@ typedef enum user_options_defaults
   FORCE                    = false,
   HWMON_DISABLE            = false,
   HWMON_TEMP_ABORT         = 90,
+  HASH_INFO                = false,
   HASH_MODE                = 0,
   HCCAPX_MESSAGE_PAIR      = 0,
   HEX_CHARSET              = false,
@@ -700,6 +701,7 @@ typedef enum user_options_map
   IDX_FORCE                     = 0xff15,
   IDX_HWMON_DISABLE             = 0xff16,
   IDX_HWMON_TEMP_ABORT          = 0xff17,
+  IDX_HASH_INFO                 = 0xff4d, // must be changed before merging
   IDX_HASH_MODE                 = 'm',
   IDX_HCCAPX_MESSAGE_PAIR       = 0xff18,
   IDX_HELP                      = 'h',
@@ -1941,6 +1943,7 @@ typedef struct user_options
   bool         example_hashes;
   bool         force;
   bool         hwmon_disable;
+  bool         hash_info;
   bool         hex_charset;
   bool         hex_salt;
   bool         hex_wordlist;

src/Makefile

@@ -4,7 +4,7 @@
 ##
 
 SHARED                  ?= 0
-DEBUG                   := 0
+DEBUG                   := 1
 PRODUCTION              := 0
 PRODUCTION_VERSION      := v6.1.1
 ENABLE_CUBIN            ?= 1

src/backend.c

@@ -4956,6 +4956,7 @@ int backend_ctx_init (hashcat_ctx_t *hashcat_ctx)
 
   backend_ctx->enabled = false;
 
+  if (user_options->hash_info      == true) return 0;
   if (user_options->example_hashes == true) return 0;
   if (user_options->keyspace       == true) return 0;
   if (user_options->left           == true) return 0;

src/bitmap.c

@@ -79,6 +79,7 @@ int bitmap_ctx_init (hashcat_ctx_t *hashcat_ctx)
 
   bitmap_ctx->enabled = false;
 
+  if (user_options->hash_info      == true) return 0;
   if (user_options->example_hashes == true) return 0;
   if (user_options->keyspace       == true) return 0;
   if (user_options->left           == true) return 0;

src/combinator.c

@@ -19,6 +19,7 @@ int combinator_ctx_init (hashcat_ctx_t *hashcat_ctx)
 
   combinator_ctx->enabled = false;
 
+  if (user_options->hash_info      == true) return 0;
   if (user_options->example_hashes == true) return 0;
   if (user_options->left           == true) return 0;
   if (user_options->backend_info   == true) return 0;

src/cpt.c

@@ -15,6 +15,7 @@ int cpt_ctx_init (hashcat_ctx_t *hashcat_ctx)
 
   cpt_ctx->enabled = false;
 
+  if (user_options->hash_info      == true) return 0;
   if (user_options->example_hashes == true) return 0;
   if (user_options->keyspace       == true) return 0;
   if (user_options->left           == true) return 0;

src/debugfile.c

@@ -87,6 +87,7 @@ int debugfile_init (hashcat_ctx_t *hashcat_ctx)
   debugfile_ctx->enabled = false;
 
   if (user_options->benchmark      == true) return 0;
+  if (user_options->hash_info      == true) return 0;
   if (user_options->example_hashes == true) return 0;
   if (user_options->keyspace       == true) return 0;
   if (user_options->left           == true) return 0;

src/dictstat.c

@@ -57,6 +57,7 @@ int dictstat_init (hashcat_ctx_t *hashcat_ctx)
   dictstat_ctx->enabled = false;
 
   if (user_options->benchmark      == true) return 0;
+  if (user_options->hash_info      == true) return 0;
   if (user_options->example_hashes == true) return 0;
   if (user_options->keyspace       == true) return 0;
   if (user_options->left           == true) return 0;

src/hashes.c

@@ -901,6 +901,9 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
 
     hashes_cnt = 1;
   }
+  else if (user_options->hash_info == true)
+  {
+  }
   else if (user_options->example_hashes == true)
   {
   }

src/hwmon.c

@@ -2225,6 +2225,7 @@ int hwmon_ctx_init (hashcat_ctx_t *hashcat_ctx)
   return 0;
   #endif // WITH_HWMON
 
+  if (user_options->hash_info       == true) return 0;
   if (user_options->example_hashes  == true) return 0;
   if (user_options->keyspace        == true) return 0;
   if (user_options->left            == true) return 0;

src/induct.c

@@ -40,6 +40,7 @@ int induct_ctx_init (hashcat_ctx_t *hashcat_ctx)
   induct_ctx->enabled = false;
 
   if (user_options->benchmark      == true) return 0;
+  if (user_options->hash_info      == true) return 0;
   if (user_options->example_hashes == true) return 0;
   if (user_options->keyspace       == true) return 0;
   if (user_options->left           == true) return 0;

src/interface.c

@@ -333,7 +333,7 @@ int hashconfig_init (hashcat_ctx_t *hashcat_ctx)
 
     hashconfig->has_optimized_kernel = hc_path_read (source_file);
 
-    if (user_options->example_hashes == false)
+    if (user_options->example_hashes == false && user_options->hash_info == false)
     {
       if (user_options->optimized_kernel_enable == true)
       {

src/loopback.c

@@ -61,6 +61,7 @@ int loopback_init (hashcat_ctx_t *hashcat_ctx)
   loopback_ctx->enabled = false;
 
   if (user_options->benchmark      == true) return 0;
+  if (user_options->hash_info      == true) return 0;
   if (user_options->example_hashes == true) return 0;
   if (user_options->keyspace       == true) return 0;
   if (user_options->left           == true) return 0;

src/main.c

@@ -184,8 +184,13 @@ static void main_outerloop_starting (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MA
 
   status_ctx->shutdown_outer = false;
 
-  if ((user_options->example_hashes == false) && (user_options->keyspace == false) && (user_options->stdout_flag == false) && (user_options->backend_info == false) && (user_options->speed_only == false))
+  if (user_options->hash_info      == true) return;
-  {
+  if (user_options->example_hashes == true) return;
+  if (user_options->keyspace       == true) return;
+  if (user_options->stdout_flag    == true) return;
+  if (user_options->backend_info   == true) return;
+  if (user_options->speed_only     == true) return;
+
   if ((user_options_extra->wordlist_mode == WL_MODE_FILE) || (user_options_extra->wordlist_mode == WL_MODE_MASK))
   {
     // see thread_keypress() how to access status information
@@ -194,7 +199,6 @@ static void main_outerloop_starting (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MA
 
     hashcat_user->outer_threads_cnt++;
   }
-  }
 }
 
 static void main_outerloop_finished (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const void *buf, MAYBE_UNUSED const size_t len)
@@ -257,6 +261,7 @@ static void main_cracker_finished (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYB
   const user_options_t       *user_options       = hashcat_ctx->user_options;
   const user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra;
 
+  if (user_options->hash_info       == true) return;
   if (user_options->example_hashes  == true) return;
   if (user_options->keyspace        == true) return;
   if (user_options->backend_info    == true) return;
@@ -1157,6 +1162,12 @@ int main (int argc, char **argv)
 
       rc_final = 0;
     }
+    else if (user_options->hash_info == true)
+    {
+      hash_info (hashcat_ctx);
+
+      rc_final = 0;
+    }
     else if (user_options->example_hashes == true)
     {
       example_hashes (hashcat_ctx);

src/mpsp.c

@@ -1391,6 +1391,7 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
 
   mask_ctx->enabled = false;
 
+  if (user_options->hash_info      == true) return 0;
   if (user_options->example_hashes == true) return 0;
   if (user_options->left           == true) return 0;
   if (user_options->backend_info   == true) return 0;

src/outfile_check.c

@@ -360,6 +360,7 @@ int outcheck_ctx_init (hashcat_ctx_t *hashcat_ctx)
 
   if (user_options->keyspace       == true) return 0;
   if (user_options->benchmark      == true) return 0;
+  if (user_options->hash_info      == true) return 0;
   if (user_options->example_hashes == true) return 0;
   if (user_options->speed_only     == true) return 0;
   if (user_options->progress_only  == true) return 0;

src/potfile.c

@@ -111,6 +111,7 @@ int potfile_init (hashcat_ctx_t *hashcat_ctx)
   potfile_ctx->enabled = false;
 
   if (user_options->benchmark       == true) return 0;
+  if (user_options->hash_info       == true) return 0;
   if (user_options->example_hashes  == true) return 0;
   if (user_options->keyspace        == true) return 0;
   if (user_options->backend_info    == true) return 0;

src/restore.c

@@ -299,6 +299,7 @@ int restore_ctx_init (hashcat_ctx_t *hashcat_ctx, int argc, char **argv)
   restore_ctx->enabled = false;
 
   if (user_options->benchmark       == true) return 0;
+  if (user_options->hash_info       == true) return 0;
   if (user_options->example_hashes  == true) return 0;
   if (user_options->keyspace        == true) return 0;
   if (user_options->left            == true) return 0;

src/straight.c

@@ -261,6 +261,7 @@ int straight_ctx_init (hashcat_ctx_t *hashcat_ctx)
 
   straight_ctx->enabled = false;
 
+  if (user_options->hash_info      == true) return 0;
   if (user_options->example_hashes == true) return 0;
   if (user_options->left           == true) return 0;
   if (user_options->backend_info   == true) return 0;

src/terminal.c

@@ -537,6 +537,129 @@ void compress_terminal_line_length (char *out_buf, const size_t keep_from_beginn
   *ptr1 = 0;
 }
 
+void hash_info_single (hashcat_ctx_t *hashcat_ctx, user_options_t *user_options)
+{
+  if (hashconfig_init (hashcat_ctx) == 0)
+  {
+    hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
+
+    event_log_info (hashcat_ctx, "Hash mode #%u", hashconfig->hash_mode);
+    event_log_info (hashcat_ctx, "  Name................: %s", hashconfig->hash_name);
+    event_log_info (hashcat_ctx, "  Category............: %s", strhashcategory (hashconfig->hash_category));
+    event_log_info (hashcat_ctx, "  Password.Len.Min....: %d", hashconfig->pw_min);
+    event_log_info (hashcat_ctx, "  Password.Len.Max....: %d", hashconfig->pw_max);
+
+    if (hashconfig->is_salted == true)
+    {
+      event_log_info (hashcat_ctx, "  Salt.Len.Min........: %d", hashconfig->salt_min);
+      event_log_info (hashcat_ctx, "  Salt.Len.Max........: %d", hashconfig->salt_max);
+    }
+
+    event_log_info (hashcat_ctx, "  Hashes.Count.Min....: %d", hashconfig->hashes_count_min);
+    event_log_info (hashcat_ctx, "  Hashes.Count.Max....: %u", hashconfig->hashes_count_max);
+
+    char kernel_types[15];
+
+    memset (kernel_types, 0, sizeof (kernel_types));
+
+    if (hashconfig->has_pure_kernel) strncat (kernel_types, "pure ", 5);
+    if (hashconfig->has_optimized_kernel) strncat (kernel_types, "optimized", 9);
+
+    event_log_info (hashcat_ctx, "  Kernel.Type(s)......: %s", kernel_types);
+
+    if ((hashconfig->st_hash != NULL) && (hashconfig->st_pass != NULL))
+    {
+      if (hashconfig->opts_type & OPTS_TYPE_BINARY_HASHFILE)
+      {
+        event_log_info (hashcat_ctx, "  Example.Hash.Format.: hex-encoded");
+        event_log_info (hashcat_ctx, "  Example.Hash........: %s", hashconfig->st_hash);
+      }
+      else
+      {
+        event_log_info (hashcat_ctx, "  Example.Hash.Format.: plain");
+        event_log_info (hashcat_ctx, "  Example.Hash........: %s", hashconfig->st_hash);
+      }
+
+      if (need_hexify ((const u8 *) hashconfig->st_pass, strlen (hashconfig->st_pass), user_options->separator, false))
+      {
+        char tmp_buf[HCBUFSIZ_LARGE] = { 0 };
+
+        int tmp_len = 0;
+
+        tmp_buf[tmp_len++] = '$';
+        tmp_buf[tmp_len++] = 'H';
+        tmp_buf[tmp_len++] = 'E';
+        tmp_buf[tmp_len++] = 'X';
+        tmp_buf[tmp_len++] = '[';
+
+        exec_hexify ((const u8 *) hashconfig->st_pass, strlen (hashconfig->st_pass), (u8 *) tmp_buf + tmp_len);
+
+        tmp_len += strlen (hashconfig->st_pass) * 2;
+
+        tmp_buf[tmp_len++] = ']';
+        tmp_buf[tmp_len++] = 0;
+
+        event_log_info (hashcat_ctx, "  Example.Pass........: %s", tmp_buf);
+      }
+      else
+      {
+        event_log_info (hashcat_ctx, "  Example.Pass........: %s", hashconfig->st_pass);
+      }
+    }
+    else
+    {
+      event_log_info (hashcat_ctx, "  Example.Hash.Format.: N/A");
+      event_log_info (hashcat_ctx, "  Example.Hash........: N/A");
+      event_log_info (hashcat_ctx, "  Example.Pass........: N/A");
+    }
+
+    if (hashconfig->benchmark_mask != NULL)
+    {
+      event_log_info (hashcat_ctx, "  Benchmark.Mask......: %s", hashconfig->benchmark_mask);
+    }
+    else
+    {
+      event_log_info (hashcat_ctx, "  Benchmark.Mask......: N/A");
+    }
+
+    event_log_info (hashcat_ctx, NULL);
+  }
+
+  hashconfig_destroy (hashcat_ctx);
+}
+
+void hash_info (hashcat_ctx_t *hashcat_ctx)
+{
+  folder_config_t *folder_config = hashcat_ctx->folder_config;
+  user_options_t  *user_options  = hashcat_ctx->user_options;
+
+  event_log_info (hashcat_ctx, "Hash Info:");
+  event_log_info (hashcat_ctx, "==========");
+  event_log_info (hashcat_ctx, NULL);
+
+  if (user_options->hash_mode_chgd == true)
+  {
+    hash_info_single (hashcat_ctx, user_options);
+  }
+  else
+  {
+    char *modulefile = (char *) hcmalloc (HCBUFSIZ_TINY);
+
+    for (int i = 0; i < MODULE_HASH_MODES_MAXIMUM; i++)
+    {
+      user_options->hash_mode = i;
+
+      module_filename (folder_config, i, modulefile, HCBUFSIZ_TINY);
+
+      if (hc_path_exist (modulefile) == false) continue;
+
+      hash_info_single (hashcat_ctx, user_options);
+    }
+
+    hcfree (modulefile);
+  }
+}
+
 void example_hashes (hashcat_ctx_t *hashcat_ctx)
 {
   folder_config_t *folder_config = hashcat_ctx->folder_config;

src/tuningdb.c

@@ -54,6 +54,7 @@ int tuning_db_init (hashcat_ctx_t *hashcat_ctx)
 
   tuning_db->enabled = false;
 
+  if (user_options->hash_info      == true) return 0;
   if (user_options->example_hashes == true) return 0;
   if (user_options->keyspace       == true) return 0;
   if (user_options->left           == true) return 0;

src/usage.c

@@ -89,6 +89,7 @@ static const char *const USAGE_BIG_PRE_HASHMODES[] =
   "     --bitmap-max               | Num  | Sets maximum bits allowed for bitmaps to X           | --bitmap-max=24",
   "     --cpu-affinity             | Str  | Locks to CPU devices, separated with commas          | --cpu-affinity=1,2,3",
   "     --hook-threads             | Num  | Sets number of threads for a hook (per compute unit) | --hook-threads=8",
+  "     --hash-info                |      | Show information for each hash-mode                  |",
   "     --example-hashes           |      | Show an example hash for each hash-mode              |",
   "     --backend-ignore-cuda      |      | Do not try to open CUDA interface on startup         |",
   "     --backend-ignore-opencl    |      | Do not try to open OpenCL interface on startup       |",

src/user_options.c

@@ -55,6 +55,7 @@ static const struct option long_options[] =
   {"generate-rules-seed",       required_argument, NULL, IDX_RP_GEN_SEED},
   {"hwmon-disable",             no_argument,       NULL, IDX_HWMON_DISABLE},
   {"hwmon-temp-abort",          required_argument, NULL, IDX_HWMON_TEMP_ABORT},
+  {"hash-info",                 no_argument,       NULL, IDX_HASH_INFO},
   {"hash-type",                 required_argument, NULL, IDX_HASH_MODE},
   {"hccapx-message-pair",       required_argument, NULL, IDX_HCCAPX_MESSAGE_PAIR},
   {"help",                      no_argument,       NULL, IDX_HELP},
@@ -188,6 +189,7 @@ int user_options_init (hashcat_ctx_t *hashcat_ctx)
   user_options->force                     = FORCE;
   user_options->hwmon_disable             = HWMON_DISABLE;
   user_options->hwmon_temp_abort          = HWMON_TEMP_ABORT;
+  user_options->hash_info                 = HASH_INFO;
   user_options->hash_mode                 = HASH_MODE;
   user_options->hccapx_message_pair       = HCCAPX_MESSAGE_PAIR;
   user_options->hex_charset               = HEX_CHARSET;
@@ -380,6 +382,7 @@ int user_options_getopt (hashcat_ctx_t *hashcat_ctx, int argc, char **argv)
       case IDX_ENCODING_TO:               user_options->encoding_to               = optarg;                          break;
       case IDX_INDUCTION_DIR:             user_options->induction_dir             = optarg;                          break;
       case IDX_OUTFILE_CHECK_DIR:         user_options->outfile_check_dir         = optarg;                          break;
+      case IDX_HASH_INFO:                 user_options->hash_info                 = true;                            break;
       case IDX_EXAMPLE_HASHES:            user_options->example_hashes            = true;                            break;
       case IDX_FORCE:                     user_options->force                     = true;                            break;
       case IDX_SELF_TEST_DISABLE:         user_options->self_test_disable         = true;                            break;
@@ -1391,6 +1394,13 @@ int user_options_sanity (hashcat_ctx_t *hashcat_ctx)
       show_error = false;
     }
   }
+  else if (user_options->hash_info == true)
+  {
+    if (user_options->hc_argc == 0)
+    {
+      show_error = false;
+    }
+  }
   else if (user_options->example_hashes == true)
   {
     if (user_options->hc_argc == 0)
@@ -1589,6 +1599,11 @@ void user_options_session_auto (hashcat_ctx_t *hashcat_ctx)
       user_options->session = "benchmark";
     }
 
+    if (user_options->hash_info == true)
+    {
+      user_options->session = "hash_info";
+    }
+
     if (user_options->example_hashes == true)
     {
       user_options->session = "example_hashes";
@@ -1668,6 +1683,7 @@ void user_options_preprocess (hashcat_ctx_t *hashcat_ctx)
   }
 
   if (user_options->example_hashes  == true
+   || user_options->hash_info       == true
    || user_options->backend_info    == true
    || user_options->keyspace        == true
    || user_options->speed_only      == true
@@ -1723,6 +1739,11 @@ void user_options_preprocess (hashcat_ctx_t *hashcat_ctx)
     }
   }
 
+  if (user_options->hash_info == true)
+  {
+    user_options->quiet = true;
+  }
+
   if (user_options->example_hashes == true)
   {
     user_options->quiet = true;
@@ -1840,6 +1861,10 @@ void user_options_preprocess (hashcat_ctx_t *hashcat_ctx)
     if (user_options->example_hashes == true)
     {
 
+    }
+    else if (user_options->hash_info == true)
+    {
+
     }
     else if (user_options->backend_info == true)
     {
@@ -2057,6 +2082,10 @@ void user_options_extra_init (hashcat_ctx_t *hashcat_ctx)
   if (user_options->benchmark == true)
   {
 
+  }
+  else if (user_options->hash_info == true)
+  {
+
   }
   else if (user_options->example_hashes == true)
   {
@@ -3005,6 +3034,7 @@ void user_options_logger (hashcat_ctx_t *hashcat_ctx)
   logfile_top_uint   (user_options->force);
   logfile_top_uint   (user_options->hwmon_disable);
   logfile_top_uint   (user_options->hwmon_temp_abort);
+  logfile_top_uint   (user_options->hash_info);
   logfile_top_uint   (user_options->hash_mode);
   logfile_top_uint   (user_options->hex_charset);
   logfile_top_uint   (user_options->hex_salt);

src/wordlist.c

@@ -588,6 +588,7 @@ int wl_data_init (hashcat_ctx_t *hashcat_ctx)
   wl_data->enabled = false;
 
   if (user_options->benchmark      == true) return 0;
+  if (user_options->hash_info      == true) return 0;
   if (user_options->example_hashes == true) return 0;
   if (user_options->left           == true) return 0;
   if (user_options->backend_info   == true) return 0;