110 lines
4.3 KiB
Nim
110 lines
4.3 KiB
Nim
import asyncdispatch, asyncnet, strformat
|
|
from net import IpAddress, Port, `$`, `==`, parseIpAddress
|
|
from random import randomize, rand
|
|
from sequtils import any
|
|
import ip_packet
|
|
import port_prediction
|
|
import puncher
|
|
import raw_socket
|
|
import utils
|
|
|
|
export PunchHoleError
|
|
|
|
type
|
|
Attempt = object
|
|
srcIp: IpAddress
|
|
srcPort: Port
|
|
dstIp: IpAddress
|
|
dstPorts: seq[Port]
|
|
seqNums: seq[uint32]
|
|
future: Future[AsyncSocket]
|
|
|
|
TcpSyniResponder* = Puncher[Attempt]
|
|
|
|
proc cleanup*(puncher: TcpSyniResponder) {.async.} =
|
|
while puncher.attempts.len() != 0:
|
|
await puncher.attempts.pop().deleteFirewallRules()
|
|
|
|
proc initTcpSyniResponder*(): TcpSyniResponder =
|
|
randomize()
|
|
TcpSyniResponder()
|
|
|
|
proc injectSynPackets(attempt: Attempt) {.async.} =
|
|
let injectFd = setupTcpInjectingSocket()
|
|
for dstPort in attempt.dstPorts:
|
|
let synOut = IpPacket(protocol: tcp, ipAddrSrc: attempt.srcIp,
|
|
ipAddrDst: attempt.dstIp, ipTTL: 2,
|
|
tcpPortSrc: attempt.srcPort, tcpPortDst: dstPort,
|
|
tcpSeqNumber: rand(uint32), tcpAckNumber: 0,
|
|
tcpFlags: {SYN}, tcpWindowSize: 1452 * 10)
|
|
echo &"[{synOut.ipAddrSrc}:{synOut.tcpPortSrc} -> {synOut.ipAddrDst}:{synOut.tcpPortDst}, SEQ {synOut.tcpSeqNumber}] injecting outgoing SYN"
|
|
await injectFd.injectTcpPacket(synOut)
|
|
for seqNum in attempt.seqNums:
|
|
let synIn = IpPacket(protocol: tcp, ipAddrSrc: attempt.dstIp,
|
|
ipAddrDst: attempt.srcIp, ipTTL: 64,
|
|
tcpPortSrc: dstPort,
|
|
tcpPortDst: attempt.srcPort,
|
|
tcpSeqNumber: seqNum, tcpAckNumber: 0,
|
|
tcpFlags: {SYN}, tcpWindowSize: 1452 * 10)
|
|
echo &"[{synIn.ipAddrSrc}:{synIn.tcpPortSrc} -> {synIn.ipAddrDst}:{synIn.tcpPortDst}, SEQ {synIn.tcpSeqNumber}] injecting incoming SYN"
|
|
await injectFd.injectTcpPacket(synIn)
|
|
closeSocket(injectFd)
|
|
|
|
proc accept(puncher: TcpSyniResponder, srcIp: IpAddress,
|
|
srcPort: Port) {.async.} =
|
|
let sock = newAsyncSocket()
|
|
sock.setSockOpt(OptReuseAddr, true)
|
|
sock.bindAddr(srcPort, $srcIp)
|
|
sock.listen()
|
|
while true:
|
|
let acceptFuture = sock.accept()
|
|
await acceptFuture or sleepAsync(Timeout)
|
|
if acceptFuture.finished():
|
|
let peer = acceptFuture.read()
|
|
let (peerAddr, peerPort) = peer.getPeerAddr()
|
|
let peerIp = parseIpAddress(peerAddr)
|
|
let i = puncher.findAttempt(srcIp, srcPort, peerIp, @[peerPort])
|
|
if i == -1:
|
|
echo "Accepted connection, but no attempt found. Discarding."
|
|
peer.close()
|
|
continue
|
|
else:
|
|
let attempt = puncher.attempts[i]
|
|
attempt.future.complete(peer)
|
|
let attempts = puncher.findAttemptsByLocalAddr(srcIp, srcPort)
|
|
# FIXME: should attempts have timestamps, so we can decide here which ones to delete?
|
|
if attempts.len() <= 1:
|
|
break
|
|
sock.close()
|
|
|
|
proc respond*(puncher: TcpSyniResponder, srcPort: Port, dstIp: IpAddress,
|
|
dstPorts: seq[Port],
|
|
seqNums: seq[uint32]): Future[AsyncSocket] {.async.} =
|
|
let localIp = getPrimaryIPAddr(dstIp)
|
|
let existingAttempts = puncher.findAttemptsByLocalAddr(localIp, srcPort)
|
|
if existingAttempts.len() == 0:
|
|
echo &"accepting connections from {dstIp}:{dstPorts[0].int}"
|
|
asyncCheck puncher.accept(localIp, srcPort)
|
|
else:
|
|
for a in existingAttempts:
|
|
if a.dstIp == dstIp and
|
|
a.dstPorts.any(proc (p: Port): bool = p in dstPorts):
|
|
raise newException(PunchHoleError, "hole punching for given parameters already active")
|
|
try:
|
|
let attempt = Attempt(srcIp: localIp, srcPort: srcPort, dstIp: dstIp,
|
|
dstPorts: predictPortRange(dstPorts),
|
|
seqNums: seqNums,
|
|
future: newFuture[AsyncSocket]("accept"))
|
|
puncher.attempts.add(attempt)
|
|
await attempt.addFirewallRules() # FIXME: needed?
|
|
await attempt.injectSynPackets()
|
|
await attempt.future or sleepAsync(Timeout)
|
|
await attempt.deleteFirewallRules() # FIXME: needed?
|
|
puncher.attempts.del(puncher.attempts.find(attempt))
|
|
if attempt.future.finished():
|
|
result = attempt.future.read()
|
|
else:
|
|
raise newException(PunchHoleError, "timeout")
|
|
except OSError as e:
|
|
raise newException(PunchHoleError, e.msg)
|