source: repository/lib/Metabrik/Network/Portscan.pm

Last change on this file was 968:76c9b59191bd, checked in by GomoR <gomor@…>, 5 months ago
  • update: network::portscan: added debug messages
  • update: network::read: added debug messages
File size: 21.6 KB
Line 
1#
2# $Id$
3#
4# network::portscan Brik
5#
6package Metabrik::Network::Portscan;
7use strict;
8use warnings;
9
10use base qw(Metabrik::Network::Device);
11
12sub brik_properties {
13   return {
14      revision => '$Revision$',
15      tags => [ qw(unstable scan syn port synscan tcpscan) ],
16      author => 'GomoR <GomoR[at]metabrik.org>',
17      license => 'http://opensource.org/licenses/BSD-3-Clause',
18      attributes => {
19         device => [ qw(device) ],
20         listen_device => [ qw(device) ],
21         ports => [ qw(port_array) ],
22         top10 => [ qw(top10_port_array) ],
23         top100 => [ qw(top100_port_array) ],
24         top1000 => [ qw(top1000_port_array) ],
25         pps => [ qw(pps) ],
26         try => [ qw(try) ],
27         bandwidth => [ qw(bandwidth) ],
28         wait => [ qw(seconds) ],
29         use_ipv6 => [ qw(0|1) ],
30         src_ip => [ qw(ip_address) ],
31         _nr => [ qw(INTERNAL) ],
32      },
33      attributes_default => { 
34         top10 => [ qw(
35            21 22 23 25 80 135 139 443 445 3389
36         ) ],
37         top100 => [ qw(
38            7 9 13 21 22 23 25 26 37 53 79 80 81 88 106 110 111 113
39            119 135 139 143 144 179 199 389 427 443 444 445 465 513 514
40            515 543 544 548 554 587 631 646 873 990 993 995 1025 1026 1027
41            1028 1029 1110 1433 1720 1723 1755 1900 2000 2001 2049 2121 2717
42            3000 3128 3306 3389 3986 4899 5000 5009 5051 5060 5101 5190 5357
43            5432 5631 5666 5800 5900 6000 6001 6646 7070 8000 8008 8009 8080
44            8081 8443 8888 9100 9999 10000 32768 49152 49153 49154 49155
45            49156 49157
46         ) ],
47         top1000 => [ qw(
48            1 3 4 6 7 9 13 17 19 20 21 22 23 24 25 26 30 32 33 37
49            42 43 49 53 70 79 80 81 82 83 84 85 88 89 90 99 100 106
50            109 110 111 113 119 125 135 139 143 144 146 161 163 179 199
51            211 212 222 254 255 256 259 264 280 301 306 311 340 366 389
52            406 407 416 417 425 427 443 444 445 458 464 465 481 497 500
53            512 513 514 515 524 541 543 544 545 548 554 555 563 587 593
54            616 617 625 631 636 646 648 666 667 668 683 687 691 700 705
55            711 714 720 722 726 749 765 777 783 787 800 801 808 843 873
56            880 888 898 900 901 902 903 911 912 981 987 990 992 993 995
57            999 1000 1001 1002 1007 1009 1010 1011 1021 1022 1023 1024 1025
58            1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
59            1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
60            1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
61            1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
62            1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
63            1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1102 1104 1105
64            1106 1107 1108 1110 1111 1112 1113 1114 1117 1119 1121 1122 1123
65            1124 1126 1130 1131 1132 1137 1138 1141 1145 1147 1148 1149 1151
66            1152 1154 1163 1164 1165 1166 1169 1174 1175 1183 1185 1186 1187
67            1192 1198 1199 1201 1213 1216 1217 1218 1233 1234 1236 1244 1247
68            1248 1259 1271 1272 1277 1287 1296 1300 1301 1309 1310 1311 1322
69            1328 1334 1352 1417 1433 1434 1443 1455 1461 1494 1500 1501 1503
70            1521 1524 1533 1556 1580 1583 1594 1600 1641 1658 1666 1687 1688
71            1700 1717 1718 1719 1720 1721 1723 1755 1761 1782 1783 1801 1805
72            1812 1839 1840 1862 1863 1864 1875 1900 1914 1935 1947 1971 1972
73            1974 1984 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008
74            2009 2010 2013 2020 2021 2022 2030 2033 2034 2035 2038 2040 2041
75            2042 2043 2045 2046 2047 2048 2049 2065 2068 2099 2100 2103 2105
76            2106 2107 2111 2119 2121 2126 2135 2144 2160 2161 2170 2179 2190
77            2191 2196 2200 2222 2251 2260 2288 2301 2323 2366 2381 2382 2383
78            2393 2394 2399 2401 2492 2500 2522 2525 2557 2601 2602 2604 2605
79            2607 2608 2638 2701 2702 2710 2717 2718 2725 2800 2809 2811 2869
80            2875 2909 2910 2920 2967 2968 2998 3000 3001 3003 3005 3006 3007
81            3011 3013 3017 3030 3031 3050 3052 3071 3077 3128 3168 3211 3221
82            3260 3261 3268 3269 3283 3300 3301 3306 3322 3323 3324 3325 3333
83            3351 3367 3369 3370 3371 3372 3389 3390 3404 3476 3493 3517 3527
84            3546 3551 3580 3659 3689 3690 3703 3737 3766 3784 3800 3801 3809
85            3814 3826 3827 3828 3851 3869 3871 3878 3880 3889 3905 3914 3918
86            3920 3945 3971 3986 3995 3998 4000 4001 4002 4003 4004 4005 4006
87            4045 4111 4125 4126 4129 4224 4242 4279 4321 4343 4443 4444 4445
88            4446 4449 4550 4567 4662 4848 4899 4900 4998 5000 5001 5002 5003
89            5004 5009 5030 5033 5050 5051 5054 5060 5061 5080 5087 5100 5101
90            5102 5120 5190 5200 5214 5221 5222 5225 5226 5269 5280 5298 5357
91            5405 5414 5431 5432 5440 5500 5510 5544 5550 5555 5560 5566 5631
92            5633 5666 5678 5679 5718 5730 5800 5801 5802 5810 5811 5815 5822
93            5825 5850 5859 5862 5877 5900 5901 5902 5903 5904 5906 5907 5910
94            5911 5915 5922 5925 5950 5952 5959 5960 5961 5962 5963 5987 5988
95            5989 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6009 6025
96            6059 6100 6101 6106 6112 6123 6129 6156 6346 6389 6502 6510 6543
97            6547 6565 6566 6567 6580 6646 6666 6667 6668 6669 6689 6692 6699
98            6779 6788 6789 6792 6839 6881 6901 6969 7000 7001 7002 7004 7007
99            7019 7025 7070 7100 7103 7106 7200 7201 7402 7435 7443 7496 7512
100            7625 7627 7676 7741 7777 7778 7800 7911 7920 7921 7937 7938 7999
101            8000 8001 8002 8007 8008 8009 8010 8011 8021 8022 8031 8042 8045
102            8080 8081 8082 8083 8084 8085 8086 8087 8088 8089 8090 8093 8099
103            8100 8180 8181 8192 8193 8194 8200 8222 8254 8290 8291 8292 8300
104            8333 8383 8400 8402 8443 8500 8600 8649 8651 8652 8654 8701 8800
105            8873 8888 8899 8994 9000 9001 9002 9003 9009 9010 9011 9040 9050
106            9071 9080 9081 9090 9091 9099 9100 9101 9102 9103 9110 9111 9200
107            9207 9220 9290 9415 9418 9485 9500 9502 9503 9535 9575 9593 9594
108            9595 9618 9666 9876 9877 9878 9898 9900 9917 9943 9944 9968 9998
109            9999 10000 10001 10002 10003 10004 10009 10010 10012 10024 10025
110            10082 10180 10215 10243 10566 10616 10617 10621 10626 10628 10629
111            10778 11110 11111 11967 12000 12174 12265 12345 13456 13722 13782
112            13783 14000 14238 14441 14442 15000 15002 15003 15004 15660 15742
113            16000 16001 16012 16016 16018 16080 16113 16992 16993 17877 17988
114            18040 18101 18988 19101 19283 19315 19350 19780 19801 19842 20000
115            20005 20031 20221 20222 20828 21571 22939 23502 24444 24800 25734
116            25735 26214 27000 27352 27353 27355 27356 27715 28201 30000 30718
117            30951 31038 31337 32768 32769 32770 32771 32772 32773 32774 32775
118            32776 32777 32778 32779 32780 32781 32782 32783 32784 32785 33354
119            33899 34571 34572 34573 35500 38292 40193 40911 41511 42510 44176
120            44442 44443 44501 45100 48080 49152 49153 49154 49155 49156 49157
121            49158 49159 49160 49161 49163 49165 49167 49175 49176 49400 49999
122            50000 50001 50002 50003 50006 50300 50389 50500 50636 50800 51103
123            51493 52673 52822 52848 52869 54045 54328 55055 55056 55555 55600
124            56737 56738 57294 57797 58080 60020 60443 61532 61900 62078 63331
125            64623 64680 65000 65129 65389
126         ) ],
127         pps => 10_000,
128         try => 2,
129         wait => 5, # Wait 5 seconds for last packet
130         use_ipv6 => 0,
131      },
132      commands => {
133         estimate_runtime => [ qw($ip_list $port_list|OPTIONAL pps|OPTIONAL try|OPTIONAL) ],
134         estimate_bandwidth => [ qw(pps|OPTIONAL size|OPTIONAL) ],
135         estimate_pps => [ qw(bandwidth|OPTIONAL size|OPTIONAL) ],
136         tcp_syn_sender => [ qw($ip_list $port_list|OPTIONAL pps|OPTIONAL try|OPTIONAL) ],
137         tcp_syn_start_receiver => [ qw($port_list|OPTIONAL filter|OPTIONAL listen_device|OPTIONAL) ],
138         tcp_syn_stop_receiver => [ ],
139         tcp_syn_scan => [ qw($ip_list $port_list|OPTIONAL pps|OPTIONAL try|OPTIONAL) ],
140         tcp_syn_receive_until_sender_exit => [ qw(pid pps|OPTIONAL wait|OPTIONAL use_ipv6|OPTIONAL) ],
141      },
142      require_modules => {
143         'Net::Write::Fast' => [ ],
144         'Net::Frame::Simple' => [ ],
145         'POSIX' => [ qw(ceil) ],
146         'Metabrik::Network::Address' => [ ],
147         'Metabrik::Network::Read' => [ ],
148         'Metabrik::System::Process' => [ ],
149         'Metabrik::Worker::Fork' => [ ],
150      },
151   };
152}
153
154sub brik_use_properties {
155   my $self = shift;
156
157   return {
158      attributes_default => {
159         device => defined($self->global) && $self->global->device || 'eth0',
160         listen_device => defined($self->global) && $self->global->device || 'eth0',
161      },
162   };
163}
164
165sub estimate_runtime {
166   my $self = shift;
167   my ($ip_list, $port_list, $pps, $try) = @_;
168
169   $port_list ||= $self->ports || $self->top100;
170   $pps ||= $self->pps;
171   $try ||= $self->try;
172   $self->brik_help_run_undef_arg('estimate_runtime', $ip_list) or return;
173   $self->brik_help_run_undef_arg('estimate_runtime', $port_list) or return;
174
175   my $runtime = Net::Write::Fast::estimate_runtime({
176      targets => $ip_list,
177      ports => $port_list,
178      pps => $pps,
179      try => $try,
180   }) or return $self->log->error('estimate_runtime: failed');
181
182   return $runtime;
183}
184
185
186sub estimate_bandwidth {
187   my $self = shift;
188   my ($pps, $size) = @_;
189
190   $pps ||= $self->pps;
191   #$size ||= 74; # Ethernet (14) + IP (20), + TCP (20) + TCP options (20)
192   $size ||= 60; # IP (20), + TCP (20) + TCP options (20)
193
194   my $count = $pps * $size;
195
196   if (length($pps) > 8) {
197      $count /= 1_000_000_000;
198      return "${count}G";
199   }
200   elsif (length($pps) > 5) {
201      $count /= 1_000_000;
202      return "${count}M";
203   }
204   elsif (length($pps) > 2) {
205      $count /= 1_000;
206      return "${count}K";
207   }
208
209   return "${count}B";
210}
211
212sub estimate_pps {
213   my $self = shift;
214   my ($bandwidth, $size) = @_;
215
216   $bandwidth ||= $self->bandwidth;
217   #$size ||= 74; # Ethernet (14) + IP (20), + TCP (20) + TCP options (20)
218   $size ||= 60; # IP (20), + TCP (20) + TCP options (20)
219
220   my $count = 0;
221   if ($bandwidth =~ m{B$}) {
222      $bandwidth =~ s/.$//;
223      $count = $bandwidth;
224   }
225   elsif ($bandwidth =~ m{K$}) {
226      $bandwidth =~ s/.$//;
227      $count = $bandwidth * 1_000;
228   }
229   elsif ($bandwidth =~ m{M$}) {
230      $bandwidth =~ s/.$//;
231      $count = $bandwidth * 1_000_000;
232   }
233   elsif ($bandwidth =~ m{G$}) {
234      $bandwidth =~ s/.$//;
235      $count = $bandwidth * 1_000_000_000;
236   }
237
238   return $count / $size;
239}
240
241sub tcp_syn_sender {
242   my $self = shift;
243   my ($ip_list, $port_list, $pps, $try) = @_;
244
245   $port_list ||= $self->ports || $self->top100;
246   $pps ||= $self->pps;
247   $try ||= $self->try;
248   $self->brik_help_run_undef_arg('tcp_syn_sender', $ip_list) or return;
249   $self->brik_help_run_invalid_arg('tcp_syn_sender', $ip_list, 'ARRAY') or return;
250   $self->brik_help_run_empty_array_arg('tcp_syn_sender', $ip_list, 'ARRAY') or return;
251   $self->brik_help_run_undef_arg('tcp_syn_sender', $port_list) or return;
252   $self->brik_help_run_invalid_arg('tcp_syn_sender', $port_list, 'ARRAY') or return;
253   $self->brik_help_run_empty_array_arg('tcp_syn_sender', $port_list, 'ARRAY') or return;
254
255   my $device = $self->device;
256   my $use_ipv6 = $self->use_ipv6;
257
258   my $na = Metabrik::Network::Address->new_from_brik_init($self) or return;
259
260   # Set source IP address.
261   my $ip4;
262   my $ip6;
263   if ($use_ipv6) {
264      $ip6 = defined($self->src_ip) ? $self->src_ip : $self->my_ipv6;
265      if (! defined($ip6)) {
266         return $self->log->error("tcp_syn_sender: IPv6 not found for device [$device]");
267      }
268   }
269   else {
270      $ip4 = defined($self->src_ip) ? $self->src_ip : $self->my_ipv4;
271      if (! defined($ip4)) {
272         return $self->log->error("tcp_syn_sender: IPv4 not found for device [$device]");
273      }
274   }
275
276   my $ip = $ip_list->[0];
277   if ($self->use_ipv6) {
278      if (! $na->is_ipv6($ip)) {
279         return $self->log->error("tcp_syn_sender: address [$ip] is not IPv6 in ip_list");
280      }
281      $self->log->verbose("tcp_syn_sender: using source IPv6 [$ip6]");
282   }
283   else {
284      if (! $na->is_ipv4($ip)) {
285         return $self->log->error("tcp_syn_sender: address [$ip] is not IPv4 in ip_list");
286      }
287      $self->log->verbose("tcp_syn_sender: using source IPv4 [$ip4]");
288   }
289
290   $self->log->verbose("tcp_syn_sender: sender started");
291
292   # We have to split by chunks of $chunk_size elements, to avoid taking to
293   # much memory in one row. And there is a SIGSEGV if we don't do so ;)
294   my $chunk_size = 1_000_000; # We can load that much into a ARRAYREF before a SIGSEGV
295   my $n_targets = scalar(@$ip_list);
296   my $n_ports = scalar(@$port_list);
297   my $n_chunks = POSIX::ceil($n_targets / $chunk_size);
298   for my $n (0..$n_chunks-1) {
299      my $first = $chunk_size * $n;
300      my $last = ($chunk_size - 1) + ($chunk_size * $n);
301      if ($last > ($n_targets - 1)) {
302         $last = $n_targets - 1;
303      }
304
305      # By default, we think we scan less than $chunk_size hosts
306      my $target_list = $ip_list;
307
308      # But if we don't, we cut in chunks and $target_list gets a slice
309      if ($n_chunks > 1) {
310         my @this = @$ip_list[$first..$last];
311         $target_list = \@this;
312         $self->log->verbose("tcp_syn_sender: scanning chunk @{[$n+1]}/@{[($n_chunks)]} ".
313            "($first-$last)");
314      }
315
316      my $r = Net::Write::Fast::l4_send_tcp_syn_multi(
317         $use_ipv6 ? $ip6 : $ip4,
318         $target_list,
319         $port_list,
320         $pps,
321         $try,
322         $use_ipv6,
323         1,  # display warnings or not
324      );
325      if ($r == 0) {
326         $self->log->error("tcp_syn_sender: l4_send_tcp_syn_multi: ".
327            Net::Write::Fast::nwf_geterror());
328      }
329   }
330
331   $self->log->verbose("tcp_syn_sender: sender finished");
332
333   # We return the number of packets sent
334   return $n_targets * $n_ports;
335}
336
337sub tcp_syn_start_receiver {
338   my $self = shift;
339   my ($port_list, $filter, $listen_device) = @_;
340
341   if (defined($port_list)) {
342      $self->brik_help_run_invalid_arg('tcp_syn_start_receiver', $port_list, 'ARRAY')
343         or return;
344      $self->brik_help_run_empty_array_arg('tcp_syn_start_receiver', $port_list)
345         or return;
346   }
347
348   $listen_device ||= $self->listen_device;
349
350   my $nr = Metabrik::Network::Read->new_from_brik_init($self) or return;
351
352   my $ip = '';
353   if ($self->use_ipv6) {
354      $ip = (defined($self->src_ip) ? $self->src_ip : $self->my_ipv6) or return;
355   }
356   else {
357      $ip = (defined($self->src_ip) ? $self->src_ip : $self->my_ipv4) or return;
358   }
359
360   if (defined($port_list)) {
361      $self->log->verbose("tcp_syn_start_receiver: scanning for ".scalar(@$port_list).
362         " port(s)");
363   }
364   
365   # Create a filter if not provided by user
366   if (! defined($filter)) {
367      $filter = $self->use_ipv6
368         ? 'tcp and (ip6 and dst host '.$ip.')'
369         : 'tcp and (((tcp[13] & 2 != 0) and (tcp[13] & 16 != 0) and dst host '.$ip.')'.
370           ' or '.
371           '((tcp[13] & 4 != 0) and (tcp[13] & 16 != 0) and dst host '.$ip.'))';
372
373      # If only a few ports specified, we use that in the filter
374      if (defined($port_list) && @$port_list <= 10) {
375         $filter .= " and (";
376         for (@$port_list) {
377            $filter .= "src port $_ or ";
378         }
379         $filter =~ s/ or $/)/;
380      }
381   }
382
383   $self->log->verbose("tcp_syn_start_receiver: using filter [$filter]");
384
385   $nr->filter($filter);
386   $nr->device($listen_device);
387
388   $nr->open or return;
389 
390   return $self->_nr($nr);
391}
392
393sub tcp_syn_stop_receiver {
394   my $self = shift;
395
396   my $nr = $self->_nr;
397   if (! defined($nr)) {
398      return 1;
399   }
400
401   $self->log->debug("tcp_syn_stop_receiver: closing nr...");
402   $nr->close;
403   $self->_nr(undef);
404   $self->log->debug("tcp_syn_stop_receiver: closing nr...done");
405
406   return 1;
407}
408
409sub tcp_syn_receive_until_sender_exit {
410   my $self = shift;
411   my ($pid, $pps, $wait, $use_ipv6) = @_;
412
413   $pps ||= $self->pps;
414   $wait ||= $self->wait;
415   my $nr = $self->_nr;
416   $use_ipv6 = 0;
417   $self->brik_help_run_undef_arg('tcp_syn_receive_until_sender_exit', $pid) or return;
418   $self->brik_help_run_undef_arg('tcp_syn_receive_until_sender_exit', $pps) or return;
419   $self->brik_help_run_undef_arg('tcp_syn_receive_until_sender_exit', $wait) or return;
420   $self->brik_help_run_undef_arg('tcp_syn_start_receiver', $nr) or return;
421
422   my $sp = Metabrik::System::Process->new_from_brik_init($self) or return;
423
424   my %open;
425   my %closed;
426   while (! $nr->has_timeout) {
427      # We blocking until X frames are read or a Y second timeout has occured
428      # X is calcluted as a ratio of the pps rate.
429      $self->log->debug("tcp_syn_receive_until_sender_exit: waiting stuff");
430      if (my $next = $nr->read_until_timeout($pps / 30, $wait)) { 
431         $self->log->debug("tcp_syn_receive_until_sender_exit: read_until_timeout has stuff");
432         for my $f (@$next) {
433            my $s = Net::Frame::Simple->newFromDump($f);
434            if ($s->ref->{TCP}) {
435               my $ip  = $use_ipv6 ? $s->ref->{IPv6} : $s->ref->{IPv4};
436               my $tcp = $s->ref->{TCP};
437               if ($tcp->flags == 0x12) { # SYN+ACK
438                  $open{$ip->src}{$tcp->src} = {
439                     ip => $ip->src,
440                     port => $tcp->src,
441                     id => $use_ipv6 ? $ip->flowLabel : $ip->id,
442                     ttl => $use_ipv6 ? $ip->hopLimit : $ip->ttl,
443                     win => $tcp->win,
444                     opt => unpack('H*', $tcp->options),
445                     flags => 'SA',
446                  };
447                  $self->log->debug("tcp_syn_receive_until_sender_exit: ".sprintf(
448                     "tcp  %s  [%-15s]:%-5d   %-5d  %-3d  %-5d  %s",
449                        $open{$ip->src}{$tcp->src}->{flags},
450                        $ip->src,
451                        $tcp->src,
452                        $open{$ip->src}{$tcp->src}->{id},
453                        $open{$ip->src}{$tcp->src}->{ttl},
454                        $open{$ip->src}{$tcp->src}->{win},
455                        $open{$ip->src}{$tcp->src}->{opt},
456                     ),
457                  );
458               }
459               elsif ($tcp->flags == 0x14) { # RST+ACK
460                  $closed{$ip->src}{$tcp->src} = {
461                     ip => $ip->src,
462                     port => $tcp->src,
463                     id => $use_ipv6 ? $ip->flowLabel : $ip->id,
464                     ttl => $use_ipv6 ? $ip->hopLimit  : $ip->ttl,
465                     win => $tcp->win,
466                     opt => unpack('H*', $tcp->options),
467                     flags => 'RA',
468                  };
469               }
470            }
471         }
472         if ($nr->has_timeout) {
473            $self->log->debug("tcp_syn_receive_until_sender_exit: has_timeout");
474            if (! $sp->is_running($pid)) {
475               $self->log->verbose("tcp_syn_receive_until_sender_exit: no more sender, stopping loop");
476               last;
477            }
478            $self->log->debug("tcp_syn_receive_until_sender_exit: reset_timeout");
479            $nr->reset_timeout;
480         }
481      }
482   }
483
484   return { open => \%open, closed => \%closed };
485}
486
487sub tcp_syn_scan {
488   my $self = shift;
489   my ($ip_list, $port_list, $pps, $try) = @_;
490
491   $port_list ||= $self->ports;
492   $port_list ||= $self->top100;
493   $pps ||= $self->pps;
494   $try ||= $self->try;
495   $self->brik_help_run_undef_arg('tcp_syn_scan', $ip_list) or return;
496   my $ref1 = $self->brik_help_run_invalid_arg('tcp_syn_scan', $ip_list, 'ARRAY', 'SCALAR')
497      or return;
498   if ($ref1 eq 'SCALAR') {
499      $ip_list = [ $ip_list ];
500   }
501   $self->brik_help_run_empty_array_arg('tcp_syn_scan', $ip_list) or return;
502   $self->brik_help_run_undef_arg('tcp_syn_scan', $port_list, 'ARRAY') or return;
503   my $ref2 = $self->brik_help_run_invalid_arg('tcp_syn_scan', $port_list, 'ARRAY', 'SCALAR')
504      or return;
505   if ($ref2 eq 'SCALAR') {
506      $port_list = [ $port_list ]; 
507   }
508   $self->brik_help_run_empty_array_arg('tcp_syn_scan', $port_list) or return;
509
510   my $wait = $self->wait;
511
512   my $na = Metabrik::Network::Address->new_from_brik_init($self) or return;
513
514   my $nr = $self->tcp_syn_start_receiver($port_list) or return;
515
516   my $estimate = $self->estimate_runtime($ip_list, $port_list, $pps, $try);
517   if (defined($estimate)) {
518      my $string = sprintf(
519         "Estimated runtime: %d day(s) %d hour(s) %d minute(s) %d second(s) for %d host(s)",
520         $estimate->{days},
521         $estimate->{hours},
522         $estimate->{minutes},
523         $estimate->{seconds},
524         $estimate->{nhosts},
525      );
526      $self->log->verbose("tcp_syn_scan: $string");
527   }
528
529   my $start = time();
530
531   # Fork sender process
532   my $wf = Metabrik::Worker::Fork->new_from_brik_init($self) or return;
533   defined(my $pid = $wf->start) or return $self->log->error("tcp_syn_scan: start failed");
534
535   if (! $pid) { # Son
536      $self->log->debug("tcp_syn_scan: son starts its task...");
537      $self->tcp_syn_sender($ip_list, $port_list, $pps, $try);
538      $self->log->debug("tcp_syn_scan: son finished its task, exiting");
539      exit(0);
540   }
541
542   my $use_ipv6 = $na->is_ipv6($ip_list->[0]) ? 1 : 0;
543
544   # Father: analyse received frames
545   $self->log->debug("tcp_syn_scan: father starts");
546   my $r = $self->tcp_syn_receive_until_sender_exit($pid, $pps, $wait, $use_ipv6);
547   $self->log->debug("tcp_syn_scan: father finished");
548   
549   $self->tcp_syn_stop_receiver($nr);
550
551   $self->log->verbose("tcp_syn_scan: completed in ".(time() - $start)." second(s)");
552
553   return $r;
554}
555
5561;
557
558__END__
559
560=head1 NAME
561
562Metabrik::Network::Portscan - network::portscan Brik
563
564=head1 COPYRIGHT AND LICENSE
565
566Copyright (c) 2014-2018, Patrice E<lt>GomoRE<gt> Auffret
567
568You may distribute this module under the terms of The BSD 3-Clause License.
569See LICENSE file in the source distribution archive.
570
571=head1 AUTHOR
572
573Patrice E<lt>GomoRE<gt> Auffret
574
575=cut
Note: See TracBrowser for help on using the repository browser.