Welcome to My Personal Website on Filippos Christianos

A Tale of Proxies

Sun, 25 Jun 2023 00:00:00 +0000

Bypassing Proxies

Tired of stubborn corporate firewalls and region blocks? Below are straightforward configs, minimal chatter—just the steps and code. Use CNTLM if you’re stuck behind NTLM proxies. For something encrypted, checkout my V2Ray configs. ToC follows.

Insecure Setup
1.1 Installing Certificates (or How to Get Spied On)
1.2 CNTLM (for NTLM Proxy)
Encrypted Setup
2.1 V2Ray Installation
2.2 V2Ray through SOCKS
2.3 Forcing Traffic through Proxy
2.4 Phone Setup
Advanced Setup
3.1 Resources for HTTPS with V2Ray

Insecure Setup

The section below describes how to correctly setup your proxy in a linux machine. Last tested 17/12/2024 on Ubuntu 22.04.

NOTE apt, python, pip, conda, or insert-similar-program-here respect these env variables and certificates! If you are getting errors something went wrong or something is overwriting your settings. I have tested these on a clean setup multiple times.

Installing Certificates (or How to Get Spied On)

Your work proxy might require you to trust custom certificates issued by them. By installing a custom bundle, you’re telling your system to trust certificates your company chooses. This can let them spy on your traffic or impersonate websites (like Google or your bank) without you knowing.

Still, if you want to go ahead on your linux machine (use sudo if needed):

apt install ca-certificates
cp mycertificate.crt /usr/local/share/ca-certificates/
chmod 644 /usr/local/share/ca-certificates/mycertificate.crt
update-ca-certificates

Occasionally, programs have their own certificate paths (especially chrome, etc). But the above should cover 99% of the terminal use cases.

CNTLM (for NTLM Proxy)

Install:

sudo apt install cntlm

Run:

cntlm -u MYUSERNAME -d MYDOMAIN -H

to get something like:

PassLM          XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
PassNT          XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
PassNTLMv2      XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Configure /etc/cntlm.conf:

Username    MYUSERNAME
Domain      MYDOMAIN

# PASTE OUTPUT OF PREVIOUS COMMAND
PassLM          XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
PassNT          XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
PassNTLMv2      XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Proxy       corporate-proxy.example.com:8080
# Proxy       more-backup-proxies.example.com:8080
# Proxy       more-backup-proxies2.example.com:8080

Listen      0.0.0.0:3128
Auth    NTLM
Gateway   yes

Start CNTLM:

sudo systemctl enable cntlm
sudo systemctl start cntlm

Set System-wide Proxy:

Add to /etc/environment before restarting:

http_proxy=http://127.0.0.1:3128
https_proxy=http://127.0.0.1:3128
HTTP_PROXY=http://127.0.0.1:3128
HTTPS_PROXY=http://127.0.0.1:3128

NOTE if you export these variables, or add them to your .bashrc, or something similar, they might not be picked up during your sudo commands. Use sudo -E instead.

NOTE 2 You can skip CNTLM and just use http_proxy=http://username:password@proxy.example.com:8080 (and the other vars as seen above). But your password will be everywhere and it will be slower. Also you won’t be able to setup backup proxies.

Encrypted Setup

Disclaimer This setup should work decently well, but I cannot guarantee you complete privacy. DNS requests or other requests might leak and be revealed. V2Ray documentation is an excellent resource which might help you dive into even safer setups.

The setup below allows you to be sure your traffic cannot be easily seen by others. You need a server you control outside of the firewall. VPS from AWS, digitalocean, etc should work fine.

First install V2Ray on both client and server:

curl -O https://raw.githubusercontent.com/v2fly/fhs-install-v2ray/master/install-release.sh
chmod +x install-release.sh
sudo ./install-release.sh

If commands above don’t work, look at their latest install instructions.

V2Ray through socks

Often you will have access to a SOCKS proxy. These configs allow you to pass your traffic through that proxy.

Make a UUID. Keep it secret. Keep it safe:

apt install uuid-runtime
uuidgen

Make a `config-server.json` file in your server:

{
  "inbounds": [
    {
      "port": 8080,
      "protocol": "vmess",
      "settings": {
        "clients": [
          {
            "id": "YOUR_UUID_HERE",
            "alterId": 64
          }
        ]
      }
    },
  ],
  "outbounds": [
    {
      "protocol": "freedom",
      "settings": {}
    }
  ]
}

and start your v2ray service:

sudo cp config-server.json /usr/local/etc/v2ray/config.json
sudo systemctl enable v2ray
sudo systemctl start v2ray
sudo systemctl status v2ray

Client setup (inside the firewall)

Make a config-client.json file:

{
  "log": {
    "access": {
      "type": "File",
      "path": "/home/USERNAME/access.log"
    }
  },
  "inbounds": [
    {
      "protocol": "socks",
      "settings": {
        "udpEnabled": true,
        "address": "127.0.0.1"
      },
      "port": 1080,
      "listen": "0.0.0.0"
    }
  ],
  "outbounds": [
    {
      "protocol": "vmess",
      "tag": "overlay",
      "settings": {
        "address": "HOSTNAME_OR_IP_OF_SERVER",
        "port": 8080,
        "uuid": "YOUR_UUID_HERE"
      },
      "proxySettings":{
        "tag": "socks-outbound",
        "transportLayer": true
      }
    },
    {
      "protocol": "#v2ray.core.proxy.socks.ClientConfig",
      "tag": "socks-outbound",
      "settings": {
        "server": [
          {
            "address": "PROXY_IP_ADDRESS",
            "port": 1080,
            "user": [
              {
                "account": {
                  "@type": "v2ray.core.proxy.socks.Account",
                  "username": "YOUR_WORK_USERNAME",
                  "password": "YOUR_WORK_PASSWORD"
                }
              }
            ]
          }
        ],
        "version": "SOCKS5",
        "delay_auth_write": true
      }
    }
  ]
}

Now, you can start v2ray as a system service or just in your terminal (e.g., tmux)

NOTE At the time of writing, this second config was from v5 which was not default. You need to run v2ray run -c config-client.json -format jsonv5.

Then, your localhost is running a proxy you can tunnel through. For example, you can run:

ssh -o ProxyCommand="nc -x 127.0.0.1:1080 %h %p" username@sshserver.com

to ssh through the proxy.

Forcing traffic through proxy

Well, how do we pass traffic through this v2ray client? You could manually setup the proxy for your applications. Or you could try this lightly tested iptables setup.

Warning only do this if you are familiar with iptables, know how to reset your system, or even are OK with breaking stuff.

Install redsocks:

apt install redsocks

Config: /etc/redsocks.conf:

base {
    log_debug = on;
    log_info = on;
    log = "stderr";
    daemon = off;
    redirector = iptables;
}
redsocks {
    local_ip = 127.0.0.1;
    local_port = 6666;
    ip = 172.38.0.1;
    port = 1080;
    type = socks5;
}

Start redsocks redsocks -c /etc/redsocks.conf (or as a service)

Then the iptables:

iptables -t nat -A OUTPUT -p tcp --dport 22 -j REDIRECT --to-ports 6666
iptables -t nat -A OUTPUT -p tcp --dport 80 -j REDIRECT --to-ports 6666
iptables -t nat -A OUTPUT -p tcp --dport 443 -j REDIRECT --to-ports 6666
# add more dports. 
iptables -t nat -A OUTPUT -o lo -j ACCEPT
iptables -t nat -A OUTPUT -p tcp -d 127.0.0.1 --dport 1080 -j ACCEPT # 127.0.0.1 or the ip of the socks proxy

Phone Setup

I can strongly recommend the “Shadowrocket” client for iOS. Worked fine for me and it is pretty straightforward to put the same proxy settings.

Advanced setup:

This section is not finished. But consider using WebSocket + TLS with a reverse proxy like Caddy or Nginx. This can add HTTPS encryption to your V2Ray traffic. Check out the V2Ray guide on WSS for step-by-step instructions.

Pareto Actor-Critic for Equilibrium Selection in Multi-Agent Reinforcement Learning

Sun, 01 Jan 2023 00:00:00 +0000

Planning with Occluded Traffic Agents using Bi-Level Variational Occlusion Models

Sun, 01 Jan 2023 00:00:00 +0000

Benchmarking Multi-Agent Deep Reinforcement Learning Algorithms in Cooperative Tasks

Fri, 01 Jan 2021 00:00:00 +0000

Scaling Multi-Agent Reinforcement Learning with Selective Parameter Sharing

Fri, 01 Jan 2021 00:00:00 +0000

Shared Experience Actor-Critic for Multi-Agent Reinforcement Learning

Wed, 01 Jan 2020 00:00:00 +0000

Eat The Planet

Sun, 25 Jun 2017 00:00:00 +0000

Disclaimer: This post is a condensed version of a series of blog entries originally written in 2017 for an older version of this website. I’ve revived them here to preserve and share the journey of creating my procedural planet generator. The content has been slightly updated and cleaned up for clarity, but it remains a snapshot of my progress and ideas from that time.

For a quick visual glimpse of the project, check out these two trailers I made back in 2017:

Now, back to the blog post…

An Almost Hex Planet Procedural Generation

Over the past few weeks, I’ve been working on a procedural planet-generation algorithm that creates a globe composed mostly of hexagonal tiles. I’ve seen many map generators that inspired this project, but I wanted something that goes beyond 2D maps—something that creates an entire planet.

Summary:
The algorithm starts by generating a procedural mesh subdivided into hundreds of tiles. It uses tectonic plates to determine elevation and form continents. Heat, humidity, and winds are then simulated to create a climate system. Finally, biomes are assigned to each tile based on these factors.

Quick Tour:

Procedural mesh generation: Start with a regular icosahedron and subdivide it. Next, create a dual polyhedron to form a sphere made up of hexagons and a few pentagons.
Tectonic plates & elevation: Assign tiles to tectonic plates and give them movement vectors. The interaction between these plates creates elevation: mountains, trenches, and so on. Elevation is then smoothed and adjusted, resulting in oceans (elevation < 0) and land (elevation > 0).
Winds: Currently random. Large-scale wind vectors are assigned and then blurred for smoother patterns.
Temperature: Tiles receive heat based on their position relative to the equator. Heat spreads through wind and radiates back into space if it becomes too intense.
Humidity & precipitation: Ocean tiles add moisture that the wind spreads across the planet. Where relative humidity is high, rain forms.
Biomes: Each tile’s biome is determined by temperature, elevation, and precipitation ranges.

Procedural Mesh Generation

To start, I began with a simple icosahedron and subdivided it to form the base sphere. Managing subdivisions and neighbors was simplified by using a half-edge data structure (i.e., a doubly connected edge list). Once I had a detailed sphere, I generated a dual polyhedron, converting original vertices into faces—this gave me a planet made up mostly of hexagons and a few pentagons.

Subdividing an icosahedron to get to the number of faces we want. Left shows the icosahedron and the continues with up to 5 subdivisions

The subdivisions helped create a solid mesh structure, but I needed more than just triangles. By forming the dual polyhedron, I ended up with a tessellation of hexagons and pentagons. The pentagons are unavoidable, as a perfect hex-only sphere is impossible.

Taking the centers of each triangle gets you hexagons.

With the dual polyhedron complete, I got something like this:

This tiled sphere became the foundation upon which everything else was built. Because you cannot form a perfect sphere solely out of hexagons, pentagons are unavoidable.

Tectonic Plates

Next, I created tectonic plates by selecting several “root” tiles and assigning each tile to its closest root. This effectively formed plate boundaries.

Then, I assigned a movement vector (rotational) to each plate around the planet’s center:

Using these boundaries, I calculated pressure where plates meet. Depending on their interaction (colliding, pulling apart, or sliding), I formed features like mountain ranges or trenches. After smoothing elevations inward, areas below zero elevation became ocean, above zero became land.

Here is one example after processing elevation:

And another view, highlighting different continental features:

The tectonic-based elevation gave the world more realistic geological complexity.

Planet Climate

With elevation done, I tackled climate. Although I hope to eventually have a system where winds depend on temperature gradients, I started with random wind “roots” for simplicity. This allowed me to spread heat and humidity across the globe, testing my simulation loop.

The steps are:

Assign random wind “roots” and derive wind directions from them.
Spread heat from the equator and balance it through wind and radiation.
Compute humidity from oceans and let wind distribute it. High relative humidity leads to rain.

An example of a random wind pattern:

Heat distribution: tiles near the equator get more sunlight and thus more heat. Wind moves heat around, and if a tile gets too hot, it radiates heat into space. After enough simulation steps, I ended up with stable but varied temperature zones.

Another perspective shows the transitions between cooler and warmer regions:

Humidity comes from the oceans and is carried by the wind. When relative humidity gets too high, it rains, adding a hydrological cycle to the simulation. Over many iterations (like simulating a year’s worth of days), precipitation patterns emerge.

Pathfinding

For pathfinding, I implemented A*. I reorganized tile data so each tile knows its neighbors, making it easy to traverse the globe. A tile-based traversal cost can later be assigned based on biome or terrain.

This sets the stage for strategic gameplay, where units could navigate varied landscapes efficiently.

Biomes

After establishing temperature, precipitation, and elevation, it was time for biomes. Each tile got a biome depending on its climate and height. Initially, I gave each tile its own material, which looked interesting but caused performance issues due to the massive number of draw calls.

To fix performance, I later grouped tiles by biome type, drastically reducing draw calls and boosting FPS.

Improving Tile Materials

To enhance the planet’s look, I improved the atmosphere rendering and adjusted materials, for example by slightly lowering ocean tiles to give depth and a more 3D look.

By adjusting colors and ocean depth, the visuals became richer and more appealing:

Reworking Rendering

To optimize rendering further, I combined tiles of the same biome into single sections, reducing thousands of draw calls down to about twenty. This optimization let me comfortably handle large maps without frame rate issues.

Here you can see two much more expansive planets running smoothly:

Tile Resources & Meshes

Next, I introduced resources. Certain biomes have a chance to spawn resource-bearing features: trees for wood, stone deposits for minerals, etc. Using instanced static meshes for these resources kept draw calls low while adding richness and variety to the planet’s surface.

From forests to mineral deposits, these features help turn the planet from a static background into a living world.

Modular Meshes

Just different colors on tiles wasn’t enough. I wanted 3D meshes that blend smoothly between tiles, like connecting mountains across multiple tiles. To achieve this, I experimented with mesh relaxation (like Lloyd’s Algorithm) to regularize tile shapes and carefully aligned modular pieces.

I aligned each tile’s meshes by choosing a reference neighbor and rotating at 60-degree increments rather than relying solely on neighbor centroids. I also scaled meshes based on tile area to prevent overlap.

Now, with modular features and lowered ocean tiles creating cliffs, the planet has taken on a truly dynamic 3D appearance:

As the planet evolves—through changes in mesh generation, tectonics, climate simulation, and resource distribution—I’m getting closer to a fully playable environment. It’s been a challenging yet rewarding journey, and I look forward to refining the details and adding new layers of gameplay on top of this procedural world.

note from Filippos in 2024: unfortunately this project never made it to a complete game…