$ lsb_release -a
No LSB modules are available.
Distributor ID: Debian
Description:    Debian GNU/Linux 12 (bookworm)
Release:        12
Codename:       bookworm
# tap デバイス(tap7)とブリッジ(br3)の準備
$ sudo apt install bridge-utils
$ sudo ip tuntap add name tap7 mode tap
$ sudo ip link set dev tap7 up
$ sudo brctl addbr br3
$ sudo brctl addif br3 tap7
$ sudo ip address add 192.168.0.101/24 broadcast 192.168.0.255 dev br3
$ sudo ip route add 192.168.0.0/24 via 192.168.0.101 dev br3
$ sudo ip link set dev br3 up
# すべてちゃんとネットワークができていることを確認
$ ip address show tap7
6: tap7: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel master br3 st
ate UP group default qlen 1000
    link/ether 2e:96:f6:3d:62:84 brd ff:ff:ff:ff:ff:ff
    inet6 fe80::2c96:f6ff:fe3d:6284/64 scope link 
       valid_lft forever preferred_lft forever
$ ip address show br3
7: br3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group 
default qlen 1000
    link/ether 46:59:6a:94:e1:65 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.101/24 brd 192.168.0.255 scope global br3
       valid_lft forever preferred_lft forever
    inet6 fe80::4459:6aff:fe94:e165/64 scope link 
       valid_lft forever preferred_lft forever
$ brctl show br3
bridge name     bridge id               STP enabled     interfaces
br3             8000.46596a94e165       no              tap7
$ ip route show 192.168.0.0/24 
192.168.0.0/24 dev br3 proto kernel scope link src 192.168.0.101 

# Pythonの環境準備
$ python3 -m venv --system-site-packages --symlinks --clear --prompt 'pytcp' --upgrade-deps .venv
$ source .venv/bin/activate
(pytcp) $ pip3 install PyTCP   #PyTCPを導入
(pytcp) $ ls 
tcpchallenge_ack_only.py
(pytcp) $ ./tcpchallenge_ack_only.py
 0006.52 | SOCKET  | TcpChallengeAckSocket.__init__ | [AF_INET4/SOCK_STREAM/0.0.
0.0/0/0.0.0.0/0] - Create socket
 0006.52 | SOCKET  | TcpChallengeAckSocket.bind | [AF_INET4/SOCK_STREAM/0.0.0.0/
8000/0.0.0.0/0] - Bound socket
 0006.52 | SOCKET-CH | TcpChallengeAckSocket.listner_to_send_challenge_ack | [AF
_INET4/SOCK_STREAM/0.0.0.0/8000/0.0.0.0/0] - Socket starting to listen for inbou
nd to send challenge ack.

$ sudo wireshark &
$ curl https://192.168.0.101:8000/

(pytcp) $ git clone https://github.com/ccie18643/PyTCP 
(pytcp) $ cd PyTCP
(pytcp) $ git checkout -b your-spike
(pytcp) $ vi examples/tcp_echo_service.py
    stack = TcpIpStack(interface=interface)
　　　　↓　こう変更する。tap7デバイスに192.168.0.100を直接割り当てるの意味
    stack = TcpIpStack(interface=interface,ip4_address="192.168.0.100/24")
(pytcp) $ env PYTHONPATH=(pwd) python3 examples/tcp_echo_service.py

$ sudo apt install netcat-traditional
$ hash -r
$ nc 192.168.0.100 7
***CLIENT OPEN / SERVICE OPEN*** ←早速example/tcp_echo_service.pyから応答。
hello ← 打ち込む
hello ← echoサーバから応答
malpka ← malpka/malpa/malpiのいずれかのコマンドを打つと、猿の絵がでてくる。

                                       
                                       
                                       
                                       
               .="=.                   
             _/.-.-.\_    _            
            ( ( o o ) )   ))           
             |/  "  \|   //            
              \'---'/   //             
              /`---`\  ((              
             / /_,_\ \  \\             
             \_\_'__/ \  ))            
             /`  /`~\  |//             
            /   /    \  /              
        ,--`,--'\/\    /               
         '-- "--'  '--'                
                                       
                                       
                                       
                                       
                                       
quit ←　quitと打つと終了する。
***CLIENT OPEN, SERVICE CLOSING***

    PacketHandler._phrx_tcp=_phrx_custom_tcp # monkey patching to PacketHandler

#!/usr/bin/env python3

import sys
from pytcp import config,TcpIpStack
from pytcp.lib import socket,stack
from pytcp.protocols.tcp.socket import TcpSocket
from pytcp.lib.logger import log
from pytcp.subsystems.packet_handler import PacketHandler
from pytcp.protocols.tcp.fpp import TcpParser
from pytcp.protocols.tcp.metadata import TcpMetadata
from threading import RLock

def _phrx_custom_tcp(self, packet_rx):
    """
    Custom Handler inbound TCP packets.
    This codes are borrowed from _phrx_tcp()
    """

    self.packet_stats_rx.tcp__pre_parse += 1

    TcpParser(packet_rx)

    if packet_rx.parse_failed:
        self.packet_stats_rx.tcp__failed_parse__drop += 1
        __debug__ and log(
            "tcp-ch",
            f"{packet_rx.tracker} - <CRIT>{packet_rx.parse_failed}</>",
        )
        return

    __debug__ and log("tcp-ch", f"{packet_rx.tracker} - {packet_rx.tcp}")

    assert isinstance(
        packet_rx.tcp.data, memoryview
    )  # memoryview: data type check point

    # Create TcpMetadata object for further processing by TCP FSM
    packet_rx_md = TcpMetadata(
        local_ip_address=packet_rx.ip.dst,
        local_port=packet_rx.tcp.dport,
        remote_ip_address=packet_rx.ip.src,
        remote_port=packet_rx.tcp.sport,
        flag_syn=packet_rx.tcp.flag_syn,
        flag_ack=packet_rx.tcp.flag_ack,
        flag_fin=packet_rx.tcp.flag_fin,
        flag_rst=packet_rx.tcp.flag_rst,
        seq=packet_rx.tcp.seq,
        ack=packet_rx.tcp.ack,
        win=packet_rx.tcp.win,
        wscale=packet_rx.tcp.wscale,
        mss=packet_rx.tcp.mss,
        data=packet_rx.tcp.data,  # memoryview: passing as memoryview for tcp
        # session to consume, no need to convert to
        # bytes here
        tracker=packet_rx.tracker,
    )

    # Check if incoming packet matches active TCP socket.
    if tcp_socket := stack.sockets.get(str(packet_rx_md), None):
        self.packet_stats_rx.tcp__socket_match_active__forward_to_socket += 1
        __debug__ and log(
            "tcp-ch",
            f"{packet_rx_md.tracker} - <INFO>TCP packet is part of active "
            f"socket [{tcp_socket}]</>",
        )
        tcp_socket.process_tcp_packet(packet_rx_md)
        return

    # Check if incoming packet is an initial SYN packet and if it matches any
    # listening TCP socket.
    if all({packet_rx_md.flag_syn}) and not any(
        {packet_rx_md.flag_ack, packet_rx_md.flag_fin, packet_rx_md.flag_rst}
    ):
        for (
            tcp_listening_socket_pattern
        ) in packet_rx_md.tcp_listening_socket_patterns:
            if tcp_socket := stack.sockets.get(
                tcp_listening_socket_pattern, None
            ):
                self.packet_stats_rx.tcp__socket_match_listening__forward_to_socket += (
                    1
                )
                __debug__ and log(
                    "tcp-ch",
                    f"{packet_rx_md.tracker} - <INFO>TCP packet matches "
                    f"listening socket [{tcp_socket}]</>",
                )
                tcp_socket.process_tcp_packet(packet_rx_md)
                return

    # In case packet doesn't match any session send RST packet, Ignore it.
    self.packet_stats_rx.tcp__no_socket_match__respond_rst += 1
    __debug__ and log(
        "tcp-ch",
        f"{packet_rx.tracker} - TCP packet from {packet_rx.ip.src} to "
        f"closed port {packet_rx.tcp.dport},Simply Ignored" 
    )
    return

class TcpSendChallengeAckSession:
    def _send_tcp_challenge_ack_to_remote(self,packet_rx_md):
        winsz = 224

        stack.packet_handler.send_tcp_packet(
            local_ip_address=packet_rx_md.local_ip_address,
            remote_ip_address=packet_rx_md.remote_ip_address,
            local_port=packet_rx_md.local_port,
            remote_port=packet_rx_md.remote_port,
            flag_syn=False,
            flag_ack=True,
            flag_fin=False,
            flag_rst=False,
            seq=packet_rx_md.seq+1,
            ack=packet_rx_md.seq+packet_rx_md.win-1,
            win=winsz,
            mss=None,
            wscale=None,
            data=None,
        )

    def tcp_fsm(self,packet_rx_md):
        if packet_rx_md is None:
            __debug__ and \
                log("tcp-ch-ss",f"uh? packt_rx_md is None,but invoke tcp_fsm")
            return
        # always send tcp challenge ack to remote
        with RLock():
            self._send_tcp_challenge_ack_to_remote(packet_rx_md)

class TcpChallengeAckSocket(TcpSocket):
    def listner_to_send_challenge_ack(self):
        self._tcp_session = TcpSendChallengeAckSession()
        __debug__ and log(
            "socket-ch",
            f"<g>[{self}]</> - Socket starting to listen for "
            "inbound to send challenge ack."
        )
        stack.sockets[str(self)] = self

if __name__ == "__main__":
    config.LOG_DEBUG = True
    config.LOG_CHANEL = {
        "tcp",
        "tcp-ch",
        "socket",
        "tcp-ch-ss",
        "socket-ch",
    }
    tcpip_stack = TcpIpStack(interface='tap7',ip4_address="192.168.0.100/24")
    PacketHandler._phrx_tcp=_phrx_custom_tcp # monkey patching to PacketHandler
    tcpip_stack.start()
    listening_socket = TcpChallengeAckSocket(family=socket.AF_INET4)
    listening_socket.bind(("0.0.0.0", 8000))
    listening_socket.listner_to_send_challenge_ack()
    sys.exit(0)