probe/discovery/protocol/tcp/syn/synv4.go
2018-08-31 23:00:08 +09:00

204 lines
4.4 KiB
Go

package syn
import (
"encoding/json"
"fmt"
"log"
"net"
"strconv"
"sync/atomic"
"time"
omd "git.loafle.net/overflow/model/discovery"
omm "git.loafle.net/overflow/model/meta"
omu "git.loafle.net/overflow/model/util"
"git.loafle.net/overflow_scanner/probe/discovery/session"
"git.loafle.net/overflow_scanner/probe/internal/pcap"
"github.com/google/gopacket"
"github.com/google/gopacket/layers"
)
func scanV4(discoverySession session.DiscoverySession, targetHost *omd.Host) error {
ps, err := pcap.RetainScanner(targetHost.Zone)
if nil != err {
return fmt.Errorf("Discovery: Cannot retain pcap instance %v", err)
}
defer func() {
go pcap.ReleaseScanner(targetHost.Zone)
}()
tcpChan := ps.OpenTCP(targetHost.Address)
defer func() {
go ps.CloseTCP(targetHost.Address, tcpChan)
}()
timerStopped := make(chan struct{})
go func() {
ports := make(map[int]*omd.Port)
var delay atomic.Value
delay.Store(false)
ticker := time.NewTicker(time.Millisecond * 500)
for {
select {
case packet, ok := <-tcpChan:
if !ok {
// olog.Logger().Debug("Discovery: tcp channel is closed")
return
}
delay.Store(true)
if p := handlePacketTCP4(discoverySession, targetHost, ports, packet); nil != p {
// resultChan <- p
log.Println(p)
}
case <-ticker.C:
if false == delay.Load().(bool) {
ticker.Stop()
timerStopped <- struct{}{}
return
}
delay.Store(false)
}
}
}()
if err := sendTCP4(discoverySession, ps, targetHost); nil != err {
log.Printf("sendTCP %v", err)
return nil
}
select {
case <-timerStopped:
return nil
}
}
func sendTCP4(discoverySession session.DiscoverySession, ps pcap.PCapScanner, host *omd.Host) error {
dp := discoverySession.DiscoverPort()
tcpPacket, err := makePacketPortTCP4(host)
if nil != err {
return err
}
buf := gopacket.NewSerializeBuffer()
Loop:
for portNumber := dp.FirstScanRange; portNumber < dp.LastScanRange; portNumber++ {
if nil != dp.ExcludePorts {
for _, exPortNumber := range dp.ExcludePorts {
if portNumber == exPortNumber {
continue Loop
}
}
}
tcpPacket.TCP.DstPort = layers.TCPPort(portNumber)
if err := tcpPacket.TCP.SetNetworkLayerForChecksum(tcpPacket.IP); err != nil {
return err
}
if err := gopacket.SerializeLayers(buf, tcpPacket.Opts, tcpPacket.Eth, tcpPacket.IP, tcpPacket.TCP); err != nil {
return err
}
if err := ps.WritePacketData(buf.Bytes()); err != nil {
return err
}
timer := time.NewTimer(time.Microsecond * 100)
select {
case <-timer.C:
}
}
return nil
}
func handlePacketTCP4(discoverySession session.DiscoverySession, host *omd.Host, ports map[int]*omd.Port, packet *layers.TCP) *omd.Port {
if nil == packet || packet.DstPort != 60000 {
return nil
}
dp := discoverySession.DiscoverPort()
if packet.SYN && packet.ACK {
port := int(packet.SrcPort)
if _, ok := ports[port]; ok || !dp.Contains(port) {
return nil
}
// olog.Logger().Debug("Discovery", zap.String("ip", host.Address), zap.Int("port", port))
p := &omd.Port{
MetaPortType: omm.ToMetaPortType(omm.MetaPortTypeEnumTCP),
PortNumber: json.Number(strconv.Itoa(port)),
DiscoveredDate: omu.NowPtr(),
}
p.Host = host
ports[port] = p
return p
}
return nil
}
type PortPacketTCP4 struct {
Eth *layers.Ethernet
IP *layers.IPv4
TCP *layers.TCP
Opts gopacket.SerializeOptions
//PacketConn net.PacketConn
}
func makePacketPortTCP4(host *omd.Host) (*PortPacketTCP4, error) {
packetTCP := &PortPacketTCP4{}
srcIP := net.ParseIP(host.Zone.Address)
if nil == srcIP {
return nil, fmt.Errorf("IP(%s) of zone is not valid", host.Zone.Address)
}
dstIP := net.ParseIP(host.Address)
if nil == dstIP {
return nil, fmt.Errorf("IP(%s) of host is not valid", host.Address)
}
srcMac, err := net.ParseMAC(host.Zone.Mac)
if nil != err {
return nil, err
}
dstMac, err := net.ParseMAC(host.Mac)
if nil != err {
return nil, err
}
packetTCP.Eth = &layers.Ethernet{
SrcMAC: srcMac,
DstMAC: dstMac,
EthernetType: layers.EthernetTypeIPv4,
}
packetTCP.IP = &layers.IPv4{
SrcIP: srcIP,
DstIP: dstIP,
Version: 4,
TTL: 64,
Protocol: layers.IPProtocolTCP,
}
packetTCP.TCP = &layers.TCP{
SrcPort: 60000,
DstPort: 0, // will be incremented during the scan
SYN: true,
Seq: 0,
}
packetTCP.Opts = gopacket.SerializeOptions{
ComputeChecksums: true,
FixLengths: true,
}
return packetTCP, nil
}