Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/thetoriqul/two-ns-connect-using-bridge

Namespaces Bridged Together and Connected to the Internet. This project aims to establish a communication bridge between two distinct, isolated environments known as namespaces. These namespaces can encapsulate various entities such as network resources, processes, or variables, ensuring separate execution and protection within a large system.
https://github.com/thetoriqul/two-ns-connect-using-bridge

Last synced: 3 days ago
JSON representation

Namespaces Bridged Together and Connected to the Internet. This project aims to establish a communication bridge between two distinct, isolated environments known as namespaces. These namespaces can encapsulate various entities such as network resources, processes, or variables, ensuring separate execution and protection within a large system.

Awesome Lists containing this project

README 

        
# Connecting Two Islands: Namespaces Bridged Together and Connected to the Internet



Imagine two separate islands, each with its own unique environment and resources. To connect and enable communication between them, we can build a bridge. This project is similar, but instead of physical islands, we're dealing with virtual namespaces.



Namespaces are like isolated containers within a system, holding their own network resources like IP addresses and routing tables. This project aims to **connect two such namespaces** using a **bridge**, allowing them to **communicate and share data**.



Think of the bridge as a central hub, forwarding messages between the two islands (namespaces). This connection can be useful for various purposes, such as:



* **Isolating network segments:** Keeping different parts of a system's network separate while enabling controlled communication.

* **Testing and development:** Creating isolated environments for testing applications or configurations without affecting the main system.

* **Security:** Enhancing security by restricting communication between different parts of the system.



**Key Components:**



- **Namespaces:** The two independent environments you want to connect. (Specific nature and purpose may vary depending on the use case.)

- **Bridge:** A virtual network device that forwards traffic between the namespaces according to defined rules. It operates at the data link layer (Layer 2) of the OSI model.



### Implementation Steps (General Guide):



This script appears to be a comprehensive setup for networking using network namespaces, bridges, and port forwarding. It sets up a network environment with two namespaces (red and green), a bridge (br0), and performs various configurations and tests within these namespaces.



Here's a more concise outline of the network namespace implementation steps:

1. **Pre-installation:** Update packages and install required tools.

2. **Create Namespaces:** Create two network namespaces (e.g., "red" and "green").

3. **Bridge Network:** Create and activate a bridge interface (e.g., "br0") with an IP address (e.g., 192.168.1.1/24).

4. **Veth Interfaces:**

   - For each namespace:

     - Create a veth pair, move one interface to the namespace, and activate it in both.

     - Attach the veth interface to the bridge.

5. **IP & Routes:**

   - Within each namespace: Assign an IP address to the veth interface and set a default route via the bridge.

6. **Loopback:** Enable loopback interfaces in the host and both namespaces.

7. **Testing:** Test connectivity between namespaces and the host using ping.

8. **Optional:** Configure internet access, server within a namespace, and port forwarding (if needed).

9. **Optional Cleanup:** Remove namespaces, veth interfaces, bridge, and iptables rules.



### Use Cases and Benefits:

* **Network Isolation and Testing**: Easily create isolated network environments for testing without impacting the host system.

* **Microservices and Containerization**: Enable isolation and efficient networking for microservices or containers, improving security and resource management.

* **Virtual Networking and Simulation**: Simulate complex network topologies for educational purposes, training, or troubleshooting.

* **Software-Defined Networking (SDN) Development**: Build the foundation for SDN experiments and development by simulating network elements within namespaces.

* **Security Testing and Penetration Testing**: Safely analyze and test potentially harmful network traffic or applications within isolated namespaces.

* **Internet Gateway and NAT Configuration**: Share internet connectivity among namespaces or containers while protecting internal IP addresses through NAT.

* **Port Forwarding and Service Access**: Easily expose services hosted in isolated environments to external clients or other parts of the network.



In summary, the script facilitates efficient network setup and management within Linux environments, offering benefits such as isolation, security, flexibility, and ease of service access and testing.



## Let's Deep Dive into Network Namespaces and Bridging: A Step-by-Step Analysis

The provided script delves into the realm of network namespaces and bridging, creating isolated network environments and enabling their communication with the internet. It also demonstrates setting up a basic server and port forwarding. Let's dissect each step, unraveling the underlying concepts and their significance:



**Step 0: Pre-setup Checks**



- Updates package lists and performs upgrades (if applicable).

- Installs essential network administration tools.

- Displays network interface and routing information to verify initial network status.

- Root privileges (use `sudo` cautiously)

- Basic understanding of networking concepts (IP addresses, namespaces, bridges, etc.)

- Network access on the host machine



**Installation (if necessary)**



```bash

sudo apt update && sudo apt upgrade -y

sudo apt install net-tools iproute2 iputils-ping tcpdump iptables -y

```



**Step 1: Create Network Namespaces**



- Creates network namespaces named `red` and `green` using `ip netns add`.

- Lists all created namespaces using `ip netns list`.

- Verifies the creation of namespaces in the `/var/run/netns` directory (optional).



**Step 2: Create Bridge Network**



- Creates a bridge interface named `br0` using `ip link add`.

- Activates the bridge interface using `ip link set br0 up`.

- Assigns an IP address (`192.168.1.1/24`) to the bridge interface using `ip addr add`.

- Verifies assigned IP addresses using `ip addr`.

- Pings the bridge interface to test connectivity using `ping`.



**Step 3: Create Veth Interfaces**



- Creates a pair of veth interfaces (`veth0` and `ceth0`) for the `red` namespace using `ip link add`.

- Moves `ceth0` to the `red` namespace and activates it within the namespace using `ip link set ceth0 netns red && sudo ip netns exec red ip link set ceth0 up`.

- Attaches `veth0` to the bridge `br0` using `ip link set veth0 master br0`.

- Activates `veth0` using `ip link set veth0 up`.

- Displays network interfaces within the host machine and `red` namespace using `ip link`.

- Assigns an IP address (`192.168.1.10/24`) to `ceth0` within the `red` namespace using `ip netns exec red ip addr add 192.168.1.10/24 dev ceth0`.

- Tests connectivity within the `red` namespace and sets a default route using:

    - `ip netns exec red ping -c 2 192.168.1.10`

    - `ip netns exec red ip route add default via 192.168.1.1`

    - `ip netns exec red ip route`

- Repeats the above steps (with appropriate interface names) to create and configure veth interfaces for the `green` namespace.



**Step 4: Loopback Interface Setup**



- Enables the loopback interface (`lo`) on the host machine using `sudo ip link set lo up`.

- Enables the loopback interface in both network namespaces using:

    - `sudo ip netns exec red ip link set lo up`

    - `sudo ip netns exec green ip link set lo up`



**Step 5: Test Network Connectivity**



- **From the `red` namespace:**

    - Pings itself (`192.168.1.10`).

    - Pings the bridge interface (`192.168.1.1`).

    - Pings the green namespace interface (`192.168.1.11`).

    - Pings the host machine using its IP address (replace `` with the actual IP).

- **Repeat the above steps from the `green` namespace.**



- **Test network connectivity:**

    * From within each namespace ("red" and "green"), pings are performed to various destinations:

        * The namespace's own veth interface IP address.

        * The bridge interface IP address (192.168.1.1).

        * The other namespace's veth interface IP address.

        * The host machine's IP address (replace `` with the actual IP).



**Step 6: Enable internet access:**

    * Checks the current iptables rules using `iptables -t nat -L -n -v`.

    * Enables NAT for internet connectivity using `iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -j MASQUERADE`.

    * Optionally adds additional firewall rules if necessary using `iptables --append FORWARD` commands.

    * From within each namespace, pings are performed to a public DNS server (8.8.8.8) to verify internet access.



**Step 7: Start HTTP server (Optional):**

    * Starts a simple HTTP server in the "red" namespace using `ip netns exec red python3 -m http.server --bind 192.168.1.10 5000`.

    * **Note:** This step assumes the server needs to be accessed from outside the "red" namespace. Additional configuration on the host machine is required for port forwarding, which is not included in the script.



**Additional configuration is required to forward traffic from the host machine to the server:**



* `sudo iptables`: Similar to Step 6, this line is used for firewall rules.

* `-t nat`: Specifies the NAT table.

* `-A PREROUTING`: Specifies the PREROUTING chain, which modifies packets before routing decisions are made.

* ``: Replace this with the actual IP address of your host machine.

* `-p tcp -m tcp --dport 5000`: Selects incoming TCP packets directed to port 5000 on the host machine.

* `-j DNAT --to-destination 192.168.1.10:5000`: Redirects those packets to the server running in the `red` namespace on port 5000.



**Applying these rules allow accessing the server from outside the namespaces using the host machine's IP address and port 5000.**



**Step 8: Run Telnet (Optional):**



* This line is demonstrates testing the port forwarding using the `telnet` command.

* Replace `` with the IP address of your host machine and run the command to connect to port 5000 and interact with the server.



**Step 9: Cleanup (Optional):**



* This script creates resources that should be cleaned up after use. Consider adding commands to:

    * Delete network namespaces: `sudo ip netns del red` and `sudo ip netns del green`.

    * Delete veth interfaces: `sudo ip link del vethX` (replace X with 0 or 1).

    * Delete bridge interface: `sudo ip link del br0`.

    * Flush iptables rules: `sudo iptables -F` and `sudo iptables -t nat -F`.

 

**Remember:**

- This script requires root privileges to execute due to network configuration commands.

- Replace IP addresses and ports as needed for your specific use case.

- Ensure proper firewall configurations are in place for security when enabling internet access within namespaces.

- This script provides a basic example and might require adjustments for your specific network configuration.

- Modifying network configurations and using tools like iptables can impact your system's security and functionality. Proceed with caution and understand the potential risks.



In essence, the script meticulously constructs a network environment with isolated namespaces that can communicate internally and access the internet. It showcases fundamental concepts like bridging, NAT, and basic firewall rules to achieve this functionality.



Thanks for reading. Feel free to ask if you have any further questions! *Email: ``` [email protected] ```*