based m17040 of m17010

OpenCL/m17040-pure.cl

@@ -0,0 +1,504 @@
+/**
+ * Author......: Netherlands Forensic Institute
+ * License.....: MIT
+ */
+
+//#define NEW_SIMD_CODE
+
+#ifdef KERNEL_STATIC
+#include M2S(INCLUDE_PATH/inc_vendor.h)
+#include M2S(INCLUDE_PATH/inc_types.h)
+#include M2S(INCLUDE_PATH/inc_platform.cl)
+#include M2S(INCLUDE_PATH/inc_common.cl)
+#include M2S(INCLUDE_PATH/inc_hash_sha1.cl)
+#include M2S(INCLUDE_PATH/inc_cipher_aes.cl)
+#endif
+
+typedef struct gpg
+{
+  u32 cipher_algo;
+  u32 iv[4];
+  u32 modulus_size;
+  u32 encrypted_data[384];
+  u32 encrypted_data_size;
+
+} gpg_t;
+
+typedef struct gpg_tmp
+{
+  // buffer for a maximum of 256 + 8 characters, we extend it to 320 characters so it's always 64 byte aligned
+  u32 salted_pw_block[80];
+  // actual number of bytes in 'salted_pwd' that are used since salt and password are copied multiple times into the buffer
+  u32 salted_pw_block_len;
+
+  u32 h[10];
+
+  u32 w0[4];
+  u32 w1[4];
+  u32 w2[4];
+  u32 w3[4];
+
+  u32 len;
+
+} gpg_tmp_t;
+
+
+DECLSPEC u32 hc_bytealign_le_S (const u32 a, const u32 b, const int c)
+{
+  const int c_mod_4 = c & 3;
+
+  #if ((defined IS_AMD || defined IS_HIP) && HAS_VPERM == 0) || defined IS_GENERIC
+  const u32 r = l32_from_64_S ((v64_from_v32ab_S (b, a) >> (c_mod_4 * 8)));
+  #endif
+
+  #if ((defined IS_AMD || defined IS_HIP) && HAS_VPERM == 1) || defined IS_NV
+
+  #if defined IS_NV
+  const int selector = (0x76543210 >> (c_mod_4 * 4)) & 0xffff;
+  #endif
+
+  #if (defined IS_AMD || defined IS_HIP)
+  const int selector = l32_from_64_S (0x0706050403020100UL >> (c_mod_4 * 8));
+  #endif
+
+  const u32 r = hc_byte_perm (b, a, selector);
+  #endif
+
+  return r;
+}
+
+DECLSPEC void memcat_le_S (PRIVATE_AS u32 *block, const u32 offset, PRIVATE_AS const u32 *append, u32 len)
+{
+  const u32 start_index = (offset - 1) >> 2;
+  const u32 count = ((offset + len + 3) >> 2) - start_index;
+  const int off_mod_4 = offset & 3;
+  const int off_minus_4 = 4 - off_mod_4;
+
+  block[start_index] |= hc_bytealign_le_S (append[0], 0, off_minus_4);
+
+  for (u32 idx = 1; idx < count; idx++)
+  {
+    block[start_index + idx] = hc_bytealign_le_S (append[idx], append[idx - 1], off_minus_4);
+  }
+}
+
+DECLSPEC void memzero_le_S (PRIVATE_AS u32 *block, const u32 start_offset, const u32 end_offset)
+{
+  const u32 start_idx = start_offset / 4;
+
+  // zero out bytes in the first u32 starting from 'start_offset'
+  // math is a bit complex to avoid shifting by 32 bits, which is not possible on some architectures
+  block[start_idx] &= ~(0xffffffff << ((start_offset & 3) * 8));
+
+  const u32 end_idx = (end_offset + 3) / 4;
+
+  // zero out bytes in u32 units -- note that the last u32 is completely zeroed!
+  for (u32 i = start_idx + 1; i < end_idx; i++)
+  {
+    block[i] = 0;
+  }
+}
+
+DECLSPEC void memzero_be_S (PRIVATE_AS u32 *block, const u32 start_offset, const u32 end_offset)
+{
+  const u32 start_idx = start_offset / 4;
+
+  // zero out bytes in the first u32 starting from 'start_offset'
+  // math is a bit complex to avoid shifting by 32 bits, which is not possible on some architectures
+  block[start_idx] &= ~(0xffffffff >> ((start_offset & 3) * 8));
+
+  const u32 end_idx = (end_offset + 3) / 4;
+
+  // zero out bytes in u32 units -- note that the last u32 is completely zeroed!
+  for (u32 i = start_idx + 1; i < end_idx; i++)
+  {
+    block[i] = 0;
+  }
+}
+
+DECLSPEC void aes128_decrypt_cfb (GLOBAL_AS const u32 *encrypted_data, int data_len, PRIVATE_AS const u32 *iv, PRIVATE_AS const u32 *key, PRIVATE_AS u32 *decrypted_data,
+                                  SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4)
+{
+  u32 ks[44];
+  u32 essiv[4];
+
+  // Copy the IV, since this will be modified
+  essiv[0] = iv[0];
+  essiv[1] = iv[1];
+  essiv[2] = iv[2];
+  essiv[3] = iv[3];
+
+  aes128_set_encrypt_key (ks, key, s_te0, s_te1, s_te2, s_te3);
+
+  // Decrypt an AES-128 encrypted block
+  for (u32 i = 0; i < (data_len + 3) / 4; i += 4)
+  {
+    aes128_encrypt (ks, essiv, decrypted_data + i, s_te0, s_te1, s_te2, s_te3, s_te4);
+
+    decrypted_data[i + 0] ^= encrypted_data[i + 0];
+    decrypted_data[i + 1] ^= encrypted_data[i + 1];
+    decrypted_data[i + 2] ^= encrypted_data[i + 2];
+    decrypted_data[i + 3] ^= encrypted_data[i + 3];
+
+    // Note: Not necessary if you are only decrypting a single block!
+    essiv[0] = encrypted_data[i + 0];
+    essiv[1] = encrypted_data[i + 1];
+    essiv[2] = encrypted_data[i + 2];
+    essiv[3] = encrypted_data[i + 3];
+  }
+}
+
+DECLSPEC void aes256_decrypt_cfb (GLOBAL_AS const u32 *encrypted_data, int data_len, PRIVATE_AS const u32 *iv, PRIVATE_AS const u32 *key, PRIVATE_AS u32 *decrypted_data,
+                                  SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4)
+{
+  u32 ks[60];
+  u32 essiv[4];
+
+  // Copy the IV, since this will be modified
+  essiv[0] = iv[0];
+  essiv[1] = iv[1];
+  essiv[2] = iv[2];
+  essiv[3] = iv[3];
+
+  aes256_set_encrypt_key (ks, key, s_te0, s_te1, s_te2, s_te3);
+
+  // Decrypt an AES-256 encrypted block
+  for (u32 i = 0; i < (data_len + 3) / 4; i += 4)
+  {
+    aes256_encrypt (ks, essiv, decrypted_data + i, s_te0, s_te1, s_te2, s_te3, s_te4);
+
+    decrypted_data[i + 0] ^= encrypted_data[i + 0];
+    decrypted_data[i + 1] ^= encrypted_data[i + 1];
+    decrypted_data[i + 2] ^= encrypted_data[i + 2];
+    decrypted_data[i + 3] ^= encrypted_data[i + 3];
+
+    // Note: Not necessary if you are only decrypting a single block!
+    essiv[0] = encrypted_data[i + 0];
+    essiv[1] = encrypted_data[i + 1];
+    essiv[2] = encrypted_data[i + 2];
+    essiv[3] = encrypted_data[i + 3];
+  }
+}
+
+DECLSPEC int check_decoded_data (PRIVATE_AS u32 *decoded_data, const u32 decoded_data_size)
+{
+  // Check the SHA-1 of the decrypted data which is stored at the end of the decrypted data
+  const u32 sha1_byte_off = (decoded_data_size - 20);
+  const u32 sha1_u32_off = sha1_byte_off / 4;
+
+  u32 expected_sha1[5];
+
+  expected_sha1[0] = hc_bytealign_le_S (decoded_data[sha1_u32_off + 1], decoded_data[sha1_u32_off + 0], sha1_byte_off);
+  expected_sha1[1] = hc_bytealign_le_S (decoded_data[sha1_u32_off + 2], decoded_data[sha1_u32_off + 1], sha1_byte_off);
+  expected_sha1[2] = hc_bytealign_le_S (decoded_data[sha1_u32_off + 3], decoded_data[sha1_u32_off + 2], sha1_byte_off);
+  expected_sha1[3] = hc_bytealign_le_S (decoded_data[sha1_u32_off + 4], decoded_data[sha1_u32_off + 3], sha1_byte_off);
+  expected_sha1[4] = hc_bytealign_le_S (decoded_data[sha1_u32_off + 5], decoded_data[sha1_u32_off + 4], sha1_byte_off);
+
+  memzero_le_S (decoded_data, sha1_byte_off, 384 * sizeof(u32));
+
+  sha1_ctx_t ctx;
+
+  sha1_init (&ctx);
+
+  sha1_update_swap (&ctx, decoded_data, sha1_byte_off);
+
+  sha1_final (&ctx);
+
+  return (expected_sha1[0] == hc_swap32_S (ctx.h[0]))
+      && (expected_sha1[1] == hc_swap32_S (ctx.h[1]))
+      && (expected_sha1[2] == hc_swap32_S (ctx.h[2]))
+      && (expected_sha1[3] == hc_swap32_S (ctx.h[3]))
+      && (expected_sha1[4] == hc_swap32_S (ctx.h[4]));
+}
+
+KERNEL_FQ void m17010_init (KERN_ATTR_TMPS_ESALT (gpg_tmp_t, gpg_t))
+{
+  const u64 gid = get_global_id (0);
+
+  if (gid >= GID_CNT) return;
+
+  const u32 pw_len = pws[gid].pw_len;
+  const u32 salted_pw_len = (salt_bufs[SALT_POS_HOST].salt_len + pw_len);
+
+  u32 salted_pw_block[80];
+
+  // concatenate salt and password -- the salt is always 8 bytes
+  salted_pw_block[0] = salt_bufs[SALT_POS_HOST].salt_buf[0];
+  salted_pw_block[1] = salt_bufs[SALT_POS_HOST].salt_buf[1];
+
+  for (u32 idx = 0; idx < 64; idx++) salted_pw_block[idx + 2] = pws[gid].i[idx];
+
+  // zero remainder of buffer
+  for (u32 idx = 66; idx < 80; idx++) salted_pw_block[idx] = 0;
+
+  // create a number of copies for efficiency
+  const u32 copies = 80 * sizeof(u32) / salted_pw_len;
+
+  for (u32 idx = 1; idx < copies; idx++)
+  {
+    memcat_le_S (salted_pw_block, idx * salted_pw_len, salted_pw_block, salted_pw_len);
+  }
+
+  for (u32 idx = 0; idx < 80; idx++)
+  {
+    tmps[gid].salted_pw_block[idx] = hc_swap32_S (salted_pw_block[idx]);
+  }
+
+  tmps[gid].salted_pw_block_len = (copies * salted_pw_len);
+
+  tmps[gid].h[0] = SHA1M_A;
+  tmps[gid].h[1] = SHA1M_B;
+  tmps[gid].h[2] = SHA1M_C;
+  tmps[gid].h[3] = SHA1M_D;
+  tmps[gid].h[4] = SHA1M_E;
+  tmps[gid].h[5] = SHA1M_A;
+  tmps[gid].h[6] = SHA1M_B;
+  tmps[gid].h[7] = SHA1M_C;
+  tmps[gid].h[8] = SHA1M_D;
+  tmps[gid].h[9] = SHA1M_E;
+
+  tmps[gid].len = 0;
+}
+
+KERNEL_FQ void m17010_loop_prepare (KERN_ATTR_TMPS_ESALT (gpg_tmp_t, gpg_t))
+{
+  const u64 gid = get_global_id (0);
+
+  if (gid >= GID_CNT) return;
+
+  tmps[gid].w0[0] = 0;
+  tmps[gid].w0[1] = 0;
+  tmps[gid].w0[2] = 0;
+  tmps[gid].w0[3] = 0;
+  tmps[gid].w1[0] = 0;
+  tmps[gid].w1[1] = 0;
+  tmps[gid].w1[2] = 0;
+  tmps[gid].w1[3] = 0;
+  tmps[gid].w2[0] = 0;
+  tmps[gid].w2[1] = 0;
+  tmps[gid].w2[2] = 0;
+  tmps[gid].w2[3] = 0;
+  tmps[gid].w3[0] = 0;
+  tmps[gid].w3[1] = 0;
+  tmps[gid].w3[2] = 0;
+  tmps[gid].w3[3] = 0;
+
+  tmps[gid].len = SALT_REPEAT;
+}
+
+KERNEL_FQ void m17010_loop (KERN_ATTR_TMPS_ESALT (gpg_tmp_t, gpg_t))
+{
+  const u64 gid = get_global_id (0);
+
+  if (gid >= GID_CNT) return;
+
+  // get the prepared buffer from the gpg_tmp_t struct into a local buffer
+  u32 salted_pw_block[80];
+
+  for (int i = 0; i < 80; i++) salted_pw_block[i] = tmps[gid].salted_pw_block[i];
+
+  const u32 salted_pw_block_len = tmps[gid].salted_pw_block_len;
+
+  // do we really need this, since the salt is always length 8?
+  if (salted_pw_block_len == 0) return;
+
+  /**
+   * context load
+   */
+
+  sha1_ctx_t ctx;
+
+  const u32 sha_offset = SALT_REPEAT * 5;
+
+  for (int i = 0; i < 5; i++) ctx.h[i] = tmps[gid].h[sha_offset + i];
+
+  for (int i = 0; i < 4; i++) ctx.w0[i] = tmps[gid].w0[i];
+  for (int i = 0; i < 4; i++) ctx.w1[i] = tmps[gid].w1[i];
+  for (int i = 0; i < 4; i++) ctx.w2[i] = tmps[gid].w2[i];
+  for (int i = 0; i < 4; i++) ctx.w3[i] = tmps[gid].w3[i];
+
+  ctx.len = tmps[gid].len;
+
+  // sha-1 of salt and password, up to 'salt_iter' bytes
+  const u32 salt_iter = salt_bufs[SALT_POS_HOST].salt_iter;
+
+  const u32 salted_pw_block_pos = LOOP_POS % salted_pw_block_len;
+  const u32 rounds = (LOOP_CNT + salted_pw_block_pos) / salted_pw_block_len;
+
+  for (u32 i = 0; i < rounds; i++)
+  {
+    sha1_update (&ctx, salted_pw_block, salted_pw_block_len);
+  }
+
+  if ((LOOP_POS + LOOP_CNT) == salt_iter)
+  {
+    const u32 remaining_bytes = salt_iter % salted_pw_block_len;
+
+    if (remaining_bytes)
+    {
+      memzero_be_S (salted_pw_block, remaining_bytes, salted_pw_block_len);
+
+      sha1_update (&ctx, salted_pw_block, remaining_bytes);
+    }
+
+    sha1_final (&ctx);
+  }
+
+  /**
+   * context save
+   */
+
+  for (int i = 0; i < 5; i++) tmps[gid].h[sha_offset + i] = ctx.h[i];
+
+  for (int i = 0; i < 4; i++) tmps[gid].w0[i] = ctx.w0[i];
+  for (int i = 0; i < 4; i++) tmps[gid].w1[i] = ctx.w1[i];
+  for (int i = 0; i < 4; i++) tmps[gid].w2[i] = ctx.w2[i];
+  for (int i = 0; i < 4; i++) tmps[gid].w3[i] = ctx.w3[i];
+
+  tmps[gid].len = ctx.len;
+}
+
+KERNEL_FQ void m17010_comp (KERN_ATTR_TMPS_ESALT (gpg_tmp_t, gpg_t))
+{
+  // not in use here, special case...
+}
+
+KERNEL_FQ void m17010_aux1 (KERN_ATTR_TMPS_ESALT (gpg_tmp_t, gpg_t))
+{
+  /**
+   * modifier
+   */
+
+  const u64 lid = get_local_id (0);
+  const u64 gid = get_global_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * aes shared
+   */
+
+  #ifdef REAL_SHM
+
+  LOCAL_VK u32 s_te0[256];
+  LOCAL_VK u32 s_te1[256];
+  LOCAL_VK u32 s_te2[256];
+  LOCAL_VK u32 s_te3[256];
+  LOCAL_VK u32 s_te4[256];
+
+  for (u32 i = lid; i < 256; i += lsz)
+  {
+    s_te0[i] = te0[i];
+    s_te1[i] = te1[i];
+    s_te2[i] = te2[i];
+    s_te3[i] = te3[i];
+    s_te4[i] = te4[i];
+  }
+
+  SYNC_THREADS ();
+
+  #else
+
+  CONSTANT_AS u32a *s_te0 = te0;
+  CONSTANT_AS u32a *s_te1 = te1;
+  CONSTANT_AS u32a *s_te2 = te2;
+  CONSTANT_AS u32a *s_te3 = te3;
+  CONSTANT_AS u32a *s_te4 = te4;
+
+  #endif
+
+  if (gid >= GID_CNT) return;
+
+  // retrieve and use the SHA-1 as the key for AES
+
+  u32 aes_key[4];
+
+  for (int i = 0; i < 4; i++) aes_key[i] = hc_swap32_S (tmps[gid].h[i]);
+
+  u32 iv[4] = {0};
+
+  for (int idx = 0; idx < 4; idx++) iv[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].iv[idx];
+
+  u32 decoded_data[384];
+
+  const u32 enc_data_size = esalt_bufs[DIGESTS_OFFSET_HOST].encrypted_data_size;
+
+  aes128_decrypt_cfb (esalt_bufs[DIGESTS_OFFSET_HOST].encrypted_data, enc_data_size, iv, aes_key, decoded_data, s_te0, s_te1, s_te2, s_te3, s_te4);
+
+  if (check_decoded_data (decoded_data, enc_data_size))
+  {
+    if (hc_atomic_inc (&hashes_shown[DIGESTS_OFFSET_HOST]) == 0)
+    {
+      mark_hash (plains_buf, d_return_buf, SALT_POS_HOST, DIGESTS_CNT, 0, DIGESTS_OFFSET_HOST + 0, gid, 0, 0, 0);
+    }
+  }
+}
+
+KERNEL_FQ void m17010_aux2 (KERN_ATTR_TMPS_ESALT (gpg_tmp_t, gpg_t))
+{
+  /**
+   * modifier
+   */
+
+  const u64 lid = get_local_id (0);
+  const u64 gid = get_global_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * aes shared
+   */
+
+  #ifdef REAL_SHM
+
+  LOCAL_VK u32 s_te0[256];
+  LOCAL_VK u32 s_te1[256];
+  LOCAL_VK u32 s_te2[256];
+  LOCAL_VK u32 s_te3[256];
+  LOCAL_VK u32 s_te4[256];
+
+  for (u32 i = lid; i < 256; i += lsz)
+  {
+    s_te0[i] = te0[i];
+    s_te1[i] = te1[i];
+    s_te2[i] = te2[i];
+    s_te3[i] = te3[i];
+    s_te4[i] = te4[i];
+  }
+
+  SYNC_THREADS ();
+
+  #else
+
+  CONSTANT_AS u32a *s_te0 = te0;
+  CONSTANT_AS u32a *s_te1 = te1;
+  CONSTANT_AS u32a *s_te2 = te2;
+  CONSTANT_AS u32a *s_te3 = te3;
+  CONSTANT_AS u32a *s_te4 = te4;
+
+  #endif
+
+  if (gid >= GID_CNT) return;
+
+  // retrieve and use the SHA-1 as the key for AES
+
+  u32 aes_key[8];
+
+  for (int i = 0; i < 8; i++) aes_key[i] = hc_swap32_S (tmps[gid].h[i]);
+
+  u32 iv[4] = {0};
+
+  for (int idx = 0; idx < 4; idx++) iv[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].iv[idx];
+
+  u32 decoded_data[384];
+
+  const u32 enc_data_size = esalt_bufs[DIGESTS_OFFSET_HOST].encrypted_data_size;
+
+  aes256_decrypt_cfb (esalt_bufs[DIGESTS_OFFSET_HOST].encrypted_data, enc_data_size, iv, aes_key, decoded_data, s_te0, s_te1, s_te2, s_te3, s_te4);
+
+  if (check_decoded_data (decoded_data, enc_data_size))
+  {
+    if (hc_atomic_inc (&hashes_shown[DIGESTS_OFFSET_HOST]) == 0)
+    {
+      mark_hash (plains_buf, d_return_buf, SALT_POS_HOST, DIGESTS_CNT, 0, DIGESTS_OFFSET_HOST + 0, gid, 0, 0, 0);
+    }
+  }
+}

src/modules/module_17040.c

@@ -0,0 +1,406 @@
+/**
+ * Author......: Netherlands Forensic Institute
+ * License.....: MIT
+ */
+
+#include "common.h"
+#include "types.h"
+#include "modules.h"
+#include "bitops.h"
+#include "convert.h"
+#include "shared.h"
+
+static const u32   ATTACK_EXEC    = ATTACK_EXEC_OUTSIDE_KERNEL;
+static const u32   DGST_POS0      = 0;
+static const u32   DGST_POS1      = 1;
+static const u32   DGST_POS2      = 2;
+static const u32   DGST_POS3      = 3;
+static const u32   DGST_SIZE      = DGST_SIZE_4_4;
+static const u32   HASH_CATEGORY  = HASH_CATEGORY_PRIVATE_KEY;
+static const char *HASH_NAME      = "GPG (AES-128/AES-256 (SHA-1($pass)))";
+static const u64   KERN_TYPE      = 17010;
+static const u32   OPTI_TYPE      = OPTI_TYPE_ZERO_BYTE;
+static const u64   OPTS_TYPE      = OPTS_TYPE_STOCK_MODULE
+                                  | OPTS_TYPE_PT_GENERATE_LE
+                                  | OPTS_TYPE_LOOP_PREPARE
+                                  | OPTS_TYPE_AUX1
+                                  | OPTS_TYPE_AUX2
+                                  | OPTS_TYPE_DEEP_COMP_KERNEL;
+static const u32   SALT_TYPE      = SALT_TYPE_EMBEDDED;
+static const char *ST_PASS        = "hashcat";
+static const char *ST_HASH        = "$gpg$*1*348*1024*8833fa3812b5500aa9eb7e46febfa31a0584b7e4a5b13c198f5c9b0814243895cce45ac3714e79692fb5a130a1c943b9130315ce303cb7e6831be68ce427892858f313fc29f533434dbe0ef26573f2071bbcc1499dc49bda90648221ef3823757e2fba6099a18c0c83386b21d8c9b522ec935ecd540210dbf0f21c859429fd4d35fa056415d8087f27b3e66b16081ea18c544d8b2ea414484f17097bc83b773d92743f76eb2ccb4df8ba5f5ff84a5474a5e8a8e5179a5b0908503c55e428de04b40628325739874e1b4aa004c4cbdf09b0b620990a8479f1c9b4187e33e63fe48a565bc1264bbf4062559631bef9e346a7217f1cabe101a38ac4be9fa94f6dafe6b0301e67792ed51bca04140cddd5cb6e80ac6e95e9a09378c9651588fe360954b622c258a3897f11246c944a588822cc6daf1cb81ccc95098c3bea8432f1ee0c663b193a7c7f1cdfeb91eee0195296bf4783025655cbebd7c70236*3*254*2*7*16*a47ef38987beab0a0b9bfe74b72822e8*65536*1f5c90d9820997db";
+
+u32         module_attack_exec    (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ATTACK_EXEC;     }
+u32         module_dgst_pos0      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS0;       }
+u32         module_dgst_pos1      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS1;       }
+u32         module_dgst_pos2      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS2;       }
+u32         module_dgst_pos3      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS3;       }
+u32         module_dgst_size      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_SIZE;       }
+u32         module_hash_category  (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_CATEGORY;   }
+const char *module_hash_name      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_NAME;       }
+u64         module_kern_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return KERN_TYPE;       }
+u32         module_opti_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTI_TYPE;       }
+u64         module_opts_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTS_TYPE;       }
+u32         module_salt_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return SALT_TYPE;       }
+const char *module_st_hash        (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_HASH;         }
+const char *module_st_pass        (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_PASS;         }
+
+typedef struct gpg
+{
+  u32 cipher_algo;
+  u32 iv[4];
+  u32 modulus_size;
+  u32 encrypted_data[384];
+  u32 encrypted_data_size;
+
+} gpg_t;
+
+typedef struct gpg_tmp
+{
+  u32 salted_pw_block[80];
+
+  u32 salted_pw_block_len;
+
+  u32 h[10];
+
+  u32 w0[4];
+  u32 w1[4];
+  u32 w2[4];
+  u32 w3[4];
+
+  u32 len;
+
+} gpg_tmp_t;
+
+static const char *SIGNATURE_GPG = "$gpg$";
+
+u64 module_esalt_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const u64 esalt_size = (const u64) sizeof (gpg_t);
+
+  return esalt_size;
+}
+
+u64 module_tmp_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const u64 tmp_size = (const u64) sizeof (gpg_tmp_t);
+
+  return tmp_size;
+}
+
+bool module_hlfmt_disable (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const bool hlfmt_disable = true;
+
+  return hlfmt_disable;
+}
+
+u32 module_kernel_loops_min (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const u32 kernel_loops_min = 1024;
+
+  return kernel_loops_min;
+}
+
+u32 module_kernel_loops_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const u32 kernel_loops_max = 65536;
+
+  return kernel_loops_max;
+}
+
+u32 module_deep_comp_kernel (MAYBE_UNUSED const hashes_t *hashes, MAYBE_UNUSED const u32 salt_pos, MAYBE_UNUSED const u32 digest_pos)
+{
+  const u32 digests_offset = hashes->salts_buf[salt_pos].digests_offset;
+
+  gpg_t *gpgs = (gpg_t *) hashes->esalts_buf;
+
+  gpg_t *gpg = &gpgs[digests_offset + digest_pos];
+
+  if (gpg->cipher_algo == 7)
+  {
+    return KERN_RUN_AUX1;
+  }
+  else if (gpg->cipher_algo == 9)
+  {
+    return KERN_RUN_AUX2;
+  }
+
+  return 0;
+}
+
+int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len)
+{
+  u32 *digest = (u32 *) digest_buf;
+
+  gpg_t *gpg = (gpg_t *) esalt_buf;
+
+  hc_token_t token;
+
+  memset (&token, 0, sizeof (hc_token_t));
+
+  token.token_cnt = 13;
+
+  // signature $gpg$
+  token.signatures_cnt = 1;
+  token.signatures_buf[0] = SIGNATURE_GPG;
+
+  // signature $gpg$
+  token.sep[0]      = '*';
+  token.len[0]      = 5;
+  token.attr[0]     = TOKEN_ATTR_FIXED_LENGTH
+                    | TOKEN_ATTR_VERIFY_SIGNATURE;
+
+  // "1" -- unknown option
+  token.sep[1]      = '*';
+  token.len[1]      = 1;
+  token.attr[1]     = TOKEN_ATTR_FIXED_LENGTH
+                    | TOKEN_ATTR_VERIFY_DIGIT;
+
+  // size of the encrypted data in bytes
+  token.sep[2]      = '*';
+  token.len_min[2]  = 3;
+  token.len_max[2]  = 4;
+  token.attr[2]     = TOKEN_ATTR_VERIFY_LENGTH
+                    | TOKEN_ATTR_VERIFY_DIGIT;
+
+  // size of the key: 1024, 2048, 4096, etc.
+  token.sep[3]      = '*';
+  token.len_min[3]  = 3;
+  token.len_max[3]  = 4;
+  token.attr[3]     = TOKEN_ATTR_VERIFY_LENGTH
+                    | TOKEN_ATTR_VERIFY_DIGIT;
+
+  // encrypted key -- twice the amount of byte because its interpreted as characters
+  token.sep[4]      = '*';
+  token.len_min[4]  = 256;
+  token.len_max[4]  = 3072;
+  token.attr[4]     = TOKEN_ATTR_VERIFY_LENGTH
+                    | TOKEN_ATTR_VERIFY_HEX;
+
+  // "3" - String2Key parameter
+  token.sep[5]      = '*';
+  token.len[5]      = 1;
+  token.attr[5]     = TOKEN_ATTR_FIXED_LENGTH
+                    | TOKEN_ATTR_VERIFY_DIGIT;
+
+  // "254" - String2Key parameters
+  token.sep[6]      = '*';
+  token.len[6]      = 3;
+  token.attr[6]     = TOKEN_ATTR_FIXED_LENGTH
+                    | TOKEN_ATTR_VERIFY_DIGIT;
+
+  // "2" - String2Key parameters
+  token.sep[7]      = '*';
+  token.len[7]      = 1;
+  token.attr[7]     = TOKEN_ATTR_FIXED_LENGTH
+                    | TOKEN_ATTR_VERIFY_DIGIT;
+
+  // cipher mode: 7 or 9
+  token.sep[8]      = '*';
+  token.len[8]      = 1;
+  token.attr[8]     = TOKEN_ATTR_FIXED_LENGTH
+                    | TOKEN_ATTR_VERIFY_DIGIT;
+
+  // size of initial vector in bytes: 16
+  token.sep[9]      = '*';
+  token.len[9]      = 2;
+  token.attr[9]     = TOKEN_ATTR_FIXED_LENGTH
+                    | TOKEN_ATTR_VERIFY_DIGIT;
+
+  // initial vector - twice the amount of bytes because its interpreted as characters
+  token.sep[10]     = '*';
+  token.len[10]     = 32;
+  token.attr[10]    = TOKEN_ATTR_FIXED_LENGTH
+                    | TOKEN_ATTR_VERIFY_HEX;
+
+  // iteration count
+  token.sep[11]     = '*';
+  token.len_min[11] = 1;
+  token.len_max[11] = 8;
+  token.attr[11]    = TOKEN_ATTR_VERIFY_LENGTH
+                    | TOKEN_ATTR_VERIFY_DIGIT;
+
+  // salt - 8 bytes / 16 characters
+  token.len[12]     = 16;
+  token.attr[12]    = TOKEN_ATTR_FIXED_LENGTH
+                    | TOKEN_ATTR_VERIFY_HEX;
+
+  const int rc_tokenizer = input_tokenizer ((const u8 *) line_buf, line_len, &token);
+
+  if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
+
+  // Modulus size
+
+  const int modulus_size = hc_strtoul ((const char *) token.buf[3], NULL, 10);
+
+  if ((modulus_size < 256) || (modulus_size > 16384)) return (PARSER_SALT_LENGTH);
+
+  gpg->modulus_size = modulus_size;
+
+  // Encrypted data
+
+  const int enc_data_size = hc_strtoul ((const char *) token.buf[2], NULL, 10);
+
+  const int encrypted_data_size = hex_decode ((const u8 *) token.buf[4], token.len[4], (u8 *) gpg->encrypted_data);
+
+  if (enc_data_size != encrypted_data_size) return (PARSER_CT_LENGTH);
+
+  gpg->encrypted_data_size = encrypted_data_size;
+
+  // Check String2Key parameters
+
+  if (hc_strtoul ((const char *) token.buf[5], NULL, 10) !=   3) return (PARSER_HASH_VALUE);
+  if (hc_strtoul ((const char *) token.buf[6], NULL, 10) != 254) return (PARSER_HASH_VALUE);
+  if (hc_strtoul ((const char *) token.buf[7], NULL, 10) !=   2) return (PARSER_HASH_VALUE);
+
+  // Cipher algo
+
+  const int cipher_algo = hc_strtoul ((const char *) token.buf[8], NULL, 10);
+
+  if ((cipher_algo != 7) && (cipher_algo != 9)) return (PARSER_CIPHER);
+
+  gpg->cipher_algo = cipher_algo;
+
+  // IV (size)
+
+  if (hc_strtoul ((const char *) token.buf[9], NULL, 10) != sizeof (gpg->iv)) return (PARSER_IV_LENGTH);
+
+  const int iv_size = hex_decode ((const u8 *) token.buf[10], token.len[10], (u8 *) gpg->iv);
+
+  if (iv_size != sizeof (gpg->iv)) return (PARSER_IV_LENGTH);
+
+  // Salt Iter
+
+  const u32 salt_iter = hc_strtoul ((const char *) token.buf[11], NULL, 10);
+
+  if (salt_iter < 8 || salt_iter > 65011712) return (PARSER_SALT_ITERATION);
+
+  salt->salt_iter = salt_iter;
+
+  // Salt Value
+
+  salt->salt_repeats = gpg->cipher_algo == 7 ? 0 : 1; // "minus one"
+
+  salt->salt_len = hex_decode ((const u8 *) token.buf[12], token.len[12], (u8 *) salt->salt_buf);
+
+  if (salt->salt_len != 8) return (PARSER_SALT_LENGTH);
+
+  // hash fake
+  digest[0] = gpg->iv[0];
+  digest[1] = gpg->iv[1];
+  digest[2] = gpg->iv[2];
+  digest[3] = gpg->iv[3];
+
+  return (PARSER_OK);
+}
+
+int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const void *digest_buf, MAYBE_UNUSED const salt_t *salt, MAYBE_UNUSED const void *esalt_buf, MAYBE_UNUSED const void *hook_salt_buf, MAYBE_UNUSED const hashinfo_t *hash_info, char *line_buf, MAYBE_UNUSED const int line_size)
+{
+  const gpg_t *gpg = (const gpg_t *) esalt_buf;
+
+  u8 encrypted_data[(384 * 8) + 1];
+
+  hex_encode ((const u8 *) gpg->encrypted_data, gpg->encrypted_data_size, (u8 *) encrypted_data);
+
+  const int line_len = snprintf (line_buf, line_size, "%s*%d*%d*%d*%s*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x",
+    SIGNATURE_GPG,
+    1, /* unknown field */
+    gpg->encrypted_data_size,
+    gpg->modulus_size,
+    encrypted_data,
+    3, /* version (major?) */
+    254, /* version (minor?) */
+    2, /* key cipher (sha-1) */
+    gpg->cipher_algo,
+    16, /*iv_size*/
+    byte_swap_32 (gpg->iv[0]),
+    byte_swap_32 (gpg->iv[1]),
+    byte_swap_32 (gpg->iv[2]),
+    byte_swap_32 (gpg->iv[3]),
+    salt->salt_iter,
+    byte_swap_32 (salt->salt_buf[0]),
+    byte_swap_32 (salt->salt_buf[1]));
+
+  return line_len;
+}
+
+void module_init (module_ctx_t *module_ctx)
+{
+  module_ctx->module_context_size             = MODULE_CONTEXT_SIZE_CURRENT;
+  module_ctx->module_interface_version        = MODULE_INTERFACE_VERSION_CURRENT;
+
+  module_ctx->module_attack_exec              = module_attack_exec;
+  module_ctx->module_benchmark_esalt          = MODULE_DEFAULT;
+  module_ctx->module_benchmark_hook_salt      = MODULE_DEFAULT;
+  module_ctx->module_benchmark_mask           = MODULE_DEFAULT;
+  module_ctx->module_benchmark_charset        = MODULE_DEFAULT;
+  module_ctx->module_benchmark_salt           = MODULE_DEFAULT;
+  module_ctx->module_build_plain_postprocess  = MODULE_DEFAULT;
+  module_ctx->module_deep_comp_kernel         = module_deep_comp_kernel;
+  module_ctx->module_deprecated_notice        = MODULE_DEFAULT;
+  module_ctx->module_dgst_pos0                = module_dgst_pos0;
+  module_ctx->module_dgst_pos1                = module_dgst_pos1;
+  module_ctx->module_dgst_pos2                = module_dgst_pos2;
+  module_ctx->module_dgst_pos3                = module_dgst_pos3;
+  module_ctx->module_dgst_size                = module_dgst_size;
+  module_ctx->module_dictstat_disable         = MODULE_DEFAULT;
+  module_ctx->module_esalt_size               = module_esalt_size;
+  module_ctx->module_extra_buffer_size        = MODULE_DEFAULT;
+  module_ctx->module_extra_tmp_size           = MODULE_DEFAULT;
+  module_ctx->module_extra_tuningdb_block     = MODULE_DEFAULT;
+  module_ctx->module_forced_outfile_format    = MODULE_DEFAULT;
+  module_ctx->module_hash_binary_count        = MODULE_DEFAULT;
+  module_ctx->module_hash_binary_parse        = MODULE_DEFAULT;
+  module_ctx->module_hash_binary_save         = MODULE_DEFAULT;
+  module_ctx->module_hash_decode_postprocess  = MODULE_DEFAULT;
+  module_ctx->module_hash_decode_potfile      = MODULE_DEFAULT;
+  module_ctx->module_hash_decode_zero_hash    = MODULE_DEFAULT;
+  module_ctx->module_hash_decode              = module_hash_decode;
+  module_ctx->module_hash_encode_status       = MODULE_DEFAULT;
+  module_ctx->module_hash_encode_potfile      = MODULE_DEFAULT;
+  module_ctx->module_hash_encode              = module_hash_encode;
+  module_ctx->module_hash_init_selftest       = MODULE_DEFAULT;
+  module_ctx->module_hash_mode                = MODULE_DEFAULT;
+  module_ctx->module_hash_category            = module_hash_category;
+  module_ctx->module_hash_name                = module_hash_name;
+  module_ctx->module_hashes_count_min         = MODULE_DEFAULT;
+  module_ctx->module_hashes_count_max         = MODULE_DEFAULT;
+  module_ctx->module_hlfmt_disable            = module_hlfmt_disable;
+  module_ctx->module_hook_extra_param_size    = MODULE_DEFAULT;
+  module_ctx->module_hook_extra_param_init    = MODULE_DEFAULT;
+  module_ctx->module_hook_extra_param_term    = MODULE_DEFAULT;
+  module_ctx->module_hook12                   = MODULE_DEFAULT;
+  module_ctx->module_hook23                   = MODULE_DEFAULT;
+  module_ctx->module_hook_salt_size           = MODULE_DEFAULT;
+  module_ctx->module_hook_size                = MODULE_DEFAULT;
+  module_ctx->module_jit_build_options        = MODULE_DEFAULT;
+  module_ctx->module_jit_cache_disable        = MODULE_DEFAULT;
+  module_ctx->module_kernel_accel_max         = MODULE_DEFAULT;
+  module_ctx->module_kernel_accel_min         = MODULE_DEFAULT;
+  module_ctx->module_kernel_loops_max         = module_kernel_loops_max;
+  module_ctx->module_kernel_loops_min         = module_kernel_loops_min;
+  module_ctx->module_kernel_threads_max       = MODULE_DEFAULT;
+  module_ctx->module_kernel_threads_min       = MODULE_DEFAULT;
+  module_ctx->module_kern_type                = module_kern_type;
+  module_ctx->module_kern_type_dynamic        = MODULE_DEFAULT;
+  module_ctx->module_opti_type                = module_opti_type;
+  module_ctx->module_opts_type                = module_opts_type;
+  module_ctx->module_outfile_check_disable    = MODULE_DEFAULT;
+  module_ctx->module_outfile_check_nocomp     = MODULE_DEFAULT;
+  module_ctx->module_potfile_custom_check     = MODULE_DEFAULT;
+  module_ctx->module_potfile_disable          = MODULE_DEFAULT;
+  module_ctx->module_potfile_keep_all_hashes  = MODULE_DEFAULT;
+  module_ctx->module_pwdump_column            = MODULE_DEFAULT;
+  module_ctx->module_pw_max                   = MODULE_DEFAULT;
+  module_ctx->module_pw_min                   = MODULE_DEFAULT;
+  module_ctx->module_salt_max                 = MODULE_DEFAULT;
+  module_ctx->module_salt_min                 = MODULE_DEFAULT;
+  module_ctx->module_salt_type                = module_salt_type;
+  module_ctx->module_separator                = MODULE_DEFAULT;
+  module_ctx->module_st_hash                  = module_st_hash;
+  module_ctx->module_st_pass                  = module_st_pass;
+  module_ctx->module_tmp_size                 = module_tmp_size;
+  module_ctx->module_unstable_warning         = MODULE_DEFAULT;
+  module_ctx->module_warmup_disable           = MODULE_DEFAULT;
+}