Biggest difference is right around 5:00 in where the routes get introduced.
Its better at making sure the message gets to the intended recipitant and the "rooms" feature is really nice for long term messaging. Its major downside is that it does not work on as many devices as meshtastic and some parts are not open source.
Yep already broke a couple of things and we had to roll back.
Its been SUUUPER stable on my systems. That and they are doing things slighly different than Ubuntu, which I really like.
Oh yeah central valley hits it all the time with 7 hops. Its awesome. Wish the hop system worked more like meshcore but it is what it is.
Most of these devicesbwould definitely gsr damaged or disabled by an emp. The voltage is very small on most of these devices.
I have a jank setup with USC c + heltek testing out the range. It was fun.
python
from flask import Flask, request, abort
from datetime import datetime, timedelta
import sqlite3
import logging
import os
app = Flask(__name__)
DB_FILE = "honeypot.db"
#LOG_FILE = "/var/log/honeypot.log"
LOG_FILE = "honeypot.log"
TRAP_THRESHOLD = 3 # clicks before flagging
FLAG_DURATION_HOURS = 24 # how long the flag lasts
# --- Setup logging for Fail2Ban integration ---
#os.makedirs(os.path.dirname(LOG_FILE), exist_ok=True)
logging.basicConfig(
filename=LOG_FILE,
level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(message)s",
)
# --- Database setup ---
def init_db():
with sqlite3.connect(DB_FILE) as conn:
c = conn.cursor()
c.execute("""
CREATE TABLE IF NOT EXISTS hits (
ip TEXT,
ts DATETIME
)
""")
c.execute("""
CREATE TABLE IF NOT EXISTS flagged (
ip TEXT PRIMARY KEY,
flagged_on DATETIME,
expires DATETIME
)
""")
conn.commit()
# --- Helper functions ---
def record_hit(ip):
now = datetime.utcnow()
with sqlite3.connect(DB_FILE) as conn:
c = conn.cursor()
c.execute("INSERT INTO hits (ip, ts) VALUES (?, ?)", (ip, now))
conn.commit()
def get_hit_count(ip):
with sqlite3.connect(DB_FILE) as conn:
c = conn.cursor()
c.execute("SELECT COUNT(*) FROM hits WHERE ip = ?", (ip,))
return c.fetchone()[0]
def flag_ip(ip):
now = datetime.utcnow()
expires = now + timedelta(hours=FLAG_DURATION_HOURS)
with sqlite3.connect(DB_FILE) as conn:
c = conn.cursor()
c.execute("REPLACE INTO flagged (ip, flagged_on, expires) VALUES (?, ?, ?)",
(ip, now, expires))
conn.commit()
logging.warning(f"HONEYPOT flagged {ip} for {FLAG_DURATION_HOURS}h") # Fail2Ban picks this up
def is_flagged(ip):
now = datetime.utcnow()
with sqlite3.connect(DB_FILE) as conn:
c = conn.cursor()
c.execute("SELECT expires FROM flagged WHERE ip = ?", (ip,))
row = c.fetchone()
if not row:
return False
expires = datetime.fromisoformat(row[0])
if now < expires:
return True
# Expired flag, remove it
c.execute("DELETE FROM flagged WHERE ip = ?", (ip,))
conn.commit()
return False
# --- Middleware ---
@app.before_request
def block_flagged():
ip = request.remote_addr
if is_flagged(ip):
abort(403, description="Access denied (you have been flagged).")
# --- Routes ---
@app.route('/')
def home():
return '''
<h1>Welcome</h1>
<p><a href="/do_not_click">Don’t click this unless you are a bot</a></p>
'''
@app.route('/robots.txt')
def robots_txt():
return "User-agent: *\nDisallow: /do_not_click\n", 200, {'Content-Type': 'text/plain'}
@app.route('/do_not_click')
def honeypot():
ip = request.remote_addr
if is_flagged(ip):
abort(403, description="Access denied (you’ve been flagged).")
record_hit(ip)
hit_count = get_hit_count(ip)
logging.info(f"HONEYPOT triggered by {ip} (count={hit_count})")
if hit_count >= TRAP_THRESHOLD:
flag_ip(ip)
return "You’ve been flagged for suspicious behavior.", 403
return f"Suspicious activity detected ({hit_count}/{TRAP_THRESHOLD})."
if __name__ == "__main__":
init_db()
app.run(debug=True)
Here I condensed this down to its parts. Hopefully this works well for you.
/etc/fail2ban/jail.d/honeypot.conf
[honeypot]
enabled = true
filter = honeypot
logpath = /var/log/honeypot.log
maxretry = 3
findtime = 86400 # Count hits within 24 hours
bantime = 86400 # Ban for 24 hours
backend = auto
action = iptables-multiport[name=honeypot, port="http,https"]
It works well with fail2ban + nginx just FYI. That and a small DB.
I created a honeypot that is only accessible if they click the "don't click this unless you are a bot". If they do after 3 times, poof the IP gets banned for a day. Its worked well.
Simple little flask app. Robots.text as well but only google seems to actually read that and respect it.
Peertube.wtf has been my savior in all this. But my tiny instance federates. I agree its a bit frustrating sometimes.
I think that many do not federate because they don't want to deal with federation traffic + video traffic. Just FYI, my tiny raspberry pi equivalent server can keep up with both Noe for over a year ;)
Or they don't want others to know they have illegal content. I'm not 100% sure why.
At work I see that screen at least 5 times a day.
Ive found getting two heltecs works out to tell if the system is working or not. Then putting one very high (like on a chimney) and using that one was as the one the city connects with.
Lora is VERY much a line of sight kind of system. If anything gets its its way, it will stop sending. Its very fickle.
You may want to reach out to your local ham group (if you have one) and see if anyone is interested in metastatic. We had one person that was super into meshtastic put a node on a foothill nearby and it covers the entire city. It gets awesome coverage. But thats the only reason I can talk with others and its spotty sometimes.