Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/scapy/as_resolvers.py: 31%

Shortcuts on this page

r m x   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

118 statements  

1# SPDX-License-Identifier: GPL-2.0-only 

2# This file is part of Scapy 

3# See https://scapy.net/ for more information 

4# Copyright (C) Philippe Biondi <phil@secdev.org> 

5 

6""" 

7Resolve Autonomous Systems (AS). 

8""" 

9 

10 

11import socket 

12from scapy.config import conf 

13from scapy.compat import plain_str 

14 

15from typing import ( 

16 Any, 

17 Optional, 

18 Tuple, 

19 List, 

20) 

21 

22 

23class AS_resolver: 

24 server = None 

25 options = "-k" # type: Optional[str] 

26 

27 def __init__(self, server=None, port=43, options=None, timeout=5): 

28 # type: (Optional[str], int, Optional[str], Optional[float]) -> None 

29 if server is not None: 

30 self.server = server 

31 self.port = port 

32 if options is not None: 

33 self.options = options 

34 self.timeout = timeout 

35 

36 def _start(self): 

37 # type: () -> None 

38 self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 

39 if self.timeout is not None: 

40 self.s.settimeout(self.timeout) 

41 self.s.connect((self.server, self.port)) 

42 if self.options: 

43 self.s.send(self.options.encode("utf8") + b"\n") 

44 self.s.recv(8192) 

45 

46 def _stop(self): 

47 # type: () -> None 

48 if hasattr(self, "s") and self.s: 

49 try: 

50 self.s.close() 

51 except OSError: 

52 pass 

53 

54 def _parse_whois(self, txt): 

55 # type: (bytes) -> Tuple[Optional[str], str] 

56 asn, desc = None, b"" 

57 for line in txt.splitlines(): 

58 if not asn and line.startswith(b"origin:"): 

59 asn = plain_str(line[7:].strip()) 

60 if line.startswith(b"descr:"): 

61 if desc: 

62 desc += b"\n" 

63 desc += line[6:].strip() 

64 if asn is not None and desc: 

65 break 

66 return asn, plain_str(desc.strip()) 

67 

68 def _resolve_one(self, ip): 

69 # type: (str) -> Tuple[str, Optional[str], str] 

70 self.s.send(("%s\n" % ip).encode("utf8")) 

71 x = b"" 

72 while not (b"%" in x or b"source" in x): 

73 d = self.s.recv(8192) 

74 if not d: 

75 break 

76 x += d 

77 asn, desc = self._parse_whois(x) 

78 return ip, asn, desc 

79 

80 def resolve(self, 

81 *ips # type: str 

82 ): 

83 # type: (...) -> List[Tuple[str, Optional[str], str]] 

84 self._start() 

85 try: 

86 ret = [] # type: List[Tuple[str, Optional[str], str]] 

87 for ip in ips: 

88 ip, asn, desc = self._resolve_one(ip) 

89 if asn is not None: 

90 ret.append((ip, asn, desc)) 

91 return ret 

92 finally: 

93 self._stop() 

94 

95 

96class AS_resolver_riswhois(AS_resolver): 

97 server = "riswhois.ripe.net" 

98 options = "-k -M -1" 

99 

100 

101class AS_resolver_radb(AS_resolver): 

102 server = "whois.ra.net" 

103 options = "-k -M" 

104 

105 

106class AS_resolver_cymru(AS_resolver): 

107 server = "whois.cymru.com" 

108 options = None 

109 

110 def resolve(self, 

111 *ips # type: str 

112 ): 

113 # type: (...) -> List[Tuple[str, Optional[str], str]] 

114 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 

115 if self.timeout is not None: 

116 s.settimeout(self.timeout) 

117 try: 

118 s.connect((self.server, self.port)) 

119 s.send( 

120 b"begin\r\n" + 

121 b"\r\n".join(ip.encode() for ip in ips) + 

122 b"\r\nend\r\n" 

123 ) 

124 r = b"" 

125 while True: 

126 line = s.recv(8192) 

127 if line == b"": 

128 break 

129 r += line 

130 finally: 

131 s.close() 

132 

133 return self.parse(r) 

134 

135 def parse(self, data): 

136 # type: (bytes) -> List[Tuple[str, Optional[str], str]] 

137 """Parse bulk cymru data""" 

138 

139 ASNlist = [] # type: List[Tuple[str, Optional[str], str]] 

140 for line in plain_str(data).splitlines()[1:]: 

141 if "|" not in line: 

142 continue 

143 asn, ip, desc = [elt.strip() for elt in line.split('|')] 

144 if asn == "NA": 

145 continue 

146 asn = "AS%s" % asn 

147 ASNlist.append((ip, asn, desc)) 

148 return ASNlist 

149 

150 

151class AS_resolver_multi(AS_resolver): 

152 def __init__(self, *reslist, **kargs): 

153 # type: (*AS_resolver, **Any) -> None 

154 timeout = kargs.get("timeout", 5) 

155 AS_resolver.__init__(self, timeout=timeout) 

156 if reslist: 

157 self.resolvers_list = reslist 

158 else: 

159 self.resolvers_list = (AS_resolver_radb(timeout=timeout), 

160 AS_resolver_cymru(timeout=timeout)) 

161 

162 def resolve(self, *ips): 

163 # type: (*Any) -> List[Tuple[str, Optional[str], str]] 

164 todo = ips 

165 ret = [] 

166 for ASres in self.resolvers_list: 

167 try: 

168 res = ASres.resolve(*todo) 

169 except socket.error: 

170 continue 

171 todo = tuple(ip for ip in todo if ip not in [r[0] for r in res]) 

172 ret += res 

173 if not todo: 

174 break 

175 return ret 

176 

177 

178conf.AS_resolver = AS_resolver_multi()