Around 2018, I sat across from a coworker — let's call him D — who had a habit of stepping away for lunch with his screen wide open. I told him about it. Twice. He laughed both times and forgot the next day.

So I taught him with twelve lines of Python.

The setup

macOS ships with a command-line utility called say. You pipe text to it, and your laptop talks. Or, more accurately, your laptop talks to everyone in the office.

The plan was simple:

1. Sneak onto D's laptop while he was at lunch.
2. Run a tiny HTTP server in the background.
3. From my own desk, send GET requests with words I wanted his laptop to shout across the room.
4. Wait.

The whole thing

from subprocess import check_output
from aiohttp import web


async def handle(request):
    name = request.match_info.get("name", "")
    text = name
    check_output(f"/usr/bin/say '{text}'", shell=True)
    return web.Response(text=text)


app = web.Application()
app.add_routes([web.get("/{name}", handle)])

web.run_app(app, port=6063)

Twelve lines. No auth. No rate limit. No input validation. (We will come back to that.)

I ran it on his MacBook over lunch — python server.py & — and walked back to my desk. Then I curled it from across the room:

curl http://<his-laptop>:6063/hello

His MacBook, sitting unattended on his desk, said "hello" in a soft computerized voice.

The whole team turned around. He was still eating his sandwich somewhere on the other side of the building.

The escalation

Over the next forty minutes I tested limits:

curl http://.../I-forgot-to-lock-my-screen
curl http://.../please-lock-your-laptop
curl http://.../this-is-what-happens-when-you-do-not

say handles dashes-as-words pretty well. The laptop announced its own delinquency to the entire team. People stopped working to listen.

When D came back, he stared at his laptop for ten seconds, said one word I will not repeat here, and lunged for the menu bar. The server kept running because I had backgrounded it with &. Closing the terminal did not stop it. He had to kill the PID. He learned about lsof -i :6063 that afternoon.

The actual security lesson

The trick is funny. The underlying flaw is not.

That 12-line server is what an unlocked MacBook looks like to anyone with thirty seconds of physical access:

• They can run arbitrary shell commands. check_output(shell=True) on user-supplied input is a textbook command injection. In the prank version, I controlled both sides. In a real attack, the attacker controls both sides too — because they have your laptop.
• They do not need your password. The Python interpreter is already there. Homebrew is already there. curl is already there. Your SSH keys are already there. Your browser's saved passwords are decryptable from a logged-in session.
• The server survives a screen lock. Once it is running, locking your screen changes nothing. The process keeps listening. The attacker keeps having fun.
• You will not notice it. A Python process on port 6063 does not show up in your Dock. It does not push a notification. The only sign is the port being open — and who checks lsof -i after lunch?

What I exposed with say, somebody else could exploit with rm, with a curl to a remote webhook that exfiltrates ~/.ssh/, or with a launchd plist that survives reboot and phones home forever. The 12 lines of Python are not the attack. Walking away from the keyboard is the attack.

What you should actually do

• Set auto-lock. System Settings → Lock Screen → "Require password immediately after screen saver begins." Screen saver delay: one minute, not fifteen.
• Use Hot Corners. Bottom-left = lock screen. Muscle memory in a week.
• Enable FileVault. If someone walks off with your laptop, they get an encrypted brick. Without it, they get your home directory.
• Ctrl+Cmd+Q. Built-in macOS lock shortcut. Use it every single time you stand up. Even for the coffee machine. Especially for the coffee machine.
• Audit listening ports. Once in a while, lsof -i -P -n | grep LISTEN. You will be surprised what is running.

Why I am writing this in 2026

Because nothing has changed.

Eight years later I still see unlocked screens at every co-working space, every conference, every startup office I walk into. The defenses are better — Touch ID, Apple Watch unlock, FileVault is on by default — but none of them help if you walk away with the session active.

D locks his screen now. Every time. He has muscle memory for Ctrl+Cmd+Q that he did not have before that day. We do not work together anymore, but at conferences he closes his lid before he walks to the bar. Every. Time.

Sometimes the most effective security training is a laptop that announces your own negligence to a room of people you respect.

Twelve lines of Python. One coworker permanently reformed. Zero incidents since.