heitt 0.4.5 → 0.4.6

data/lib/heitt/database.rb

@@ -8,2508 +8,1002 @@ module HEITT
     {
         extract_regex: Regexp.new('\b[a-f0-9]{4}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"CRC-16",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "Cyclic Redundancy Check 16-bit — 4 hexadecimal chars, basic checksum",
-                notes: ["Error detection in data transmission", "Data storage integrity checks", "Not cryptographic", "Low collision resistance"],
-                context: ["checksum", "networking"], 
-                prefixes: ["crc-16"],
-                common_sources: ["file verification", "network protocols", "embedded systems"]
-
-            },
-            {
-                name:"CRC-16-CCITT",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "Cyclic Redundancy Check 16-bit Consultative Commitee for International Telegraph and Telephone",
-                notes: ["Used for error detection in communication and storage systems", "Data Integrity and verification", "Memory checks integrity", "Not cryptographic"],
-                context: ["checksum", "telecom", "bluetooth"], 
-                common_sources: ["V.41", "X.25", "HDLC", "Bluetooth"]
-            },
-            {
-                name:"FCS-16",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "Frame Check Sequence 6-bit — 4 hexadecimal chars, data link layer",
-                notes: ["Not cryptographic"],
-                prefixes: ["fcs-16"],
-                context: ["checksum", "networking"], 
-                common_sources: ["Ethernet frames", "PPP"]
-            }
+            {name:"CRC-16", john: nil, hashcat: nil, extended: false},
+            {name:"CRC-16-CCITT", john: nil, hashcat: nil, extended: false},
+            {name:"FCS-16", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{8}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"Adler-32",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "Adler-32 checksum — 8 hex chars, zlib compression",
-                common_sources: ["zlib", "PNG files", "RSYNC"], 
-                context: ["checksum", "compression"]     
-            },
-            {
-                name:"CRC-32B",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "CRC-32 IEEE 802.3 variant — 8 hex chars, Ethernet standard" ,
-                notes: ["Not cryptographic"],
-                common_sources: ["Ethernet", "MPEG-2", "PKZIP"], 
-                context: ["checksum", "networking"]            
-            },
-            {
-                name:"FCS-32",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "Frame Check Sequence 32-bit — 8 hex chars, advanced networking",
-                common_sources: ["advanced networking protocols"], 
-                context: ["checksum", "networking"]       
-            },
-            {
-                name:"GHash-32-3",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "G-Hash 32-bit 3-round — 8 hex chars, experimental hash",
-                  common_sources: ["research", "academic"], 
-                context: ["experimental"]
-            }, 
-            {
-                name:"GHash-32-5",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "G-Hash 32-bit 5-round — 8 hex chars, experimental hash",
-                common_sources: ["research", "academic"], 
-                context: ["experimental"]
-            },
-            {
-                name:"FNV-132",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "Fowler-Noll-Vo hash 32-bit — 8 hex chars, fast non-crypto hash",
-                common_sources: ["DNS", "database indexing", "hash tables"], 
-                context: ["checksum", "programming"]
-            },
-            {
-                name:"Fletcher-32",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "Fletcher's checksum 32-bit — 8 hex chars, error detection",
-                common_sources: ["OSTA UDF", "ISO/IEC 8473-1"], 
-                context: ["checksum", "storage"]
-            },
-            {
-                name:"Joaat",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "Jenkins one-at-a-time hash — 8 hex chars, simple string hash",
-                common_sources: ["Perl", "Apache", "various applications"], 
-                context: ["programming", "hashing"]
-            },
-            {
-                name:"ELF-32",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "ELF-32 hash for object files — 8 hex chars, Unix/Linux object files",
-                context: ["executable", "system"],
-                "mime_types": ["application/octet-stream"]
-                
-            },
-            {
-                name:"XOR-32",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "Simple XOR-based 32-bit hash — 8 hex chars, basic XOR operation",
-                common_sources: ["simple applications", "embedded systems"], 
-                context: ["basic", "embedded"]
-                
-            }
+            {name:"Adler-32", john: nil, hashcat: nil, extended: false},
+            { name:"CRC-32B", john: nil, hashcat: nil, extended: false},
+            {name:"FCS-32", john: nil, hashcat: nil, extended: false},
+            {name:"GHash-32-3", john: nil, hashcat: nil, extended: false}, 
+            {name:"GHash-32-5", john: nil, hashcat: nil, extended: false},
+            {name:"FNV-132", john: nil, hashcat: nil, extended: false},
+            {name:"Fletcher-32", john: nil, hashcat: nil, extended: false},
+            {name:"Joaat", john: nil, hashcat: nil, extended: false},
+            {name:"ELF-32", john: nil, hashcat: nil, extended: false},
+            {name:"XOR-32", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{6}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"CRC-24",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "Cyclic Redundancy Check 24-bits — 6 hexadecimal chars, OpenPGP standard",
-                notes: ["Not cryptographic"],
-                context: ["checksum"], 
-                common_sources: ["OpenPGP", "RFID", "some file formats"]           
-            }
+            {name:"CRC-24", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(\$crc32\$[a-f0-9]{8}.)?[a-f0-9]{8}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"CRC-32",
-                john: "crc32",
-                hashcat: nil,
-                extended: false,
-                description: "Cyclic Redundancy Check 32-bit — 8 hex chars, most common checksum",
-                notes: ["Not cryptographic"]
-            }
+            {name:"CRC-32", john: "crc32", hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\\+[a-z0-9\\/.]{12}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "bfegg",
-                hashcat: nil,
-                extended: false,
-                name:"Eggdrop IRC Bot"
-            }
+            {name:"Eggdrop IRC Bot", john: "bfegg", hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-z0-9\\/.]{13}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"DES(Unix)",
-                john: "descrypt",
-                hashcat: 1500,
-                extended: false,
-                description: "DES-based Unix crypt — 13 chars, traditional Unix passwords",
-                notes: ["Only 8 char passwords", "weak salt"],
-                common_sources: ["/etc/passwd", "old Unix systems"], 
-                context: ["unix", "legacy"]   
-            },
-            {
-                name:"Traditional DES",
-                john: "descrypt",
-                hashcat: 1500,
-                extended: false
-                
-            },
-            {
-                name:"DEScrypt",
-                john: "descrypt",
-                hashcat: 1500,
-                extended: false,
-                description: "DES crypt implementation — 13 chars",
-                notes: ["Traditional Unix password hashing"],
-                common_sources: ["old Unix/Linux"], 
-                context: ["unix", "legacy"]
-            }
+            {name:"DES(Unix)", john: "descrypt", hashcat: 1500, extended: false},
+            {name:"Traditional DES", john: "descrypt", hashcat: 1500, extended: false},
+            {name:"DEScrypt", john: "descrypt", hashcat: 1500, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{16}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"MySQL323",
-                john: "mysql",
-                hashcat: 200,
-                extended: false,
-                description: "MySQL 3.23 password hash — 16 chars typical, but can be padded to 32 (hexadecimals)",
-                notes: ["Used in old MySQL databases", "Can be broken in seconds", "Susceptible to rainbow tables", "Limited to 8 character passwords", "Deprecated since MySQL 4.1"]
-            },
-            {
-                name:"DES(Oracle)",
-                john: nil,
-                hashcat: 3100,
-                extended: false,
-                description: "Oracle DES-based hash — 16 hex chars, Oracle specific"
-            },
-            {
-                name:"Half MD5",
-                john: nil,
-                hashcat: 5100,
-                extended: false,
-                description: "First half of MD5 hash — 16 hex chars, MD5 truncated",
-                notes: ["Weaker than full MD5"]
-            },
-            {
-                name:"Oracle 7-10g",
-                john: nil,
-                hashcat: 3100,
-                extended: false
-            },
-            {
-                name:"FNV-164",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "Fowler-Noll-Vo hash 64-bit —  16 hex chars, 64-bit version",
-                notes: ["Not cryptographic"]
-            },
-            {
-                name:"CRC-64",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "Cyclic Redundancy Check 64-bit — 16 hex chars, ISO 3309",
-                notes: ["Not cryptographic"]
-            }
+            {name:"MySQL323", john: "mysql", hashcat: 200, extended: false},
+            {name:"DES(Oracle)", john: nil, hashcat: 3100, extended: false},
+            {name:"Half MD5", john: nil, hashcat: 5100, extended: false},
+            {name:"Oracle 7-10g", john: nil, hashcat: 3100, extended: false},
+            {name:"FNV-164", john: nil, hashcat: nil, extended: false},
+            {name:"CRC-64", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-z0-9\\/.]{16}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"Cisco-PIX(MD5)",
-                john: "pix-md5",
-                hashcat: 2400,
-                extended: false,
-                description: "Cisco PIX MD5 hash"            
-            }
+            {name:"Cisco-PIX(MD5)", john: "pix-md5", hashcat: 2400, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\\([a-z0-9\\/+]{20}\\)\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "dominosec",
-                hashcat: 8700,
-                extended: false,
-                name:"Lotus Notes/Domino 6"
-            }
+            {name:"Lotus Notes/Domino 6", john: "dominosec", hashcat: 8700, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b_[a-z0-9\\/.]{19}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "bsdicrypt",
-                hashcat: nil,
-                extended: false,
-                name:"BSDi Crypt"
-            }
+            {name:"BSDi Crypt", john: "bsdicrypt", hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{24}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"CRC-96(ZIP)",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "CRC-96 used in some ZIP variants — 24 hex chars, extended CRC",
-                notes: ["Not cryptographic", "For some archive formats"]
-            }
+            {name:"CRC-96(ZIP)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-z0-9\\/.]{24}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"Crypt16",
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                description: "Extended crypt16 implementation", 
-                characteristics: "24 chars, extended DES crypt",
-                notes: ["Rarely used", "Used by some Unix variants"]
-            }
+            {name:"Crypt16", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(\$md2\$)?[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "md2",
-                hashcat: nil,
-                extended: false,
-                name:"MD2"
-            }
+            {name:"MD2", john: "md2", hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{32}(:.+)?\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"MD5",
-                john: "raw-md5",
-                hashcat: 0,
-                extended: false,
-                description: "MD5 cryptographic hash function",
-                characteristics: "32 chars, hexadecimal, unsalted",
-                notes: ["Used as checksum to verify data or file integrity", "MD5 is cryptographically broken as it is vulnerable to collision attacks"],
-                context: ["web", "checksum", "legacy", "password", "hash", "md5"],    
-                prefixes: ["md5", "hash", "checksum", "password"],
-                file_types: ["shadow", "htpasswd", "logs"],
-                mime_types: ["text/plain", "text/x-passwd"],
-                common_sources: ["web applications", "file integrity checks", "checksums", "legacy systems"]
-
-            },
-            {
-                name:"MD4",
-                john: "raw-md4",
-                hashcat: 900,
-                extended: false,
-                characteristics: "32 chars, legacy Microsoft systems",
-                prefixes: ["hash"],
-                context: ["hash"],
-                common_sources: ["Old Windows systems", "legacy applications"]
-            },
-            {
-                name:"Double MD5",
-                john: nil,
-                hashcat: 2600,
-                extended: false
-            },
-            {
-                name:"LM",
-                john: "lm",
-                hashcat: 3000,
-                extended: false,
-                description: "Windows LAN Manager hash", 
-                characteristics: "16 hex chars, all uppercase, split password",
-                notes: ["Mainly found in Windows SAM files(legacy Windows)", "Very weak", "no lowercase", "split passwords"],
-                common_sources: ["Windows SAM", "legacy Windows systems"], 
-                context: ["windows", "SAM"]
-            },
-            {
-                name:"RIPEMD-128",
-                john: "ripemd-128",
-                hashcat: nil,
-                extended: false
-            },
-            {
-                name:"Haval-128",
-                john: "haval-128-4",
-                hashcat: nil,
-                extended: false
-            },
-            {
-                 name:"Tiger-128",
-                john: nil,
-                hashcat: nil,
-                extended: false
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Skein-256(128)"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Skein-512(128)"
-            },
-            {
-                john: "lotus5",
-                hashcat: 8600,
-                extended: false,
-                name:"Lotus Notes/Domino 5"
-            },
-            {
-                john: nil,
-                hashcat: 23,
-                extended: false,
-                name:"Skype"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: true,
-                name:"ZipMonster"
-            },
-            {
-                john: nil,
-                hashcat: 11000,
-                extended: true,
-                name:"PrestaShop"
-            },
-            {
-                john: nil,
-                hashcat: 3500,
-                extended: true,
-                name:"md5(md5(md5($pass)))"
-            },
-            {
-                john: nil,
-                hashcat: 4300,
-                extended: true,
-                name:"md5(strtoupper(md5($pass)))"
-            },
-            {
-                john: nil,
-                hashcat: 4400,
-                extended: true,
-                name:"md5(sha1($pass))"
-            },
-            {
-                john: nil,
-                hashcat: 10,
-                extended: true,
-                name:"md5($pass.$salt)"
-            },
-            {
-                john: nil,
-                hashcat: 20,
-                extended: true,
-                name:"md5($salt.$pass)"
-            },
-            {
-                john: nil,
-                hashcat: 30,
-                extended: true,
-                name:"md5(unicode($pass).$salt)"
-            },
-            {
-                john: nil,
-                hashcat: 40,
-                extended: true,
-                name:"md5($salt.unicode($pass))"
-            },
-            {
-                john: "hmac-md5",
-                hashcat: 50,
-                extended: true,
-                name:"HMAC-MD5 (key = $pass)"
-            },
-            {
-                john: "hmac-md5",
-                hashcat: 60,
-                extended: true,
-                name:"HMAC-MD5 (key = $salt)"
-            },
-            {
-                john: nil,
-                hashcat: 3610,
-                extended: true,
-                name:"md5(md5($salt).$pass)"
-            },
-            {
-                john: nil,
-                hashcat: 3710,
-                extended: true,
-                name:"md5($salt.md5($pass))"
-            },
-            {
-                john: nil,
-                hashcat: 3720,
-                extended: true,
-                name:"md5($pass.md5($salt))"
-            },
-            {
-                john: nil,
-                hashcat: 3810,
-                extended: true,
-                name:"md5($salt.$pass.$salt)"
-            },
-            {
-                john: nil,
-                hashcat: 3910,
-                extended: true,
-                name:"md5(md5($pass).md5($salt))"
-            },
-            {
-                john: nil,
-                hashcat: 4010,
-                extended: true,
-                name:"md5($salt.md5($salt.$pass))"
-            },
-            {
-                john: nil,
-                hashcat: 4110,
-                extended: true,
-                name:"md5($salt.md5($pass.$salt))"
-            },
-            {
-                john: nil,
-                hashcat: 4210,
-                extended: true,
-                name:"md5($username.0.$pass)"
-            }
+            {name:"MD5", john: "raw-md5", hashcat: 0, extended: false},
+            {name:"MD4", john: "raw-md4", hashcat: 900, extended: false},
+            {name:"Double MD5", john: nil, hashcat: 2600, extended: false},
+            {name:"LM", john: "lm", hashcat: 3000, extended: false},
+            {name:"RIPEMD-128", john: "ripemd-128", hashcat: nil, extended: false},
+            {name:"Haval-128", john: "haval-128-4", hashcat: nil, extended: false},
+            {name:"Tiger-128", john: nil, hashcat: nil, extended: false},
+            {name:"Skein-256(128)", john: nil, hashcat: nil, extended: false},
+            {name:"Skein-512(128)", john: nil, hashcat: nil, extended: false},
+            {name:"Lotus Notes/Domino 5", john: "lotus5", hashcat: 8600, extended: false},
+            {name:"Skype", john: nil, hashcat: 23, extended: false},
+            {name:"ZipMonster", john: nil, hashcat: nil, extended: true},
+            {name:"PrestaShop", john: nil, hashcat: 11000, extended: true},
+            {name:"md5(md5(md5($pass)))", john: nil, hashcat: 3500, extended: true},
+            {name:"md5(strtoupper(md5($pass)))", john: nil, hashcat: 4300, extended: true},
+            {name:"md5(sha1($pass))", john: nil, hashcat: 4400, extended: true},
+            {name:"md5($pass.$salt)", john: nil, hashcat: 10, extended: true},
+            {name:"md5($salt.$pass)", john: nil, hashcat: 20, extended: true},
+            {name:"md5(unicode($pass).$salt)", john: nil, hashcat: 30, extended: true},
+            {name:"md5($salt.unicode($pass))", john: nil, hashcat: 40, extended: true},
+            {name:"HMAC-MD5 (key = $pass)", john: "hmac-md5", hashcat: 50, extended: true},
+            {name:"HMAC-MD5 (key = $salt)", john: "hmac-md5", hashcat: 60, extended: true},
+            {name:"md5(md5($salt).$pass)", john: nil, hashcat: 3610, extended: true},
+            {name:"md5($salt.md5($pass))", john: nil, hashcat: 3710, extended: true},
+            {name:"md5($pass.md5($salt))", john: nil, hashcat: 3720, extended: true},
+            {name:"md5($salt.$pass.$salt)", john: nil, hashcat: 3810, extended: true},
+            {name:"md5(md5($pass).md5($salt))", john: nil, hashcat: 3910, extended: true},
+            {name:"md5($salt.md5($salt.$pass))", john: nil, hashcat: 4010, extended: true},
+            {name:"md5($salt.md5($pass.$salt))", john: nil, hashcat: 4110, extended: true},
+            {name:"md5($username.0.$pass)", john: nil, hashcat: 4210, extended: true}
         ]
     },
     {
         extract_regex: Regexp.new('\b(\$snefru\$)?[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "snefru-128",
-                hashcat: nil,
-                extended: false,
-                name:"Snefru-128"
-            }
+            {name:"Snefru-128", john: "snefru-128", hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(\$NT\$)?[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"NTLM",
-                john: "nt",
-                hashcat: 1000,
-                extended: false,
-                description: "Windows NTLM authentication hash",
-                characteristics: "32 chars, Windows authentication, based on MD4",
-                notes: ["Hashcat Mode: 5600 (NetNTLMv2) - if network captured", "Hashcat Mode: 5500 (NetNTLMv1/NetNTLMv1+ESS) - legacy versions", "John Format: netntlm (for network hashes)", "John Format: netntlmv2 (v2 hashes)"],
-                context: ["windows", "SAM", "LSASS", "nt", "ntlm"],
-                prefixes: ["nt"],
-                file_types: ["ntds", "logs"],
-                mime_types: ["text/plain", "application/octet-stream"],
-                common_sources: ["Windows SAM", "Active Directory", "LSASS memory"]
-            }
+            {name:"NTLM", john: "nt", hashcat: 1000, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b([^\\\\\\/:*?\"<>|]{1,20}:)?[a-f0-9]{32}(:[^\\\\\\/:*?\"<>|]{1,20})?\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "mscach",
-                hashcat: 1100,
-                extended: false,
-                name:"Domain Cached Credentials"
-            }
+            {name:"Domain Cached Credentials", john: "mscach", hashcat: 1100, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b([^\\\\\\/:*?\"<>|]{1,20}:)?(\$DCC2\$10240#[^\\\\\\/:*?\"<>|]{1,20}#)?[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "mscach2",
-                hashcat: 2100,
-                extended: false,
-                name:"Domain Cached Credentials 2"
-            }
+            {name:"Domain Cached Credentials 2", john: "mscach2", hashcat: 2100, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b{SHA}[a-z0-9\\/+]{27}=\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "nsldap",
-                hashcat: 101,
-                extended: false,
-                name:"SHA-1(Base64)"
-            },
-            {
-                john: "nsldap",
-                hashcat: 101,
-                extended: false,
-                name:"Netscape LDAP SHA"
-            }
+            {name:"SHA-1(Base64)", john: "nsldap", hashcat: 101, extended: false},
+            {name:"Netscape LDAP SHA", john: "nsldap", hashcat: 101, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$1\$[a-z0-9\\/.]{0,8}\$[a-z0-9\\/.]{22}(:.*)?\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "md5crypt",
-                hashcat: 500,
-                extended: false,
-                name:"MD5 Crypt"
-            },
-            {
-                john: "md5crypt",
-                hashcat: 500,
-                extended: false,
-                name:"Cisco-IOS(MD5)"
-            },
-            {
-                john: "md5crypt",
-                hashcat: 500,
-                extended: false,
-                name:"FreeBSD MD5"
-            }
+            {name:"MD5 Crypt", john: "md5crypt", hashcat: 500, extended: false},
+            {name:"Cisco-IOS(MD5)", john: "md5crypt", hashcat: 500, extended: false},
+            {name:"FreeBSD MD5", john: "md5crypt", hashcat: 500, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b0x[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Lineage II C4"
-            }
+            {name:"Lineage II C4", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$H\$[a-z0-9\\/.]{31}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "phpass",
-                hashcat: 400,
-                extended: false,
-                name:"phpBB v3.x"
-            },
-            {
-                john: "phpass",
-                hashcat: 400,
-                extended: false,
-                name:"Wordpress v2.6.0/2.6.1"
-            },
-            {
-                john: "phpass",
-                hashcat: 400,
-                extended: false,
-                name:"PHPass' Portable Hash"
-            }
+            {name:"phpBB v3.x", john: "phpass", hashcat: 400, extended: false},
+            {name:"Wordpress v2.6.0/2.6.1", john: "phpass", hashcat: 400, extended: false},
+            {name:"PHPass' Portable Hash", john: "phpass", hashcat: 400, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$P\$[a-z0-9\\/.]{31}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "phpass",
-                hashcat: 400,
-                extended: false,
-                name:"Wordpress \u2265 v2.6.2"
-            },
-            {
-                john: "phpass",
-                hashcat: 400,
-                extended: false,
-                name:"Joomla \u2265 v2.5.18"
-            },
-            {
-                john: "phpass",
-                hashcat: 400,
-                extended: false,
-                name:"PHPass' Portable Hash"
-            }
+            {name:"Wordpress \u2265 v2.6.2", john: "phpass", hashcat: 400, extended: false},
+            {name:"Joomla \u2265 v2.5.18", john: "phpass", hashcat: 400, extended: false},
+            {name:"PHPass' Portable Hash", john: "phpass", hashcat: 400, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{32}:[a-z0-9]{2}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 21,
-                extended: false,
-                name:"osCommerce"
-            },
-            {
-                john: nil,
-                hashcat: 21,
-                extended: false,
-                name:"xt:Commerce"
-            }
+            {name:"osCommerce", john: nil, hashcat: 21, extended: false},
+            {name:"xt:Commerce", john: nil, hashcat: 21, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$apr1\$[a-z0-9\\/.]{0,8}\$[a-z0-9\\/.]{22}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 1600,
-                extended: false,
-                name:"MD5(APR)"
-            },
-            {
-                john: nil,
-                hashcat: 1600,
-                extended: false,
-                name:"Apache MD5"
-            },
-            {
-                john: nil,
-                hashcat: 1600,
-                extended: true,
-                name:"md5apr1"
-            }
+            {name:"MD5(APR)", john: nil, hashcat: 1600, extended: false},
+            {name:"Apache MD5", john: nil, hashcat: 1600, extended: false},
+            {name:"md5apr1", john: nil, hashcat: 1600, extended: true}
         ]
     },
     {
         extract_regex: Regexp.new('\b{smd5}[a-z0-9$\\/.]{31}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "aix-smd5",
-                hashcat: 6300,
-                extended: false,
-                name:"AIX(smd5)"
-            }
+            {name:"AIX(smd5)", john: "aix-smd5", hashcat: 6300, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{32}:[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 3721,
-                extended: false,
-                name:"WebEdition CMS"
-            }
+            {name:"WebEdition CMS", john: nil, hashcat: 3721, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{32}:.{5}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 2811,
-                extended: false,
-                name:"IP.Board \u2265 v2+"
-            }
+            {name:"IP.Board \u2265 v2+", john: nil, hashcat: 2811, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{32}:.{8}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 2811,
-                extended: false,
-                name:"MyBB \u2265 v1.2+"
-            }
+            {name:"MyBB \u2265 v1.2+", john: nil, hashcat: 2811, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-z0-9]{34}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"CryptoCurrency(Adress)"
-            }
+            {name:"CryptoCurrency(Adress)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{40}(:.+)?\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"SHA-1",
-                john: "raw-sha1",
-                hashcat: 100,
-                extended: false,
-                description: "SHA-1 cryptographic hash function", 
-                characteristics: "40 chars, hexadecimal, unsalted",
-                notes: ["Used for file verification", "found in git commits and legacy certificates"],
-                prefixes: ["sha1", "hash"],
-                context: ["sha1", "hash"]
-            },
-            {
-                john: nil,
-                hashcat: 4500,
-                extended: false,
-                name:"Double SHA-1",
-                context: ["sha1"]
-                #prefixes: ["sha1"]
-            },
-            {
-                name:"RIPEMD-160",
-                john: "ripemd-160",
-                hashcat: 6000,
-                extended: false,
-                characteristics: "40 chars, Bitcoin addresses, digital signatures",
-                notes: ["Rarely used for passwords"]
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Haval-160"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Tiger-160"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"HAS-160"
-            },
-            {
-                john: "raw-sha1-linkedin",
-                hashcat: 190,
-                extended: false,
-                name:"LinkedIn"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Skein-256(160)"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Skein-512(160)"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: true,
-                name:"MangosWeb Enhanced CMS"
-            },
-            {
-                john: nil,
-                hashcat: 4600,
-                extended: true,
-                name:"sha1(sha1(sha1($pass)))"
-            },
-            {
-                john: nil,
-                hashcat: 4700,
-                extended: true,
-                name:"sha1(md5($pass))"
-            },
-            {
-                john: nil,
-                hashcat: 110,
-                extended: true,
-                name:"sha1($pass.$salt)"
-            },
-            {
-                john: nil,
-                hashcat: 120,
-                extended: true,
-                name:"sha1($salt.$pass)"
-            },
-            {
-                john: nil,
-                hashcat: 130,
-                extended: true,
-                name:"sha1(unicode($pass).$salt)"
-            },
-            {
-                john: nil,
-                hashcat: 140,
-                extended: true,
-                name:"sha1($salt.unicode($pass))"
-            },
-            {
-                john: "hmac-sha1",
-                hashcat: 150,
-                extended: true,
-                name:"HMAC-SHA1 (key = $pass)"
-            },
-            {
-                john: "hmac-sha1",
-                hashcat: 160,
-                extended: true,
-                name:"HMAC-SHA1 (key = $salt)"
-            },
-            {
-                john: nil,
-                hashcat: 4710,
-                extended: true,
-                name:"sha1($salt.$pass.$salt)"
-            }
+            {name:"SHA-1", john: "raw-sha1", hashcat: 100, extended: false},
+            {name:"Double SHA-1", john: nil, hashcat: 4500, extended: false},
+            {name:"RIPEMD-160", john: "ripemd-160", hashcat: 6000, extended: false},
+            {name:"Haval-160", john: nil, hashcat: nil, extended: false},
+            {name:"Tiger-160", john: nil, hashcat: nil, extended: false},
+            {name:"HAS-160", john: nil, hashcat: nil, extended: false},
+            {name:"LinkedIn", john: "raw-sha1-linkedin", hashcat: 190, extended: false},
+            {name:"Skein-256(160)", john: nil, hashcat: nil, extended: false},
+            {name:"Skein-512(160)", john: nil, hashcat: nil, extended: false},
+            {name:"MangosWeb Enhanced CMS", john: nil, hashcat: nil, extended: true},
+            {name:"sha1(sha1(sha1($pass)))", john: nil, hashcat: 4600, extended: true},
+            {name:"sha1(md5($pass))", john: nil, hashcat: 4700, extended: true},
+            {name:"sha1($pass.$salt)", john: nil, hashcat: 110, extended: true},
+            {name:"sha1($salt.$pass)", john: nil, hashcat: 120, extended: true},
+            {name:"sha1(unicode($pass).$salt)", john: nil, hashcat: 130, extended: true},
+            {name:"sha1($salt.unicode($pass))", john: nil, hashcat: 140, extended: true},
+            {name:"HMAC-SHA1 (key = $pass)", john: "hmac-sha1", hashcat: 150, extended: true},
+            {name:"HMAC-SHA1 (key = $salt)", john: "hmac-sha1", hashcat: 160, extended: true},
+            {name:"sha1($salt.$pass.$salt)", john: nil, hashcat: 4710, extended: true}
         ]
     },
     {
         extract_regex: Regexp.new('\b\\*[a-f0-9]{40}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "mysql-sha1",
-                hashcat: 300,
-                extended: false,
-                name:"MySQL5.x"
-            },
-            {
-                name:"MySQL4.1",
-                john: "mysql-sha1",
-                hashcat: 300,
-                extended: false,
-                description: "MySQL double SHA1 implementation", 
-                characteristics: "40 chars, double SHA1 with salt",
-                notes: ["Used in database export"]
-            }
+            {name:"MySQL5.x", john: "mysql-sha1", hashcat: 300, extended: false},
+            {name:"MySQL4.1", john: "mysql-sha1", hashcat: 300, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-z0-9]{43}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 5700,
-                extended: false,
-                name:"Cisco-IOS(SHA-256)"
-            }
+            {name:"Cisco-IOS(SHA-256)", john: nil, hashcat: 5700, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b{SSHA}[a-z0-9\\/+]{38}==', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "nsldaps",
-                hashcat: 111,
-                extended: false,
-                name:"SSHA-1(Base64)"
-            },
-            {
-                john: "nsldaps",
-                hashcat: 111,
-                extended: false,
-                name:"Netscape LDAP SSHA"
-            },
-            {
-                john: "nsldaps",
-                hashcat: 111,
-                extended: true,
-                name:"nsldaps"
-            }
+            {name:"SSHA-1(Base64)", john: "nsldaps", hashcat: 111, extended: false},
+            {name:"Netscape LDAP SSHA", john: "nsldaps", hashcat: 111, extended: false},
+            {name:"nsldaps", john: "nsldaps", hashcat: 111, extended: true}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-z0-9=]{47}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "fortigate",
-                hashcat: 7000,
-                extended: false,
-                name:"Fortigate(FortiOS)"
-            }
+            {name:"Fortigate(FortiOS)", john: "fortigate", hashcat: 7000, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{48}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Haval-192"
-            },
-            {
-                john: "tiger",
-                hashcat: nil,
-                extended: false,
-                name:"Tiger-192"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"SHA-1(Oracle)"
-            },
-            {
-                john: "xsha",
-                hashcat: 122,
-                extended: false,
-                name:"OSX v10.4"
-            },
-            {
-                john: "xsha",
-                hashcat: 122,
-                extended: false,
-                name:"OSX v10.5"
-            },
-            {
-                john: "xsha",
-                hashcat: 122,
-                extended: false,
-                name:"OSX v10.6"
-            }
+            {name:"Haval-192", john: nil, hashcat: nil, extended: false},
+            {name:"Tiger-192", john: "tiger", hashcat: nil, extended: false},
+            {name:"SHA-1(Oracle)", john: nil, hashcat: nil, extended: false},
+            {name:"OSX v10.4", john: "xsha", hashcat: 122, extended: false},
+            {name:"OSX v10.5", john: "xsha", hashcat: 122, extended: false},
+            {name:"OSX v10.6", john: "xsha", hashcat: 122, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{51}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Palshop CMS"
-            }
+            {name:"Palshop CMS", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-z0-9]{51}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"CryptoCurrency(PrivateKey)"
-            }
+            {name:"CryptoCurrency(PrivateKey)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b{ssha1}[0-9]{2}\$[a-z0-9$\\/.]{44}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "aix-ssha1",
-                hashcat: 6700,
-                extended: false,
-                name:"AIX(ssha1)"
-            }
+            {name:"AIX(ssha1)", john: "aix-ssha1", hashcat: 6700, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b0x0100[a-f0-9]{48}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "mssql05",
-                hashcat: 132,
-                extended: false,
-                name:"MSSQL(2005)"
-            },
-            {
-                john: "mssql05",
-                hashcat: 132,
-                extended: false,
-                name:"MSSQL(2008)"
-            }
+            {name:"MSSQL(2005)", john: "mssql05", hashcat: 132, extended: false},
+            {name:"MSSQL(2008)", john: "mssql05", hashcat: 132, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(\$md5,rounds=[0-9]+\$|\$md5\$rounds=[0-9]+\$|\$md5\$)[a-z0-9\\/.]{0,16}(\$|\$\$)[a-z0-9\\/.]{22}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "sunmd5",
-                hashcat: 3300,
-                extended: false,
-                name:"Sun MD5 Crypt"
-            }
+            {name:"Sun MD5 Crypt", john: "sunmd5", hashcat: 3300, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{56}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "raw-sha224",
-                hashcat: nil,
-                extended: false,
-                name:"SHA-224"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Haval-224"
-            },
-            {
-                john: nil,
-                hashcat: 17300,
-                extended: false,
-                name:"SHA3-224"
-            },
-            {
-                john: nil,
-                hashcat: 17700,
-                extended: false,
-                name:"Keccak-224"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Skein-256(224)"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Skein-512(224)"
-            }
+            {name:"SHA-224", john: "raw-sha224", hashcat: nil, extended: false},
+            {name:"Haval-224", john: nil, hashcat: nil, extended: false},
+            {name:"SHA3-224", john: nil, hashcat: 17300, extended: false},
+            {name:"Keccak-224", john: nil, hashcat: 17700, extended: false},
+            {name:"Skein-256(224)", john: nil, hashcat: nil, extended: false},
+            {name:"Skein-512(224)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(\$2[axy]|\$2)\$[0-9]{2}\$[a-z0-9\\/.]{53}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "bcrypt",
-                hashcat: 3200,
-                extended: false,
-                name:"Blowfish(OpenBSD)"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Woltlab Burning Board 4.x"
-            },
-            {
-                john: "bcrypt",
-                hashcat: 3200,
-                extended: false,
-                name:"bcrypt"
-            }
+            {name:"Blowfish(OpenBSD)", john: "bcrypt", hashcat: 3200, extended: false},
+            {name:"Woltlab Burning Board 4.x", john: nil, hashcat: nil, extended: false},
+            {name:"bcrypt", john: "bcrypt", hashcat: 3200, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{40}:[a-f0-9]{16}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                 name:"Android PIN",
-                john: nil,
-                hashcat: 5800,
-                extended: false,
-                description: "Android PIN/Password hash", 
-                characteristics: "40 chars hash + 16 chars salt, SHA1 + MD5",
-                notes: ["found in android gesture.key files"]
-            }
+            {name:"Android PIN", john: nil, hashcat: 5800, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(S:)?[a-f0-9]{40}(:)?[a-f0-9]{20}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "oracle11",
-                hashcat: 112,
-                extended: false,
-                name:"Oracle 11g/12c"
-            }
+            {name:"Oracle 11g/12c", john: "oracle11", hashcat: 112, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$bcrypt-sha256\$(2[axy]|2)\\,[0-9]+\$[a-z0-9\\/.]{22}\$[a-z0-9\\/.]{31}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"bcrypt(SHA-256)"
-            }
+            {name:"bcrypt(SHA-256)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{32}:.{3}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 2611,
-                extended: false,
-                name:"vBulletin < v3.8.5"
-            }
+            {name:"vBulletin < v3.8.5", john: nil, hashcat: 2611, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{32}:.{30}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 2711,
-                extended: false,
-                name:"vBulletin \u2265 v3.8.5"
-            }
+            {name:"vBulletin \u2265 v3.8.5", john: nil, hashcat: 2711, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(\$snefru\$)?[a-f0-9]{64}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "snefru-256",
-                hashcat: nil,
-                extended: false,
-                name:"Snefru-256"
-            }
+            {name:"Snefru-256", john: "snefru-256", hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{64}(:.+)?\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "raw-sha256",
-                hashcat: 1400,
-                extended: false,
-                name:"SHA-256"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"RIPEMD-256"
-            },
-            {
-                john: "haval-256-3",
-                hashcat: nil,
-                extended: false,
-                name:"Haval-256"
-            },
-            {
-                john: "gost",
-                hashcat: 6900,
-                extended: false,
-                name:"GOST R 34.11-94"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"GOST CryptoPro S-Box"
-            },
-            {
-                john: nil,
-                hashcat: 17400,
-                extended: false,
-                name:"SHA3-256"
-            },
-            {
-                john: "raw-keccak-256",
-                hashcat: 17800,
-                extended: false,
-                name:"Keccak-256"
-            },
-            {
-                john: "skein-256",
-                hashcat: nil,
-                extended: false,
-                name:"Skein-256"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Skein-512(256)"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: true,
-                name:"Ventrilo"
-            },
-            {
-                john: nil,
-                hashcat: 1410,
-                extended: true,
-                name:"sha256($pass.$salt)"
-            },
-            {
-                john: nil,
-                hashcat: 1420,
-                extended: true,
-                name:"sha256($salt.$pass)"
-            },
-            {
-                john: nil,
-                hashcat: 1430,
-                extended: true,
-                name:"sha256(unicode($pass).$salt)"
-            },
-            {
-                john: nil,
-                hashcat: 1440,
-                extended: true,
-                name:"sha256($salt.unicode($pass))"
-            },
-            {
-                john: "hmac-sha256",
-                hashcat: 1450,
-                extended: true,
-                name:"HMAC-SHA256 (key = $pass)"
-            },
-            {
-                john: "hmac-sha256",
-                hashcat: 1460,
-                extended: true,
-                name:"HMAC-SHA256 (key = $salt)"
-            }
+            {name:"SHA-256", john: "raw-sha256", hashcat: 1400, extended: false},
+            {name:"RIPEMD-256", john: nil, hashcat: nil, extended: false},
+            {name:"Haval-256", john: "haval-256-3", hashcat: nil, extended: false},
+            {name:"GOST R 34.11-94", john: "gost", hashcat: 6900, extended: false},
+            {name:"GOST CryptoPro S-Box", john: nil, hashcat: nil, extended: false},
+            {name:"SHA3-256", john: nil, hashcat: 17400, extended: false},
+            {name:"Keccak-256", john: "raw-keccak-256", hashcat: 17800, extended: false},
+            {name:"Skein-256", john: "skein-256", hashcat: nil, extended: false},
+            {name:"Skein-512(256)", john: nil, hashcat: nil, extended: false},
+            {name:"Ventrilo", john: nil, hashcat: nil, extended: true},
+            {name:"sha256($pass.$salt)", john: nil, hashcat: 1410, extended: true},
+            {name:"sha256($salt.$pass)", john: nil, hashcat: 1420, extended: true},
+            {name:"sha256(unicode($pass).$salt)", john: nil, hashcat: 1430, extended: true},
+            {name:"sha256($salt.unicode($pass))", john: nil, hashcat: 1440, extended: true},
+            {name:"HMAC-SHA256 (key = $pass)", john: "hmac-sha256", hashcat: 1450, extended: true},
+            {name:"HMAC-SHA256 (key = $salt)", john: "hmac-sha256", hashcat: 1460, extended: true}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{32}:[a-z0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 11,
-                extended: false,
-                name:"Joomla < v2.5.18"
-            }
+            {name:"Joomla < v2.5.18", john: nil, hashcat: 11, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{32}:[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"SAM(LM_Hash:NT_Hash)"
-            }
+            {name:"SAM(LM_Hash:NT_Hash)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(\$chap\$0\\*)?[a-f0-9]{32}[\\*:][a-f0-9]{32}(:[0-9]{2})?\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "chap",
-                hashcat: 4800,
-                extended: false,
-                name:"MD5(Chap)"
-            },
-            {
-                john: "chap",
-                hashcat: 4800,
-                extended: false,
-                name:"iSCSI CHAP Authentication"
-            }
+            {name:"MD5(Chap)", john: "chap", hashcat: 4800, extended: false},
+            {name:"iSCSI CHAP Authentication", john: "chap", hashcat: 4800, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$episerver\$\\*0\\*[a-z0-9\\/=+]+\\*[a-z0-9\\/=+]{27,28}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "episerver",
-                hashcat: 141,
-                extended: false,
-                name:"EPiServer 6.x < v4"
-            }
+            {name:"EPiServer 6.x < v4", john: "episerver", hashcat: 141, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b{ssha256}[0-9]{2}\$[a-z0-9$\\/.]{60}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "aix-ssha256",
-                hashcat: 6400,
-                extended: false,
-                name:"AIX(ssha256)"
-            }
+            {name:"AIX(ssha256)", john: "aix-ssha256", hashcat: 6400, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{80}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"RIPEMD-320"
-            }
+            {name:"RIPEMD-320", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$episerver\$\\*1\\*[a-z0-9\\/=+]+\\*[a-z0-9\\/=+]{42,43}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "episerver",
-                hashcat: 1441,
-                extended: false,
-                name:"EPiServer 6.x \u2265 v4"
-            }
+            {name:"EPiServer 6.x \u2265 v4", john: "episerver", hashcat: 1441, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b0x0100[a-f0-9]{88}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "mssql",
-                hashcat: 131,
-                extended: false,
-                name:"MSSQL(2000)"
-            }
+            {name:"MSSQL(2000)", john: "mssql", hashcat: 131, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{96}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "raw-sha384",
-                hashcat: 10800,
-                extended: false,
-                name:"SHA-384"
-            },
-            {
-                john: nil,
-                hashcat: 17500,
-                extended: false,
-                name:"SHA3-384"
-            },
-            {
-                john: nil,
-                hashcat: 17900,
-                extended: false,
-                name:"Keccak-384"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Skein-512(384)"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Skein-1024(384)"
-            }
+            {name:"SHA-384", john: "raw-sha384", hashcat: 10800, extended: false},
+            {name:"SHA3-384", john: nil, hashcat: 17500, extended: false},
+            {name:"Keccak-384", john: nil, hashcat: 17900, extended: false},
+            {name:"Skein-512(384)", john: nil, hashcat: nil, extended: false},
+            {name:"Skein-1024(384)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b{SSHA512}[a-z0-9\\/+]{96}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "ssha512",
-                hashcat: 1711,
-                extended: false,
-                name:"SSHA-512(Base64)"
-            },
-            {
-                john: "ssha512",
-                hashcat: 1711,
-                extended: false,
-                name:"LDAP(SSHA-512)"
-            }
+            {name:"SSHA-512(Base64)", john: "ssha512", hashcat: 1711, extended: false},
+            {name:"LDAP(SSHA-512)", john: "ssha512", hashcat: 1711, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b{ssha512}[0-9]{2}\$[a-z0-9\\/.]{16,48}\$[a-z0-9\\/.]{86}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "aix-ssha512",
-                hashcat: 6500,
-                extended: false,
-                name:"AIX(ssha512)"
-            }
+            {name:"AIX(ssha512)", john: "aix-ssha512", hashcat: 6500, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{128}(:.+)?\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "raw-sha512",
-                hashcat: 1700,
-                extended: false,
-                name:"SHA-512"
-            },
-            {
-                john: "whirlpool",
-                hashcat: 6100,
-                extended: false,
-                name:"Whirlpool"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Salsa10"
-            },         
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Salsa20"
-            },
-            {
-                john: "raw-sha3",
-                hashcat: 17600,
-                extended: false,
-                name:"SHA3-512"
-            },
-            {
-                john: "raw-keccak",
-                hashcat: 18000,
-                extended: false,
-                name:"Keccak-512"
-            },
-            {
-                john: "skein-512",
-                hashcat: nil,
-                extended: false,
-                name:"Skein-512"
-            },
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Skein-1024(512)"
-            },
-            {
-                john: nil,
-                hashcat: 1710,
-                extended: true,
-                name:"sha512($pass.$salt)"
-            },
-            {
-                john: nil,
-                hashcat: 1720,
-                extended: true,
-                name:"sha512($salt.$pass)"
-            },
-            {
-                john: nil,
-                hashcat: 1730,
-                extended: true,
-                name:"sha512(unicode($pass).$salt)"
-            },
-            {
-                john: nil,
-                hashcat: 1740,
-                extended: true,
-                name:"sha512($salt.unicode($pass))"
-            },
-            {
-                john: "hmac-sha512",
-                hashcat: 1750,
-                extended: true,
-                name:"HMAC-SHA512 (key = $pass)"
-            },
-            {
-                john: "hmac-sha512",
-                hashcat: 1760,
-                extended: true,
-                name:"HMAC-SHA512 (key = $salt)"
-            }
+            {name:"SHA-512", john: "raw-sha512", hashcat: 1700, extended: false},
+            {name:"Whirlpool", john: "whirlpool", hashcat: 6100, extended: false},
+            {name:"Salsa10", john: nil, hashcat: nil, extended: false},         
+            {name:"Salsa20", john: nil, hashcat: nil, extended: false},
+            {name:"SHA3-512", john: "raw-sha3", hashcat: 17600, extended: false},
+            {name:"Keccak-512", john: "raw-keccak", hashcat: 18000, extended: false},
+            {name:"Skein-512", john: "skein-512", hashcat: nil, extended: false},
+            {name:"Skein-1024(512)", john: nil, hashcat: nil, extended: false},
+            {name:"sha512($pass.$salt)", john: nil, hashcat: 1710, extended: true},
+            {name:"sha512($salt.$pass)", john: nil, hashcat: 1720, extended: true},
+            {name:"sha512(unicode($pass).$salt)", john: nil, hashcat: 1730, extended: true},
+            {name:"sha512($salt.unicode($pass))", john: nil, hashcat: 1740, extended: true},
+            {name:"HMAC-SHA512 (key = $pass)", john: "hmac-sha512", hashcat: 1750, extended: true},
+            {name:"HMAC-SHA512 (key = $salt)", john: "hmac-sha512", hashcat: 1760, extended: true}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{136}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "xsha512",
-                hashcat: 1722,
-                extended: false,
-                name:"OSX v10.7"
-            }
+            {name:"OSX v10.7", john: "xsha512", hashcat: 1722, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b0x0200[a-f0-9]{136}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "msql12",
-                hashcat: 1731,
-                extended: false,
-                name:"MSSQL(2012)"
-            },
-            {
-                john: "msql12",
-                hashcat: 1731,
-                extended: false,
-                name:"MSSQL(2014)"
-            }
+            {name:"MSSQL(2012)", john: "msql12", hashcat: 1731, extended: false},
+            {name:"MSSQL(2014)", john: "msql12", hashcat: 1731, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$ml\$[0-9]+\$[a-f0-9]{64}\$[a-f0-9]{128}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "pbkdf2-hmac-sha512",
-                hashcat: 7100,
-                extended: false,
-                name:"OSX v10.8"
-            },
-            {
-                john: "pbkdf2-hmac-sha512",
-                hashcat: 7100,
-                extended: false,
-                name:"OSX v10.9"
-            }
+            {name:"OSX v10.8", john: "pbkdf2-hmac-sha512", hashcat: 7100, extended: false},
+            {name:"OSX v10.9", john: "pbkdf2-hmac-sha512", hashcat: 7100, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{256}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Skein-1024"
-            }
+            {name:"Skein-1024", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\bgrub\\.pbkdf2\\.sha512\\.[0-9]+\\.([a-f0-9]{128,2048}\\.|[0-9]+\\.)?[a-f0-9]{128}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 7200,
-                extended: false,
-                name:"GRUB 2"
-            }
+            {name:"GRUB 2", john: nil, hashcat: 7200, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\bsha1\$[a-z0-9]+\$[a-f0-9]{40}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 124,
-                extended: false,
-                name:"Django(SHA-1)"
-            }
+            {name:"Django(SHA-1)", john: nil, hashcat: 124, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{49}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "citrix_ns10",
-                hashcat: 8100,
-                extended: false,
-                name:"Citrix Netscaler"
-            }
+            {name:"Citrix Netscaler", john: "citrix_ns10", hashcat: 8100, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$S\$[a-z0-9\\/.]{52}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "drupal7",
-                hashcat: 7900,
-                extended: false,
-                name:"Drupal > v7.x"
-            }
+            {name:"Drupal > v7.x", john: "drupal7", hashcat: 7900, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$5\$(rounds=[0-9]+\$)?[a-z0-9\\/.]{0,16}\$[a-z0-9\\/.]{43}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "sha256crypt",
-                hashcat: 7400,
-                extended: false,
-                name:"SHA-256 Crypt"
-            }
+            {name:"SHA-256 Crypt", john: "sha256crypt", hashcat: 7400, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b0x[a-f0-9]{4}[a-f0-9]{16}[a-f0-9]{64}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "sybasease",
-                hashcat: 8000,
-                extended: false,
-                name:"Sybase ASE"
-            }
+            {name:"Sybase ASE", john: "sybasease", hashcat: 8000, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$6\$(rounds=[0-9]+\$)?[a-z0-9\\/.]{0,16}\$[a-z0-9\\/.]{86}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"SHA-512 Crypt",
-                john: "sha512crypt",
-                hashcat: 1800,
-                extended: false,
-                characteristics: "$6$ prefix, includes salt, 96-106 chars", 
-                notes: ["Industry standard for modern Linux systems"]
-               
-            }
+            {name:"SHA-512 Crypt", john: "sha512crypt", hashcat: 1800, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$sha\$[a-z0-9]{1,16}\$([a-f0-9]{32}|[a-f0-9]{40}|[a-f0-9]{64}|[a-f0-9]{128}|[a-f0-9]{140})\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Minecraft(AuthMe Reloaded)"
-            }
+            {name:"Minecraft(AuthMe Reloaded)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\bsha256\$[a-z0-9]+\$[a-f0-9]{64}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Django(SHA-256)"
-            }
+            {name:"Django(SHA-256)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\bsha384\$[a-z0-9]+\$[a-f0-9]{96}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Django(SHA-384)"
-            }
+            {name:"Django(SHA-384)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\bcrypt1:[a-z0-9+=]{12}:[a-z0-9+=]{12}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Clavister Secure Gateway"
-            }
+            {name:"Clavister Secure Gateway", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{112}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Cisco VPN Client(PCF-File)"
-            }
+            {name:"Cisco VPN Client(PCF-File)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{1329}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Microsoft MSTSC(RDP-File)"
-            }
+            {name:"Microsoft MSTSC(RDP-File)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[^\\\\\\/:*?\"<>|]{1,20}[:]{2,3}([^\\\\\\/:*?\"<>|]{1,20})?:[a-f0-9]{48}:[a-f0-9]{48}:[a-f0-9]{16}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "netntlm",
-                hashcat: 5500,
-                extended: false,
-                name:"NetNTLMv1-VANILLA / NetNTLMv1+ESS"
-            }
+            {name:"NetNTLMv1-VANILLA / NetNTLMv1+ESS", john: "netntlm", hashcat: 5500, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b([^\\\\\\/:*?\"<>|]{1,20}\\\\)?[^\\\\\\/:*?\"<>|]{1,20}[:]{2,3}([^\\\\\\/:*?\"<>|]{1,20}:)?[^\\\\\\/:*?\"<>|]{1,20}:[a-f0-9]{32}:[a-f0-9]+\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "netntlmv2",
-                hashcat: 5600,
-                extended: false,
-                name:"NetNTLMv2"
-            }
+            {name:"NetNTLMv2", john: "netntlmv2", hashcat: 5600, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$(krb5pa|mskrb5)\$([0-9]{2})?\$.+\$[a-f0-9]{1,}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "krb5pa-md5",
-                hashcat: 7500,
-                extended: false,
-                name:"Kerberos 5 AS-REQ Pre-Auth"
-            }
+            {name:"Kerberos 5 AS-REQ Pre-Auth", john: "krb5pa-md5", hashcat: 7500, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$scram\$[0-9]+\$[a-z0-9\\/.]{16}\$sha-1=[a-z0-9\\/.]{27},sha-256=[a-z0-9\\/.]{43},sha-512=[a-z0-9\\/.]{86}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"SCRAM Hash"
-            }
+            {name:"SCRAM Hash", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{40}:[a-f0-9]{0,32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 7600,
-                extended: false,
-                name:"Redmine Project Management Web App"
-            }
+            {name:"Redmine Project Management Web App", john: nil, hashcat: 7600, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(.+)?\$[a-f0-9]{16}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "sapb",
-                hashcat: 7700,
-                extended: false,
-                name:"SAP CODVN B (BCODE)"
-            }
+            {name:"SAP CODVN B (BCODE)", john: "sapb", hashcat: 7700, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(.+)?\$[a-f0-9]{40}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "sapg",
-                hashcat: 7800,
-                extended: false,
-                name:"SAP CODVN F/G (PASSCODE)"
-            }
+            {name:"SAP CODVN F/G (PASSCODE)", john: "sapg", hashcat: 7800, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(.+\$)?[a-z0-9\\/.+]{30}(:.+)?\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "md5",
-                hashcat: 22,
-                extended: false,
-                name:"Juniper Netscreen/SSG(ScreenOS)"
-            }
+            {name:"Juniper Netscreen/SSG(ScreenOS)", john: "md5", hashcat: 22, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b0x[a-f0-9]{60}\\s0x[a-f0-9]{40}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 123,
-                extended: false,
-                name:"EPi"
-            }
+            {name:"EPi", john: nil, hashcat: 123, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{40}:[^*]{1,25}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 121,
-                extended: false,
-                name:"SMF \u2265 v1.1"
-            }
+            {name:"SMF \u2265 v1.1", john: nil, hashcat: 121, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(\$wbb3\$\\*1\\*)?[a-f0-9]{40}[:*][a-f0-9]{40}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "wbb3",
-                hashcat: 8400,
-                extended: false,
-                name:"Woltlab Burning Board 3.x"
-            }
+            {name:"Woltlab Burning Board 3.x", john: "wbb3", hashcat: 8400, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{130}(:[a-f0-9]{40})?\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 7300,
-                extended: false,
-                name:"IPMI2 RAKP HMAC-SHA1"
-            }
+            {name:"IPMI2 RAKP HMAC-SHA1", john: nil, hashcat: 7300, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{32}:[0-9]+:[a-z0-9_.+\\-]+@[a-z0-9\\-]+\\.[a-z0-9\\-.]+\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 6800,
-                extended: false,
-                name:"Lastpass"
-            }
+            {name:"Lastpass", john: nil, hashcat: 6800, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-z0-9\\/.]{16}([:$].{1,})?\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "asa-md5",
-                hashcat: 2410,
-                extended: false,
-                name:"Cisco-ASA(MD5)"
-            }
+            {name:"Cisco-ASA(MD5)", john: "asa-md5", hashcat: 2410, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$vnc\$\\*[a-f0-9]{32}\\*[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "vnc",
-                hashcat: nil,
-                extended: false,
-                name:"VNC"
-            }
+            {name:"VNC", john: "vnc", hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-z0-9]{32}(:([a-z0-9\\-]+\\.)?[a-z0-9\\-.]+\\.[a-z]{2,7}:.+:[0-9]+)?\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 8300,
-                extended: false,
-                name:"DNSSEC(NSEC3)"
-            }
+            {name:"DNSSEC(NSEC3)", john: nil, hashcat: 8300, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(user-.+:)?\$racf\$\\*.+\\*[a-f0-9]{16}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "racf",
-                hashcat: 8500,
-                extended: false,
-                name:"RACF"
-            }
+            {name:"RACF", john: "racf", hashcat: 8500, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$3\$\$[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"NTHash(FreeBSD Variant)"
-            }
+            {name:"NTHash(FreeBSD Variant)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$sha1\$[0-9]+\$[a-z0-9\\/.]{0,64}\$[a-z0-9\\/.]{28}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "sha1crypt",
-                hashcat: nil,
-                extended: false,
-                name:"SHA-1 Crypt"
-            }
+            {name:"SHA-1 Crypt", john: "sha1crypt", hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{70}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "hmailserver",
-                hashcat: 1421,
-                extended: false,
-                name:"hMailServer"
-            }
+            {name:"hMailServer", john: "hmailserver", hashcat: 1421, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[:\$][AB][:\$]([a-f0-9]{1,8}[:\$])?[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "mediawiki",
-                hashcat: 3711,
-                extended: false,
-                name:"MediaWiki"
-            }
+            {name:"MediaWiki", john: "mediawiki", hashcat: 3711, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{140}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Minecraft(xAuth)"
-            }
+            {name:"Minecraft(xAuth)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$pbkdf2(-sha1)?\$[0-9]+\$[a-z0-9\\/.]+\$[a-z0-9\\/.]{27}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"PBKDF2-SHA1(Generic)"
-            }
+            {name:"PBKDF2-SHA1(Generic)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$pbkdf2-sha256\$[0-9]+\$[a-z0-9\\/.]+\$[a-z0-9\\/.]{43}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "pbkdf2-hmac-sha256",
-                hashcat: nil,
-                extended: false,
-                name:"PBKDF2-SHA256(Generic)"
-            }
+            {name:"PBKDF2-SHA256(Generic)", john: "pbkdf2-hmac-sha256", hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$pbkdf2-sha512\$[0-9]+\$[a-z0-9\\/.]+\$[a-z0-9\\/.]{86}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"PBKDF2-SHA512(Generic)"
-            }
+            {name:"PBKDF2-SHA512(Generic)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$p5k2\$[0-9]+\$[a-z0-9\\/+=-]+\$[a-z0-9\\/+-]{27}=\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"PBKDF2(Cryptacular)"
-            }
+            {name:"PBKDF2(Cryptacular)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$p5k2\$[0-9]+\$[a-z0-9\\/.]+\$[a-z0-9\\/.]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"PBKDF2(Dwayne Litzenberger)"
-            }
+            {name:"PBKDF2(Dwayne Litzenberger)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b{FSHP[0123]\\|[0-9]+\\|[0-9]+}[a-z0-9\\/+=]+\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Fairly Secure Hashed Password"
-            }
+            {name:"Fairly Secure Hashed Password", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$PHPS\$.+\$[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "phps",
-                hashcat: 2612,
-                extended: false,
-                name:"PHPS"
-            }
+            {name:"PHPS", john: "phps", hashcat: 2612, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[0-9]{4}:[a-f0-9]{16}:[a-f0-9]{2080}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 6600,
-                extended: false,
-                name:"1Password(Agile Keychain)"
-            }
+            {name:"1Password(Agile Keychain)", john: nil, hashcat: 6600, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{64}:[a-f0-9]{32}:[0-9]{5}:[a-f0-9]{608}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 8200,
-                extended: false,
-                name:"1Password(Cloud Keychain)"
-            }
+            {name:"1Password(Cloud Keychain)", john: nil, hashcat: 8200, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{256}:[a-f0-9]{256}:[a-f0-9]{16}:[a-f0-9]{16}:[a-f0-9]{320}:[a-f0-9]{16}:[a-f0-9]{40}:[a-f0-9]{40}:[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 5300,
-                extended: false,
-                name:"IKE-PSK MD5"
-            }
+            {name:"IKE-PSK MD5", john: nil, hashcat: 5300, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{256}:[a-f0-9]{256}:[a-f0-9]{16}:[a-f0-9]{16}:[a-f0-9]{320}:[a-f0-9]{16}:[a-f0-9]{40}:[a-f0-9]{40}:[a-f0-9]{40}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 5400,
-                extended: false,
-                name:"IKE-PSK SHA1"
-            }
+            {name:"IKE-PSK SHA1", john: nil, hashcat: 5400, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-z0-9\\/+]{27}=\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 133,
-                extended: false,
-                name:"PeopleSoft"
-            }
+            {name:"PeopleSoft", john: nil, hashcat: 133, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\bcrypt\$[a-f0-9]{5}\$[a-z0-9\\/.]{13}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Django(DES Crypt Wrapper)"
-            }
+            {name:"Django(DES Crypt Wrapper)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(\$django\$\\*1\\*)?pbkdf2_sha256\$[0-9]+\$[a-z0-9]+\$[a-z0-9\\/+=]{44}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "django",
-                hashcat: 10000,
-                extended: false,
-                name:"Django(PBKDF2-HMAC-SHA256)"
-            }
+            {name:"Django(PBKDF2-HMAC-SHA256)", john: "django", hashcat: 10000, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\bpbkdf2_sha1\$[0-9]+\$[a-z0-9]+\$[a-z0-9\\/+=]{28}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Django(PBKDF2-HMAC-SHA1)"
-            }
+            {name:"Django(PBKDF2-HMAC-SHA1)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\bbcrypt(\$2[axy]|\$2)\$[0-9]{2}\$[a-z0-9\\/.]{53}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Django(bcrypt)"
-            }
+            {name:"Django(bcrypt)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\bmd5\$[a-f0-9]+\$[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"Django(MD5)"
-            }
+            {name:"Django(MD5)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\\{PKCS5S2\\}[a-z0-9\\/+]{64}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"PBKDF2(Atlassian)"
-            }
+            {name:"PBKDF2(Atlassian)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\bmd5[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: nil,
-                extended: false,
-                name:"PostgreSQL MD5"
-            }
+            {name:"PostgreSQL MD5", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\\([a-z0-9\\/+]{49}\\)\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 9100,
-                extended: false,
-                name:"Lotus Notes/Domino 8"
-            }
+            {name:"Lotus Notes/Domino 8", john: nil, hashcat: 9100, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\bSCRYPT:[0-9]{1,}:[0-9]{1}:[0-9]{1}:[a-z0-9:\\/+=]{1,}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 8900,
-                extended: false,
-                name:"scrypt"
-            }
+            {name:"scrypt", john: nil, hashcat: 8900, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$8\$[a-z0-9\\/.]{14}\$[a-z0-9\\/.]{43}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "cisco8",
-                hashcat: 9200,
-                extended: false,
-                name:"Cisco Type 8"
-            }
+            {name:"Cisco Type 8", john: "cisco8", hashcat: 9200, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$9\$[a-z0-9\\/.]{14}\$[a-z0-9\\/.]{43}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "cisco9",
-                hashcat: 9300,
-                extended: false,
-                name:"Cisco Type 9"
-            }
+            {name:"Cisco Type 9", john: "cisco9", hashcat: 9300, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$office\$\\*2007\\*[0-9]{2}\\*[0-9]{3}\\*[0-9]{2}\\*[a-z0-9]{32}\\*[a-z0-9]{32}\\*[a-z0-9]{40}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "office",
-                hashcat: 9400,
-                extended: false,
-                name:"Microsoft Office 2007"
-            }
+            {name:"Microsoft Office 2007", john: "office", hashcat: 9400, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$office\$\\*2010\\*[0-9]{6}\\*[0-9]{3}\\*[0-9]{2}\\*[a-z0-9]{32}\\*[a-z0-9]{32}\\*[a-z0-9]{64}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"Microsoft Office 2010",
-                john: nil,
-                hashcat: 9500,
-                extended: false
-            }
+            {name:"Microsoft Office 2010", john: nil, hashcat: 9500, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$office\$\\*2013\\*[0-9]{6}\\*[0-9]{3}\\*[0-9]{2}\\*[a-z0-9]{32}\\*[a-z0-9]{32}\\*[a-z0-9]{64}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"Microsoft Office 2013",
-                john: nil,
-                hashcat: 9600,
-                extended: false
-            }
+            {name:"Microsoft Office 2013", john: nil, hashcat: 9600, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$fde\$[0-9]{2}\$[a-f0-9]{32}\$[0-9]{2}\$[a-f0-9]{32}\$[a-f0-9]{3072}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "fde",
-                hashcat: 8800,
-                extended: false,
-                name:"Android FDE \u2264 4.3"
-            }
+            {name:"Android FDE \u2264 4.3", john: "fde", hashcat: 8800, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$oldoffice\$[01]\\*[a-f0-9]{32}\\*[a-f0-9]{32}\\*[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "oldoffice",
-                hashcat: 9700,
-                extended: false,
-                name:"Microsoft Office \u2264 2003 (MD5+RC4)"
-            },
-            {
-                john: "oldoffice",
-                hashcat: 9710,
-                extended: false,
-                name:"Microsoft Office \u2264 2003 (MD5+RC4) collider-mode #1"
-            },
-            {
-                john: "oldoffice",
-                hashcat: 9720,
-                extended: false,
-                name:"Microsoft Office \u2264 2003 (MD5+RC4) collider-mode #2"
-            }
+            {name:"Microsoft Office \u2264 2003 (MD5+RC4)", john: "oldoffice", hashcat: 9700, extended: false},
+            {name:"Microsoft Office \u2264 2003 (MD5+RC4) collider-mode #1", john: "oldoffice", hashcat: 9710, extended: false},
+            {name:"Microsoft Office \u2264 2003 (MD5+RC4) collider-mode #2", john: "oldoffice", hashcat: 9720, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$oldoffice\$[34]\\*[a-f0-9]{32}\\*[a-f0-9]{32}\\*[a-f0-9]{40}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 9800,
-                extended: false,
-                name:"Microsoft Office \u2264 2003 (SHA1+RC4)"
-            },
-            {
-                john: nil,
-                hashcat: 9810,
-                extended: false,
-                name:"Microsoft Office \u2264 2003 (SHA1+RC4) collider-mode #1"
-            },
-            {
-                john: nil,
-                hashcat: 9820,
-                extended: false,
-                name:"Microsoft Office \u2264 2003 (SHA1+RC4) collider-mode #2"
-            }
+            {name:"Microsoft Office \u2264 2003 (SHA1+RC4)", john: nil, hashcat: 9800, extended: false},
+            {name:"Microsoft Office \u2264 2003 (SHA1+RC4) collider-mode #1", john: nil, hashcat: 9810, extended: false},
+            {name:"Microsoft Office \u2264 2003 (SHA1+RC4) collider-mode #2", john: nil, hashcat: 9820, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(\$radmin2\$)?[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "radmin",
-                hashcat: 9900,
-                extended: false,
-                name:"RAdmin v2.x"
-            }
+            {name:"RAdmin v2.x", john: "radmin", hashcat: 9900, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b{x-issha,\\s[0-9]{4}}[a-z0-9\\/+=]+\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: "saph",
-                hashcat: 10300,
-                extended: false,
-                name:"SAP CODVN H (PWDSALTEDHASH) iSSHA-1"
-            }
+            {name:"SAP CODVN H (PWDSALTEDHASH) iSSHA-1", john: "saph", hashcat: 10300, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$cram_md5\$[a-z0-9\\/+=-]+\$[a-z0-9\\/+=-]{52}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 10200,
-                extended: false,
-                name:"CRAM-MD5"
-            }
+            {name:"CRAM-MD5", john: nil, hashcat: 10200, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{16}:2:4:[a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                john: nil,
-                hashcat: 10100,
-                extended: false,
-                name:"SipHash"
-            }
+            {name:"SipHash", john: nil, hashcat: 10100, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-f0-9]{4,}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"Cisco Type 7",
-                john: nil,
-                hashcat: nil,
-                extended: true
-            }
+            {name:"Cisco Type 7", john: nil, hashcat: nil, extended: true}
         ]
     },
     {
         extract_regex: Regexp.new('\b[a-z0-9\\/.]{13,}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"BigCrypt",
-                john: "bigcrypt",
-                hashcat: nil,
-                extended: true,
-                description: "Extended DES crypt — 13+ chars, extended length",
-                notes: ["Rarely used", "Used in some Unix variants"], 
-                common_sources: ["some Unix variants"], 
-                context: ["unix", "extended"]
-            }
+            {name:"BigCrypt", john: "bigcrypt", hashcat: nil, extended: true}
         ]
     },
     {
         extract_regex: Regexp.new('\b(\$cisco4\$)?[a-z0-9\\/.]{43}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"Cisco Type 4",
-                john: "cisco4",
-                hashcat: nil,
-                extended: false
-            }
+            {name:"Cisco Type 4", john: "cisco4", hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\bbcrypt_sha256\$\$(2[axy]|2)\$[0-9]+\$[a-z0-9\\/.]{53}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"Django(bcrypt-SHA256)",
-                john: nil,
-                hashcat: nil,
-                extended: false
-            }
+            {name:"Django(bcrypt-SHA256)", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$postgres\$.[^\\*]+[*:][a-f0-9]{1,32}[*:][a-f0-9]{32}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"PostgreSQL Challenge-Response Authentication (MD5)",
-                john: "postgres",
-                hashcat: 11100,
-                extended: false
-            }
+            {name:"PostgreSQL Challenge-Response Authentication (MD5)", john: "postgres", hashcat: 11100, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$siemens-s7\$[0-9]{1}\$[a-f0-9]{40}\$[a-f0-9]{40}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"Siemens-S7",
-                john: "siemens-s7",
-                hashcat: nil,
-                extended: false
-            }
+            {name:"Siemens-S7", john: "siemens-s7", hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(\$pst\$)?[a-f0-9]{8}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"Microsoft Outlook PST",
-                john: nil,
-                hashcat: nil,
-                extended: false
-            }
+            {name:"Microsoft Outlook PST", john: nil, hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\bsha256[:$][0-9]+[:$][a-z0-9\\/+]+[:$][a-z0-9\\/+]{32,128}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"PBKDF2-HMAC-SHA256(PHP)",
-                john: nil,
-                hashcat: 10900,
-                extended: false
-            }
+            {name:"PBKDF2-HMAC-SHA256(PHP)", john: nil, hashcat: 10900, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b(\$dahua\$)?[a-z0-9]{8}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"Dahua",
-                john: "dahua",
-                hashcat: nil,
-                extended: false
-            }
+            {name:"Dahua", john: "dahua", hashcat: nil, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$mysqlna\$[a-f0-9]{40}[:*][a-f0-9]{40}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                 name:"MySQL Challenge-Response Authentication (SHA1)",
-                john: nil,
-                hashcat: 11200,
-                extended: false
-            }
+            {name:"MySQL Challenge-Response Authentication (SHA1)", john: nil, hashcat: 11200, extended: false}
         ]
     },
     {
         extract_regex: Regexp.new('\b\$pdf\$[24]\\*[34]\\*128\\*[0-9-]{1,5}\\*1\\*(16|32)\\*[a-f0-9]{32,64}\\*32\\*[a-f0-9]{64}\\*(8|16|32)\\*[a-f0-9]{16,64}\b', Regexp::IGNORECASE),
         modes: [
-            {
-                name:"PDF 1.4 - 1.6 (Acrobat 5 - 8)",
-                john: "pdf",
-                hashcat: 10500,
-                extended: false
-            }
+            {name:"PDF 1.4 - 1.6 (Acrobat 5 - 8)", john: "pdf", hashcat: 10500, extended: false}
         ]
     }
   ].freeze