def test(self):
from lib.keys_wrapper import PublicKey
key1_data = """-----BEGIN PUBLIC KEY-----
MIGdMA0GCSqGSIb3DQEBAQUAA4GLADCBhwKBgQCenPk2Mrwap7Du5QA+ikywFpd+
qlErff2id/KC3hlQ40+9XvVTAsNi+d9hm4bInV4hBG8Qj98fOnyy2xG0MZr3RCko
x9vkk2GgNSkiUZT0xy7DGI2UDs/2tnFlUPDbNPRJddErhj1P1Vhsyru9BOoftfR1
aE7ad9DdkTtjrvsZWQIBEQ==
-----END PUBLIC KEY-----"""
key2_data = """-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCenPk2Mrwap7Du5QA+ikywFpd+
qlErff2id/KC3hlQ40+9XvVTAsNi+d9hm4bInV4hBG8Qj98fOnyy2xG0MZr3RCko
x9vkk2GgNSkiUZT0xy7DGI2UDs/2tnFlUPDbNPRJddErhj1P1Vhsyru9BOoftfR1
aE7ad9DdkTtjrvsZWQIDAQAB
-----END PUBLIC KEY-----"""
cipher1 = 54995751387258798791895413216172284653407054079765769704170763023830130981480272943338445245689293729308200574217959018462512790523622252479258419498858307898118907076773470253533344877959508766285730509067829684427375759345623701605997067135659404296663877453758701010726561824951602615501078818914410959610
cipher2 = 91290935267458356541959327381220067466104890455391103989639822855753797805354139741959957951983943146108552762756444475545250343766798220348240377590112854890482375744876016191773471853704014735936608436210153669829454288199838827646402742554134017280213707222338496271289894681312606239512924842845268366950
result = self.attack(
[PublicKey(key1_data), PublicKey(key2_data)],
[
cipher1.to_bytes((cipher1.bit_length() + 7) // 8, "big"),
cipher2.to_bytes((cipher2.bit_length() + 7) // 8, "big"),
],
progress=False,
)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
import base64
key1_data = """-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCtbdQAzdaO7GHXxUsVZ+FmcddA
Hrugq+azkVdfgnHu6teK3hDQlk0BdNz9LlQT3BoHXg5/g9FDv3bBwaulpQEQPlGM
UXEUnQAJ69KSVaLxHb5Wmb0vqX/qySKc8Hseqt5wbXklOrnZeHJ3Hm3mUeIplpWP
f19C6goN3bUGrrniwwIDAQAB
-----END PUBLIC KEY-----"""
key2_data = """-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCtbdQAzdaO7GHXxUsVZ+FmcddA
Hrugq+azkVdfgnHu6teK3hDQlk0BdNz9LlQT3BoHXg5/g9FDv3bBwaulpQEQPlGM
UXEUnQAJ69KSVaLxHb5Wmb0vqX/qySKc8Hseqt5wbXklOrnZeHJ3Hm3mUeIplpWP
f19C6goN3bUGrrniwwIDBTy3
-----END PUBLIC KEY-----"""
cipher1 = base64.b64_decode(
"BzFd4riBUZdFuPCkB3LOh+5iyMImeQ/saFLVD+ca2L8VKSz0+wtTaL55RRpHBAQdl24Fb3XyVg2N9UDcx3slT+vZs7tr03W7oJZxVp3M0ihoCwer3xZNieem8WZQvQvyNP5s5gMT+K6pjB9hDFWWmHzsn7eOYxRJZTIDgxA4k2w="
)
cipher2 = base64.b64_decode(
"jmVRiKyVPy1CHiYLl8fvpsDAhz8rDa/Ug87ZUXZ//rMBKfcJ5MqZnQbyTJZwSNASnQfgel3J/xJsjlnf8LoChzhgT28qSppjMfWtQvR6mar1GA0Ya1VRHkhggX1RUFA4uzL56X5voi0wZEpJITUXubbujDXHjlAfdLC7BvL/5+w="
)
result = self.attack(
[PublicKey(key1_data), PublicKey(key2_data)],
[
cipher1,
cipher2,
],
)
print(result)
return result != (None, None)
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MIIEIjANBgkqhkiG9w0BAQEFAAOCBA8AMIIECgKCAgEDMXAsX+AfJAHJ5E7Aunnk
/AwahJiyenQz9UOB9r6MuzOSRgIHFggsPr6Duj5q8v61RoMyrifh3VvMgtkgGrqB
wckMHt67sGYbigo4c5zLz9kz8DI4g7Y3n/pipdceQGt8O6YxTEnq8NcL5HIQ0iqL
quS+idjbYgy5dtAyoprDvHcTNOgEefVLB6OaZ5G7Q0txPWo/QoYSQEpVyzp4fl0T
4m6ui+uLUuT3JKg+sEIw+sF6ztfezgt+1E2mDs5d32fHJ92DpeigzyQwOFasQert
Acgld/3wdh4xv8w7USJ871nF3RVLqKYW7dwswb2G/QT6zSmnavZILLHNzs/u3z7J
iWM4SPbmYv16XbzVYDU01GPIeIQFPqVsKYSbw0+erEzqTnaioou9OuNS8bZfQQPz
fXJ20C7cFOw2FqVw+obmi6C4qvdXNXJIHN+CZWXwIx/I2ZSOBCCCGEQjinlPupZ0
p3uBpeYJY5IPu16CIM4asYm+DbM+2URKAR4fawnm6D3sZ6a8xn5ebO0keqKvEYnT
H1WtQzAvMZcar0zaotj5G6DbYlhFsMZxKZjhZVZDvaWscXem6lAU9zYVsllYuVmn
hVDrg3gXfDzyP5+IKxfyydcfzkEClfex3PpDnaCo4VSAF6iIsgKjxsUErKy3Q7XI
cZpptlNof+saJWgqWwV9dXkCggIBAsOYvjEh0hDi9U26aIoPFida3LsfLAM3ptUs
brD3yGBXM35RJacHrlwkkY44eny81QNRINCg6+pKSz60xdyT17qsvB4z4Q1zSxXx
hPqdAHB/nTREbAs4AlToNL0SCEc8G0aUdQ2+myunQVfuxTfVMnnyiUIy8la5i5Fq
ULeJXUBOSV+ERX/VmeX7O4TTLSlzvnnFSarIip58+4IIoSXD2m77ZvhPq8HZfaW9
xFw3we9zw/lQu6nLJrqgR6cmk9DD/dA4zzSLUyc3I33HpL1VM+R66cP+1uRj2Ytn
8Ku0ZWQ8PlwH15QNL/PqJoXhrFou4wCIAX99sVdhh0pnwKaHqJwSANOFi60ELkF0
/ATLPKWG124Kdkp24At4+jLJqirQSd13gpKYRdaCVo/1f3trt1xyXns6sD++onbl
I6TB4WAZuMKmzZthDfJCeWYeOhiOhDTewqi4KP227P/p+7sQKXyiI5mxIFnfRCtM
88K0xA+0yw7m1OVb69OwU5gN/uLdRIwrpA/K8zFFueD4X0Rj9MFA06hEt7rphK3a
Aqk1HXHWiF2tXr7lxpkQyRi15tyiig9CmCgPG4e1Pk95FRd6CR8i8s1q3DmtdqHb
FccBoenVqO5rZ5YwVEuhG+ofy1sEPNXO3ZPOO51DJgQO3mxmnceqLgF/Ktpzxyg+
sSSqyHKL
-----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
"""
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.__name__.split(".")[-1],
self.publickey.filename))
try:
self.priv_key, unciphered = attack_module.attack(
self, 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)
return self.get_boolean_results()
def test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MCQwDQYJKoZIhvcNAQEBBQADEwAwEAIJVqCE2raBvB+lAgMBAAE=
-----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-----
MCAwDQYJKoZIhvcNAQEBBQADDwAwDAIFAQAwAjcCAwEAAQ==
-----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-----
MBowDQYJKoZIhvcNAQEBBQADCQAwBgIBDwIBAw==
-----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-----
MBswDQYJKoZIhvcNAQEBBQADCgAwBwICCg0CAQM=
-----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 test(self):
from lib.keys_wrapper import PublicKey
key_data = """-----BEGIN PUBLIC KEY-----
MC0wDQYJKoZIhvcNAQEBBQADHAAwGQISAwm6aZnGyIrl57QGF+4RdcjlAgMBAAE=
-----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-----
MCIwDQYJKoZIhvcNAQEBBQADEQAwDgIHEAABggAEpQIDAQAB
-----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-----
MF4wDQYJKoZIhvcNAQEBBQADTQAwSgJDTuJNJVnOa1qp8n91iIWs30F6xA+I/nkf
MV7Ad/0M5seWOKImUngYig60DRfrXwXa7GWh8qmK0V5sR+ib27+bbZfwAQIDAQAB
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data))
return result != (None, None)
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:
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
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-----
MDwwDQYJKoZIhvcNAQEBBQADKwAwKAIhAM7gDElzPMzEU1htubZ8KvfHomChbmwN
ZrJ1fw38h5l1AgMBAAE=
-----END PUBLIC KEY-----"""
result = self.attack(PublicKey(key_data))
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
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-----
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-----
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-----
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
# 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-----
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-----
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-----
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-----
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-----
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-----
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()