Add multiple type hints

nmap_scan/Scripts/ReverseIndex.py

@@ -28,7 +28,7 @@
 
 
 import logging
-from typing import TypeVar
+from typing import TypeVar, Dict, List
 from xml.etree.ElementTree import Element as XMLElement
 
 from nmap_scan.CompareHelper import compare_lists
@@ -61,11 +61,11 @@ def equals(self, other: T) -> bool:
     def get_xml(self) -> XMLElement:
         return self.__xml
 
-    def get_port_ip_map(self):
+    def get_port_ip_map(self) -> Dict[str, List[str]]:
         return self.__port_ip_map
 
-    def get_ips_for_port(self, port, proto):
-        return self.__port_ip_map.get(port + '/' + proto, [])
+    def get_ips_for_port(self, port: int, proto: str) -> List[str]:
+        return self.__port_ip_map.get(str(port) + '/' + proto, [])
 
     def __parse_xml(self):
 

nmap_scan/Scripts/SSH/SSH2EnumAlgos.py

@@ -28,7 +28,7 @@
 
 
 import logging
-from typing import TypeVar
+from typing import TypeVar, List, Dict
 from xml.etree.ElementTree import Element as XMLElement
 
 from nmap_scan.CompareHelper import compare_lists
@@ -71,22 +71,22 @@ def equals(self, other: T) -> bool:
     def get_xml(self) -> XMLElement:
         return self.__xml
 
-    def get_kex_algorithms(self):
+    def get_kex_algorithms(self) -> List[str]:
         return self.__kex_algorithms
 
-    def get_server_host_key_algorithms(self):
+    def get_server_host_key_algorithms(self) -> List[str]:
         return self.__server_host_key_algorithms
 
-    def get_encryption_algorithms(self):
+    def get_encryption_algorithms(self) -> List[str]:
         return self.__encryption_algorithms
 
-    def get_mac_algorithms(self):
+    def get_mac_algorithms(self) -> List[str]:
         return self.__mac_algorithms
 
-    def get_compression_algorithms(self):
+    def get_compression_algorithms(self) -> List[str]:
         return self.__compression_algorithms
 
-    def get_other(self):
+    def get_other(self) -> Dict[str, List[str]]:
         return self.__other
 
     def __parse_xml(self):

nmap_scan/Scripts/SSH/SSHHostkey.py

@@ -28,14 +28,15 @@
 
 
 import logging
-from typing import TypeVar, Union
+from typing import TypeVar, Union, List
 from xml.etree.ElementTree import Element as XMLElement
 
 from nmap_scan.CompareHelper import compare_lists_equal
 from nmap_scan.Scripts.Script import Script
 from nmap_scan.Validator import validate
 
 T = TypeVar('T', bound='SSHHostkey')
+U = TypeVar('U', bound='Key')
 
 
 class SSHHostkey(Script):
@@ -60,7 +61,7 @@ def equals(self, other: T) -> bool:
     def get_xml(self) -> XMLElement:
         return self.__xml
 
-    def get_keys(self):
+    def get_keys(self) -> List[U]:
         return self.__keys
 
     def __parse_xml(self):
@@ -99,16 +100,16 @@ def equals(self, other: T) -> bool:
     def get_xml(self) -> XMLElement:
         return self.__xml
 
-    def get_bits(self):
+    def get_bits(self) -> int:
         return self.__bits
 
     def get_key(self) -> Union[str, None]:
         return self.__key
 
-    def get_fingerprint(self):
+    def get_fingerprint(self) -> Union[str, None]:
         return self.__fingerprint
 
-    def get_type(self):
+    def get_type(self) -> Union[str, None]:
         return self.__type
 
     def __parse_xml(self):

nmap_scan/Scripts/SSLEnumCiphers.py

@@ -28,14 +28,16 @@
 
 
 import logging
-from typing import TypeVar
+from typing import TypeVar, Dict, Union, List
 from xml.etree.ElementTree import Element as XMLElement
 
 from nmap_scan.Exceptions.LogicException import LogicException
 from nmap_scan.Scripts.Script import Script
 from nmap_scan.Validator import validate
 
 T = TypeVar('T', bound='SSLEnumCiphers')
+U = TypeVar('U', bound='SSLEnumCiphersProtocol')
+V = TypeVar('V', bound='SSLEnumCiphersCipher')
 
 
 class SSLEnumCiphers(Script):
@@ -71,13 +73,13 @@ def equals(self, other: T) -> bool:
     def get_xml(self) -> XMLElement:
         return self.__xml
 
-    def get_protocols(self):
+    def get_protocols(self) -> Dict[str, U]:
         return self.__protocols
 
-    def get_protocol(self, version):
+    def get_protocol(self, version: str) -> Union[U, None]:
         return self.__protocols.get(version, None)
 
-    def get_least_strength(self):
+    def get_least_strength(self) -> Union[str, None]:
         return self.__least_strength
 
     def __parse_xml(self):
@@ -94,9 +96,6 @@ def __parse_xml(self):
         logging.debug('Least strength: "{strength}"'.format(strength=self.__least_strength))
 
 
-U = TypeVar('U', bound='SSLEnumCiphersProtocol')
-
-
 class SSLEnumCiphersProtocol:
 
     def __init__(self, xml: XMLElement, validate_xml: bool = True):
@@ -119,19 +118,19 @@ def __ne__(self, other: U) -> bool:
     def get_xml(self) -> XMLElement:
         return self.__xml
 
-    def get_ciphers(self):
+    def get_ciphers(self) -> List[V]:
         return self.__ciphers
 
-    def get_compressor(self):
+    def get_compressor(self) -> Union[str, None]:
         return self.__compressors
 
-    def get_least_strength(self):
+    def get_least_strength(self) -> Union[str, None]:
         return self.__least_strength
 
-    def get_cipher_preference(self):
+    def get_cipher_preference(self) -> Union[str, None]:
         return self.__cipher_preference
 
-    def get_protocol_version(self):
+    def get_protocol_version(self) -> Union[str, None]:
         return self.__protocol_version
 
     def equals(self, other: U) -> bool:
@@ -196,9 +195,6 @@ def __parse_xml(self):
         logging.debug('Least strength: "{strength}"'.format(strength=self.__least_strength))
 
 
-V = TypeVar('V', bound='SSLEnumCiphersCipher')
-
-
 class SSLEnumCiphersCipher:
 
     def __init__(self, xml: XMLElement, validate_xml: bool = True):
@@ -219,40 +215,40 @@ def __ne__(self, other: V) -> bool:
     def get_xml(self) -> XMLElement:
         return self.__xml
 
-    def get_strength(self):
+    def get_strength(self) -> Union[str, None]:
         return self.__strength
 
-    def get_name(self):
+    def get_name(self) -> Union[str, None]:
         return self.__name
 
-    def get_key_info(self):
+    def get_key_info(self) -> Union[str, None]:
         return self.__key_info
 
-    def is_worse_than(self, cipher):
+    def is_worse_than(self, cipher: V) -> bool:
         return self.is_worse_than_strength(cipher.get_strength())
 
-    def is_worse_than_strength(self, strength):
+    def is_worse_than_strength(self, strength: str) -> bool:
 
         return CipherCompare.a_worse_b(self.__strength, strength)
 
-    def is_worse_equals_than(self, cipher):
+    def is_worse_equals_than(self, cipher: V) -> bool:
         return self.is_worse_equals_than_strength(cipher.get_strength())
 
-    def is_worse_equals_than_strength(self, strength):
+    def is_worse_equals_than_strength(self, strength: str) -> bool:
 
         return CipherCompare.a_worse_equals_b(self.__strength, strength)
 
-    def is_better_than(self, cipher):
+    def is_better_than(self, cipher: V) -> bool:
         return self.is_better_than_strength(cipher.get_strength())
 
-    def is_better_than_strength(self, strength):
+    def is_better_than_strength(self, strength: str) -> bool:
 
         return CipherCompare.a_better_b(self.__strength, strength)
 
-    def is_better_equals_than(self, cipher):
+    def is_better_equals_than(self, cipher: V) -> bool:
         return self.is_better_equals_than_strength(cipher.get_strength())
 
-    def is_better_equals_than_strength(self, strength):
+    def is_better_equals_than_strength(self, strength: str) -> bool:
 
         return CipherCompare.a_better_equals_b(self.__strength, strength)
 
@@ -283,47 +279,47 @@ def __parse_xml(self):
 class CipherCompare:
 
     @staticmethod
-    def a_lower_b(a, b):
+    def a_lower_b(a: V, b: V) -> bool:
         return CipherCompare.map_strength(a) < CipherCompare.map_strength(b)
 
     @staticmethod
-    def a_lower_equals_b(a, b):
+    def a_lower_equals_b(a: V, b: V) -> bool:
         return CipherCompare.map_strength(a) <= CipherCompare.map_strength(b)
 
     @staticmethod
-    def a_better_b(a, b):
+    def a_better_b(a: V, b: V) -> bool:
         return CipherCompare.a_lower_b(a, b)
 
     @staticmethod
-    def a_better_equals_b(a, b):
+    def a_better_equals_b(a: V, b: V) -> bool:
         return CipherCompare.a_lower_equals_b(a, b)
 
     @staticmethod
-    def a_grater_b(a, b):
+    def a_grater_b(a: V, b: V) -> bool:
         return CipherCompare.map_strength(a) > CipherCompare.map_strength(b)
 
     @staticmethod
-    def a_grater_equals_b(a, b):
+    def a_grater_equals_b(a: V, b: V) -> bool:
         return CipherCompare.map_strength(a) >= CipherCompare.map_strength(b)
 
     @staticmethod
-    def a_worse_b(a, b):
+    def a_worse_b(a: V, b: V) -> bool:
         return CipherCompare.a_grater_b(a, b)
 
     @staticmethod
-    def a_worse_equals_b(a, b):
+    def a_worse_equals_b(a: V, b: V) -> bool:
         return CipherCompare.a_grater_equals_b(a, b)
 
     @staticmethod
-    def a_equals_b(a, b):
+    def a_equals_b(a: V, b: V) -> bool:
         return CipherCompare.map_strength(a) == CipherCompare.map_strength(b)
 
     @staticmethod
-    def a_not_equals_b(a, b):
+    def a_not_equals_b(a: V, b: V) -> bool:
         return CipherCompare.map_strength(a) != CipherCompare.map_strength(b)
 
     @staticmethod
-    def map_strength(strength):
+    def map_strength(strength: str) -> int:
         logging.debug('Map strength "{strength}"'.format(strength=strength))
 
         all_strength = {
@@ -343,7 +339,7 @@ def map_strength(strength):
         return mapped_strength
 
     @staticmethod
-    def reverse_map_strength(strength):
+    def reverse_map_strength(strength: int) -> str:
         logging.debug('Reverse map strength "{strength}"'.format(strength=strength))
         all_strength = {
             1: 'A',

nmap_scan/Scripts/Script.py

@@ -28,7 +28,7 @@
 
 
 import logging
-from typing import TypeVar, Dict
+from typing import TypeVar, Dict, List
 from xml.etree.ElementTree import Element as XMLElement
 
 from lxml import etree
@@ -111,16 +111,16 @@ def equals(self, other: T) -> bool:
     def get_xml(self) -> XMLElement:
         return self.__xml
 
-    def get_elements(self):
+    def get_elements(self) -> List[Element]:
         return self.__elements
 
-    def get_tables(self):
+    def get_tables(self) -> List[Table]:
         return self.__tables
 
-    def get_id(self):
+    def get_id(self) -> str:
         return self.__id
 
-    def get_output(self):
+    def get_output(self) -> str:
         return self.__output
 
     def __parse_xml(self):