def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MF4wDQYJKoZIhvcNAQEBBQADTQAwSgJDTuJNJVnOa1qp8n91iIWs30F6xA+I/nkf
MV7Ad/0M5seWOKImUngYig60DRfrXwXa7GWh8qmK0V5sR+ib27+bbZfwAQIDAQAB
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data))
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MDwwDQYJKoZIhvcNAQEBBQADKwAwKAIhAM7gDElzPMzEU1htubZ8KvfHomChbmwN
ZrJ1fw38h5l1AgMBAAE=
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MF0wDQYJKoZIhvcNAQEBBQADTAAwSQJCBcW4rpUeDXt1iPxWHCeb48HXZBIpulCr
t/e2LMmbGmPfBeS1cG7CKBFPBRdFIknRmApLezz8oBwSBcPhFmVMyBc9AgMBAAE=
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def attack_multiple_keys(self, publickeys, attacks_list):
"""Run attacks on multiple keys"""
self.logger.info("[*] Multikey mode using keys: " +
", ".join(publickeys))
self.load_attacks(attacks_list, multikeys=True)
# Read keyfiles
publickeys_obj = []
for publickey in publickeys:
try:
with open(publickey, "rb") as pubkey_fd:
publickeys_obj.append(
PublicKey(pubkey_fd.read(), publickey))
except Exception:
self.logger.error("[*] Key format not supported : %s." %
publickey)
continue
if len(publickeys_obj) == 0:
self.logger.error("No key loaded.")
exit(1)
self.publickey = publickeys_obj
if self.args.check_publickey:
k, ok = self.pre_attack_check(self.publickey)
if not ok:
return False
# Loop through implemented attack methods and conduct attacks
for attack_module in self.implemented_attacks:
if isinstance(self.publickey, list):
self.logger.info("[*] Performing %s attack." %
attack_module.get_name())
try:
if not attack_module.can_run():
continue
self.priv_key, unciphered = attack_module.attack(
self.publickey, self.cipher)
if unciphered is not None and unciphered is not []:
if isinstance(unciphered, list):
self.unciphered = self.unciphered + unciphered
else:
self.unciphered.append(unciphered)
if self.can_stop_tests():
self.logger.info(
f"[*] Attack success with {attack_module.get_name()} method !"
)
break
except FactorizationError:
self.logger.warning("Timeout")
public_key_name = ",".join(publickeys)
self.print_results_details(public_key_name)
self.priv_key_send2fdb()
return self.get_boolean_results()
def test(self):
from lib.keys_wrapper import PublicKey
# The complexity of the problem grows exponential with every bit set.
# p=0b10000000000001111, q=0b10000000000000011
key_data = """-----BEGIN PUBLIC KEY-----
MCAwDQYJKoZIhvcNAQEBBQADDwAwDAIFAQASAC0CAwEAAQ==
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAIAce1LytE5hd6Kl8yUMSo9BSfvjgW9W
3nu+QG7/FNRjB7+ot8giOYNZqid2e6Z/MrJf1QzftgJCF9qhUv2egKUCAwEAAQ==
-----END PUBLIC KEY-----"""
self.timeout = 120
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MFswDQYJKoZIhvcNAQEBBQADSgAwRwJAar8f96eVg1jBUt7IlYJk89ksQxJSdIjC
3e7baDh166JFr7lL6jrkD+9fsqgxFj9nPRYWCkKX/JcceVd5Y81YQwIDAQAB
-----END PUBLIC KEY-----"""
self.timeout = 120
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MGIwDQYJKoZIhvcNAQEBBQADUQAwTgJHFe/Y6RPz9BY+fYsJo9d+YAsqKLtte/tI
VyjReeB0fShmpmw8VE1pImeChPevslr2tuc7D/yu5VxYHO/GdP1xUE3nPGYaMkcC
AwEAAQ==
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MDwwDQYJKoZIhvcNAQEBBQADKwAwKAIhAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAABAgMBAAE=
-----END PUBLIC KEY-----"""
self.timeout = 180
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MGYwDQYJKoZIhvcNAQEBBQADVQAwUgJLAi7v97hPb80NkMELBLYGAGEeDOdFAiW6
5wq4OGN1P6nmUmg5iFRQA6YWU8x1WdQMmVs6KxIUS89W0InUN3JVQ9SzLE32nKXc
t6rrAgMBAAE=
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MGIwDQYJKoZIhvcNAQEBBQADUQAwTgJHRxjQFVPVvt1fa+cUt3fS5qNiHLa/OeaX
5USLac4dYG3GsvE97xPdzXfx6iQiM5u9608uoygqBRfr+YN4bTuvC6omcabKO30C
AwEAAQ==
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data))
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MIGhMA0GCSqGSIb3DQEBAQUAA4GPADCBiwKBgwC60gz5ftUELfaWzk3z5aZ4z0+z
aT098S3+n9P9jMiquLlVM+QU4/wMN39O5UgnEYsdMFYaPHQb6nx2iZeJtRdD4HYJ
LfnrBdyX6xUFzp6xK1q54Qq/VvkgpY5+AOzwWXfocoNN2FhM9KyHy33FAVm9lix1
y++2xqw6MadOfY8eTBDVAgMBAAE=
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data))
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCG6ZYBPnfEFpkADglB1IDARrL3
Gk+Vs1CsGk1CY3KSPYpFYdlvv7AkBZWQcgGtMiXPbt7X3gLZHDhv+sKAty0Plcrn
H0Lr4NPtrqznzqMZX6MsHGCA2Q74U9Bt1Fcskrn4MQu8DGNaXiaVJRF1EDCmWQgW
VU52MDG8uzHj8RnGXwIDAQAB
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data))
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MIGWMA0GCSqGSIb3DQEBAQUAA4GEADCBgAJ5C/QyoZTftkv7F7HOOWqxiRTnW3Sa
mWXYEKiCOio1vK3Xh/HMJdJZ5JsOwd27OTvlBw5eLEjsJfjT0PQR/ULJujjvf35q
4EYr3aw1U4JVcy8h2eyb61AhNDc1GL2YXOIkjUbpj+8I0fKpDjPesfa0h5yhTluo
x5AlBQIDAQAB
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgRBNZTe9G/tNqNNwNZz4JDgmOVmk
ZheJybt5Ew4jKnUjKcfLY8rs8nGCbVdYyKUdq3WQSKCsYy2StxBSZn4qgxoA7G5n
DGWWBFisWHeLM+lUr3jfnOTbnAZt3utu8plSMbv2irXohbDRxN/6NgzoQMVcmhIQ
bD3qa8mMScpXZXD2qwIDAQAB
-----END PUBLIC KEY-----"""
self.timeout = 180
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MIGeMA0GCSqGSIb3DQEBAQUAA4GMADCBiAKBgAOBxiQviVpL4G5d0TmVmjDn51zu
iravDlD4vUlVk9XK79/fwptVzYsjimO42+ZW5VmHF2AUXaPhDC3jBaoNIoa78CXO
ft030bR1S0hGcffcDFMm/tZxwu2/AAXCHoLdjHSwL7gxtXulFxbWoWOdSq+qxtak
zBSZ7R1QlDmbnpwdAgMDEzc=
-----END PUBLIC KEY-----"""
self.timeout = 120
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MIGeMA0GCSqGSIb3DQEBAQUAA4GMADCBiAKBgAf9o7hkl15GaKWJ51ULnccQmgKl
u1DS4UUpfTP9rVsJ0id9WMZeAD6sr2kJuraVywHszS4BNhYGfJ4Yyd+DabTpIWRx
zSdsZXTLCf5XvPV9BUkg9FCkBjvl0YBUZ1toQCUqlI6v0tGrEGllpUF3Nq67Htd1
YYO3FuEbderGwu9dAgMBAAE=
-----END PUBLIC KEY-----"""
self.timeout = 120
result = self.attack(PublicKey(key_data))
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MIIBJDANBgkqhkiG9w0BAQEFAAOCAREAMIIBDAKCAQMlsYv184kJfRcjeGa7Uc/4
3pIkU3SevEA7CZXJfA44bUbBYcrf93xphg2uR5HCFM+Eh6qqnybpIKl3g0kGA4rv
tcMIJ9/PP8npdpVE+U4Hzf4IcgOaOmJiEWZ4smH7LWudMlOekqFTs2dWKbqzlC59
NeMPfu9avxxQ15fQzIjhvcz9GhLqb373XDcn298ueA80KK6Pek+3qJ8YSjZQMrFT
+EJehFdQ6yt6vALcFc4CB1B6qVCGO7hICngCjdYpeZRNbGM/r6ED5Nsozof1oMbt
Si8mZEJ/Vlx3gathkUVtlxx/+jlScjdM7AFV5fkRidt0LkwosDoPoRz/sDFz0qTM
5q5TAgMBAAE=
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def attack_multiple_keys(self, publickeys, attacks_list):
""" Run attacks on multiple keys
"""
self.logger.info("[*] Multikey mode using keys: " + ", ".join(publickeys))
self.load_attacks(attacks_list, multikeys=True)
# Read keyfiles
publickeys_obj = []
for publickey in publickeys:
try:
with open(publickey, "rb") as pubkey_fd:
publickeys_obj.append(PublicKey(pubkey_fd.read(), publickey))
except Exception:
print("Key format not supported : %s." % publickey)
pass
if len(publickeys_obj) == 0:
self.logger.error("No key loaded.")
exit(1)
self.publickey = publickeys_obj
# Loop through implemented attack methods and conduct attacks
for attack_module in self.implemented_attacks:
if isinstance(self.publickey, list):
self.logger.info(
"[*] Performing %s attack." % attack_module.__name__.split(".")[-1]
)
try:
self.priv_key, unciphered = attack_module.attack(
self, self.publickey, self.cipher
)
if self.priv_key != None and self.priv_key not in self.priv_keys:
self.priv_keys.append(self.priv_key)
if unciphered is not None and unciphered is not []:
if isinstance(unciphered, list):
self.unciphered = self.unciphered + unciphered
else:
self.unciphered.append(unciphered)
if self.can_stop_tests():
break
except FactorizationError:
self.logger.warning("Timeout")
public_key_name = ",".join(publickeys)
self.print_results_details(public_key_name)
if self.args.sendtofdb==True:
if len(self.priv_keys) > 0:
for privkey in list(set(self.priv_keys)):
send2fdb(privkey.n,[privkey.p,privkey.q])
return self.get_boolean_results()
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MIGtMA0GCSqGSIb3DQEBAQUAA4GbADCBlwKBjw+vePt+ocGhwLTa5ONmKUvyhdAX
fU99ZyaGskpxn2DAkPett8hD/3eySSPMgd/y9oXYYsIm/0x5hfs7wLLh/Av5Qx7x
Or5ejGechok7VVoUbw6KTBB1fWy1lC39jFyTa4oZAGCQLf9nJRMYbDGzzrWnDm7K
ynOXWY/6keaIBeg2Xh7VkK5VOl33WjCkSARfAgMBAAE=
-----END PUBLIC KEY-----"""
cipher = 7102577393434866594929140550804968099111271800384955683330956013020579564684516163830573468073604865935034522944441894535695787080676107364035121171758895218132464499398807752144702697548021940878072503062685829101838944413876346837812265739970980202827485238414586892442822429233004808821082551675699702413952211939387589361654209039260795229
result = self.attack(
PublicKey(key_data),
[cipher.to_bytes((cipher.bit_length() + 7) // 8, "big")],
)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MIIBfjANBgkqhkiG9w0BAQEFAAOCAWsAMIIBZgKCAV0BAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAEcN5PtyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE7i1xIeWbfAOhAgMB
AAE=
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MIIB3zANBgkqhkiG9w0BAQEFAAOCAcwAMIIBxwKCAb4A////////////////////
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
/f//////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
////////////////////////////////////////gAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQID
AQAB
-----END PUBLIC KEY-----"""
self.timeout = 90
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEBIRb3M+neIDFb/YRV7KC6
gNbuE3PACl6XF308lnbE5nlhbW7Hv9cqa1ejjXhrlY/yEOqa0P+tVHpRg6UPTFI6
Tdo6XsQrBMXj5qmhdWXVdybJlk5vZdfHdUUgVY6n9YEEff2++mzfD68AzWXadCT6
rEAHgNey44VyLrDg9obVgrmtc7wXtBr+YVrepRfDcrm0D4ZMKeUb07DErZ6GM4I5
/nqLsv8fG55HsWnDp53HCjnWF21I8UvLQqS3qo5N2HQSi7JoONfwsgCwN92t5P/F
jJX0E06PvXqny7uBtSu00KQ1t/srkn47EU4u7U3z+hgJ1kYITrtUG/u+H0xhz9MD
iJtmMx+tfBg7fLSeYQ4uFyxurNakcDYY0D9zu60OT8MzgCby94jydHwowavvyxT9
akEdv/urdgF4Cu0arYCl0DPFDwSvZxyicywbacIHqqalwTm4jRwUK43vJp+5xbTG
cek5zZTIhGbTkhTGTkYWNnQs5QE8UW4y4Z61+sNtpz3rJ7z9PTPd2jGFHmb0X2f/
DogSs0Vjse3lbJsTiM08dwxyP+TtsMIp6AXqClWsjx2RItxGtAmUuyQgE+HG/VaO
+f/EZcSnDcUwLs8XRpDwHVH/kx780H2NTk3LOM5RARWzLmr0HleZSU2IyWLHB9+n
YNyR4N29HHEfixQFgwHapccCAwEAAQ==
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def attack_single_key(self, publickey, attacks_list=[]):
"""Run attacks on single keys"""
if len(attacks_list) == 0:
self.args.attack = "all"
self.load_attacks(attacks_list)
# Read keyfile
with open(publickey, "rb") as pubkey_fd:
self.publickey = PublicKey(pubkey_fd.read(), publickey)
# Read n/e from publickey file
if not self.args.n or not self.args.e:
self.args.n = self.publickey.n
self.args.e = self.publickey.e
# Loop through implemented attack methods and conduct attacks
for attack_module in self.implemented_attacks:
self.logger.info(
"[*] Performing %s attack on %s." %
(attack_module.get_name(), self.publickey.filename))
try:
if not attack_module.can_run():
continue
self.priv_key, unciphered = attack_module.attack(
self.publickey, self.cipher)
if unciphered is not None and unciphered is not []:
if isinstance(unciphered, list):
self.unciphered = self.unciphered + unciphered
else:
self.unciphered.append(unciphered)
if self.can_stop_tests():
break
except FactorizationError:
self.logger.warning("Timeout")
self.print_results_details(publickey)
if self.args.sendtofdb == True:
if self.priv_key != None:
send2fdb(self.priv_key.n, [self.priv_key.p, self.priv_key.q])
return self.get_boolean_results()
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MIICIDANBgkqhkiG9w0BAQEFAAOCAg0AMIICCAKCAQBdR3T47dmS7hhRFn9WeLj1
ZTYG0e0w9EcFbflJ7Z/FYjPCLxeFaIW1iMLCVXVsXLMqY255y/4hdEmPa2NP9X/b
72JJEUgPhi9o/2fzM+fFemdlo+ikXoFXRxpz3F0ACJm2FZidVfkJBQU8V7HO1Urn
FT9SuNt77CggNQliEKmSuNmnOfsN9U7694XltgqjxHOnnwKxm9qpvhte9xy6lSco
ckvf329/Ui4C2iBlfKkEzavhEgVj1wgCp/B77h/CHz+d62TnCO9WHWUQ/e0QcaiI
T0nv7RPKACYE5vkLXOwB7AiENf01ZCTRHtM0yDsmy3N18TsruxMMKf2tRfWtEGqt
AoIBABzfv6RIiqEg6T4OlTdnViAecGKXCFXg0cbzt5ZN8/ASV012mR44ogjIywYY
O6DolPNYGMSCVj1ZtXJn/gpVssH5PcrMLeamQoHs60VD5gBuz75qIsUtxOj6uPqK
PpThSunYWNg4NbEn0sVIhbKetRjCWDGGJqvQOSlUrcYs+E27VenZ55URQHjfqPcK
csmn70OHR+vD/gPq2qLb+STG4LGFpeez7Kssgio5hNRbeSvSd+DacrKcV3J/j+QW
IKglOWAqKED9Ahc9d5KufAO0WSf2H2GPiosSkn9LVrfIUAupPUf/xe4X8p4WvAfT
HiV/C1S+/8j2BWST7rdOtNN7SGc=
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data), progress=False)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MIIBIDANBgkqhkiG9w0BAQEFAAOCAQ0AMIIBCAKCAQEA6FqEbjr1AgKR+WtbpHa3
1kvsipKxGoKPWtZDCLnrzvwnyVJVdlyvKEYVqVGHhiuJU2RH+8oSQsGF/yjMaOzc
CxB5/cCrXAFere5nsN2SQsAEG8xS1ccn9YWoEfKAJrsdxUZd5CoSkwlQzvX01JMN
ap5u35o+emK3/ny5QdzZpoie0xp4l8uCFR/cp33cvZj2+VOP4ch6szpTG2u0h7sP
SfNvAHUqrZ8YscwkWEUk6N+55mQMviuLV8cqY1O9Lu+Q8yL5EtZj0vtxhb4Pj/ad
+GMzczpiZxZDjfpEVHaP67ntl7Ut8zhfWjQ69/Un7hjjdqQuh7GPGfhGd6ohbX6E
uQIBAw==
-----END PUBLIC KEY-----"""
cipher = 2205316413931134031074603746928247799030155221252519872650101242908540609117693035883827878696406295617513907962419726541451312273821810017858485722109359971259158071688912076249144203043097720816270550387459717116098817458584146690177125
result = self.attack(
PublicKey(key_data),
[cipher.to_bytes((cipher.bit_length() + 7) // 8, "big")],
progress=False)
return result != (None, None)
def print_results(args, publickey, private_key, uncipher):
"""Print results to output"""
logger = logging.getLogger("global_logger")
if ((args.private and private_key is not None) or (args.dumpkey)
or (args.uncipher and uncipher not in [None, []])):
if publickey is not None:
logger.info("\nResults for %s:" % publickey)
if private_key is not None:
if not isinstance(private_key, list):
private_keys = [private_key]
else:
private_keys = private_key
if args.private:
logger.info("\nPrivate key :")
for priv_key in private_keys:
if priv_key is not None:
if args.output:
try:
with open(args.output, "a") as output_fd:
output_fd.write("%s\n" % str(priv_key))
except:
logger.error("Can't write output file : %s" %
args.output)
if str(priv_key) != "":
logger.info(priv_key)
else:
logger.warning(
"Key format seems wrong, check input data to solve this."
)
if args.dumpkey:
for priv_key in private_keys:
if priv_key.n is not None:
logger.info("n: " + str(priv_key.n))
if priv_key.e is not None:
logger.info("e: " + str(priv_key.e))
if priv_key.d is not None:
logger.info("d: " + str(priv_key.d))
if priv_key.p is not None:
logger.info("p: " + str(priv_key.p))
if priv_key.q is not None:
logger.info("q: " + str(priv_key.q))
if args.ext:
dp = priv_key.d % (priv_key.p - 1)
dq = priv_key.d % (priv_key.q - 1)
pinv = invmod(priv_key.p, priv_key.q)
qinv = invmod(priv_key.q, priv_key.p)
logger.info("dp: " + str(dp))
logger.info("dq: " + str(dq))
logger.info("pinv: " + str(pinv))
logger.info("qinv: " + str(qinv))
else:
if args.private:
logger.critical("Sorry, cracking failed.")
if args.dumpkey:
if args.publickey is not None:
for public_key in args.publickey:
with open(public_key, "rb") as pubkey_fd:
publickey_obj = PublicKey(pubkey_fd.read(), publickey)
logger.info("\nPublic key details for %s" %
publickey_obj.filename)
logger.info("n: " + str(publickey_obj.n))
logger.info("e: " + str(publickey_obj.e))
if args.uncipher:
if uncipher is not None:
if not isinstance(uncipher, list):
uncipher = [uncipher]
if len(uncipher) > 0:
logger.info("\nUnciphered data :")
for uncipher_ in uncipher:
if not isinstance(uncipher_, list):
uncipher_ = [uncipher_]
for c in uncipher_:
if args.output:
try:
with open(args.output, "ab") as output_fd:
output_fd.write(c)
except:
logger.error("Can't write output file : %s" %
args.output)
logger.info(f"HEX : 0x{c.hex()}")
int_big = int.from_bytes(c, "big")
int_little = int.from_bytes(c, "little")
logger.info(f"INT (big endian) : {int_big}")
logger.info(f"INT (little endian) : {int_little}")
try:
c_utf8 = c.decode("utf-8")
logger.info(f"utf-8 : { c_utf8 }")
except UnicodeDecodeError:
pass
try:
c_utf16 = c.decode("utf-16")
logger.info(f"utf-16 : { c_utf16 }")
except UnicodeDecodeError:
pass
logger.info(f"STR : {repr(c)}")
else:
logger.critical("Sorry, unciphering failed.")
def print_results(args, publickey, private_key, uncipher):
""" Print results to output
"""
logger = logging.getLogger("global_logger")
if ((args.private and private_key is not None) or (args.dumpkey)
or (args.uncipher and uncipher not in [None, []])):
if publickey is not None:
logger.info("\nResults for %s:" % publickey)
if private_key is not None:
if not isinstance(private_key, list):
private_keys = [private_key]
else:
private_keys = private_key
if args.private:
logger.info("\nPrivate key :")
for priv_key in private_keys:
if priv_key is not None:
if args.output:
try:
with open(args.output, "a") as output_fd:
output_fd.write("%s\n" % str(priv_key))
except:
logger.error("Can't write output file : %s" %
args.output)
logger.info(priv_key)
if args.dumpkey:
for priv_key in private_keys:
if priv_key.n is not None:
logger.info("n: " + str(priv_key.n))
if priv_key.e is not None:
logger.info("e: " + str(priv_key.e))
if priv_key.d is not None:
logger.info("d: " + str(priv_key.d))
if priv_key.p is not None:
logger.info("p: " + str(priv_key.p))
if priv_key.q is not None:
logger.info("q: " + str(priv_key.q))
if args.ext:
dp = priv_key.d % (priv_key.p - 1)
dq = priv_key.d % (priv_key.q - 1)
pinv = invmod(priv_key.p, priv_key.q)
qinv = invmod(priv_key.q, priv_key.p)
logger.info("dp: " + str(dp))
logger.info("dq: " + str(dq))
logger.info("pinv: " + str(pinv))
logger.info("qinv: " + str(qinv))
else:
if args.private:
logger.critical("Sorry, cracking failed.")
if args.dumpkey:
if args.publickey is not None:
for public_key in args.publickey:
with open(public_key, "rb") as pubkey_fd:
publickey_obj = PublicKey(pubkey_fd.read(), publickey)
logger.info("\nPublic key details for %s" %
publickey_obj.filename)
logger.info("n: " + str(publickey_obj.n))
logger.info("e: " + str(publickey_obj.e))
if args.uncipher:
if uncipher is not None:
if not isinstance(uncipher, list):
uncipher = [uncipher]
if len(uncipher) > 0:
logger.info("\nUnciphered data :")
for uncipher_ in uncipher:
if args.output:
try:
with open(args.output, "ab") as output_fd:
output_fd.write(uncipher_)
except:
logger.error("Can't write output file : %s" %
args.output)
logger.info(uncipher_)
else:
logger.critical("Sorry, unciphering failed.")
def attack_single_key(self, publickey, attacks_list=[], test=False):
"""Run attacks on single keys"""
if len(attacks_list) == 0:
self.args.attack = "all"
self.load_attacks(attacks_list)
if test:
for attack in self.implemented_attacks:
if attack.can_run():
self.logger.info("[*] Testing %s" % attack.get_name())
try:
try:
if attack.test():
self.logger.info("[*] Success")
else:
self.logger.error("[!] Failure")
except NotImplementedError:
self.logger.warning("[!] Test not implemented")
except Exception:
self.logger.error("[!] Failure")
exit(0)
# Read keyfile
try:
with open(publickey, "rb") as pubkey_fd:
self.publickey = PublicKey(pubkey_fd.read(), publickey)
except Exception as e:
self.logger.error("[*] %s." % e)
return
if self.args.check_publickey:
k, ok = self.pre_attack_check(self.publickey)
if not ok:
return False
# Read n/e from publickey file
if not self.args.n or not self.args.e:
self.args.n = self.publickey.n
self.args.e = self.publickey.e
# Loop through implemented attack methods and conduct attacks
for attack_module in self.implemented_attacks:
self.logger.info(
"[*] Performing %s attack on %s." %
(attack_module.get_name(), self.publickey.filename))
try:
if not attack_module.can_run():
continue
self.priv_key, unciphered = attack_module.attack(
self.publickey, self.cipher)
if unciphered is not None and unciphered is not []:
if isinstance(unciphered, list):
self.unciphered = self.unciphered + unciphered
else:
self.unciphered.append(unciphered)
if self.can_stop_tests():
self.logger.info(
f"[*] Attack success with {attack_module.get_name()} method !"
)
break
except FactorizationError:
self.logger.warning("Timeout")
except NotImplementedError:
self.logger.warning(
"[!] This attack module is not implemented yet")
self.print_results_details(publickey)
self.priv_key_send2fdb()
return self.get_boolean_results()
