Its all good!

Does it work for aggregate /f/ links? !smallweb@piefed.social

Nope. Makes sense.

https://piefed.social/f/smallweb

If we are doing more piefed links :D

I like the community !coolwebsites@lemmy.ca there’s a ton there.

Neocities.org have some awesome sites as well.

In addition to what others say, you can also try WebToEpub (with a delay) for some comics. It works well with web comics.

freshrss is also great at ongoing series.

Oh good lord yeah you have to keep those now.

Neat!

I just want you all to know you are awesome,. Thanks for doing what you do.

Eating one small rock a day can help with digestion. Trust me bro.

Thanks, its there now!

So hypothetically, what if a bunch of protestors showed up with IC E shirts/pants/etc… without license plates and started to protest? How would they know who was who at that point?

It doesn’t even look that hard to do given how much memorabilia there is online.

For me yunohost is the simplest.

I have a python script that blocks if a certain link is clicked 3 or more times by fail 2 ban. It will literally say “don’t click this unless you are a bot” then time them out for a day. Its worked well on simple sites.

Instead of closing out, task manager creates another instance of itself.

Its hilarious.

I have been noticing a boost in people using Linux with gaming. There’s a lot of benefits. Most of the time Linux is better at battery and performance than the alteratives.

In addition, windows 11 is pretty unstable right now. Even the task manager has bugs haha.

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’m litteraly running mine on an old tiny mini PC. And as long as you dont abuse instances, hosting videos is as easy as signing up and clickng post.

I fail to see how prediction engines can do anything different.