Laan Tungir
lt@laantungir.net
npub1rmz9...xv06
Artist, Scientist, Cypherpunk, Critical Rationalist, Nym.
[domain] https://laantungir.net
[ipv4] https://15.235.3.231
[ipv6] https://[2607:5300:203:bb5c:4a46:c3d3:1dc3:fbe8]
[tor] http://kn2jam4kyz6s5wacyozo3do3d2zsvh4to45uh7xliulwdust6zjuvnad.onion
[fips] http://npub1crpldvy49ef8z34wlacwujnfudy4nd7k96aqdx5wgn6ckztz7z8q9t59ud.fips
[n-site] https://npub1rmz9gu6de0m0u4ysrn39crrud099ahvfgs6pvasl4hpjr5ud7yus54xv06.nsite.run
GM fellow nyms.
I presume everyone is having a GM.
We are not on social media enough.
Social Media is one of the greatest inventions of mankind. Ever. Full stop.
But it is constantly maligned.
Even on NOSTR social media is seen in a somewhat negative light. Moral virtue is expressed as "go out and touch grass".
A thought experiment - give 100 people this social media challenge:
"Every day for a year, post on social media about your problems, or your society's problems, along with what you believe are the solutions. Post on politics, science, religion, morality, whatever is important to you. Consider and respond to any serious replies. Be earnest."
Now at the end of the year, compare that group of 100 people, to a control group.
Almost certainly the 100 who posted on social media would have advanced their thinking far more from where it was. They would have had to make explicit in their mind their beliefs, and then put them up for critique. Their knowledge would have grown. They would look back at their early beliefs as relatively uninformed.
If I was asked to spend time with either group after the year, I would choose the 100 people who posted on social media.
Is social media perfect? No. That is why we #NOSTR.
Would the people posting have been happy the whole time doing it? Almost certainly not, but I'm not always happy at the gym either.
Karl Popper taught us how we create knowledge:
1. Start with a problem
2. Conjecture solutions.
3. Criticize those solutions.
4. Go with the best solution until we can conjecture a better one.
The social media challenge I proposed, is virtually this exact method.
I have been thinking that the traditional education system is doomed, but was not sure what would replace it. Now I am thinking that it is simply social media.
I love NOSTR.
Even on NOSTR social media is seen in a somewhat negative light. Moral virtue is expressed as "go out and touch grass".
A thought experiment - give 100 people this social media challenge:
"Every day for a year, post on social media about your problems, or your society's problems, along with what you believe are the solutions. Post on politics, science, religion, morality, whatever is important to you. Consider and respond to any serious replies. Be earnest."
Now at the end of the year, compare that group of 100 people, to a control group.
Almost certainly the 100 who posted on social media would have advanced their thinking far more from where it was. They would have had to make explicit in their mind their beliefs, and then put them up for critique. Their knowledge would have grown. They would look back at their early beliefs as relatively uninformed.
If I was asked to spend time with either group after the year, I would choose the 100 people who posted on social media.
Is social media perfect? No. That is why we #NOSTR.
Would the people posting have been happy the whole time doing it? Almost certainly not, but I'm not always happy at the gym either.
Karl Popper taught us how we create knowledge:
1. Start with a problem
2. Conjecture solutions.
3. Criticize those solutions.
4. Go with the best solution until we can conjecture a better one.
The social media challenge I proposed, is virtually this exact method.
I have been thinking that the traditional education system is doomed, but was not sure what would replace it. Now I am thinking that it is simply social media.
I love NOSTR.
If a doomer tells you their guess for P(doom)*, ask them what their guess for P(saved) is.
P(saved) is the probability we survive because we have created AI fast enough.
It is interesting to note that almost all examples we have of societies going extinct are because they didn't create enough knowledge fast enough, not that they had too much.
Native American tribes would have been much better off if they had more knowledge about gunpowder and especially smallpox. It was this lack of knowledge that doomed them.
The Greenland Norse needed to know about insulating clothing and how to hunt marine mammals.
The Anasazi about soil conservation.
The Easter Islanders about sustainable forestry.
Given that almost all examples of situations we want to avoid are situations where we don't have enough knowledge, I think this is a strong indication that we need to build AGIs and the new knowledge that comes with them as quickly as possible.
The danger lies in not having the knowledge needed to save ourselves.
GM
*P(Doom) is the probability that AIs kill us all any given year.
P(saved) is the probability we survive because we have created AI fast enough.
It is interesting to note that almost all examples we have of societies going extinct are because they didn't create enough knowledge fast enough, not that they had too much.
Native American tribes would have been much better off if they had more knowledge about gunpowder and especially smallpox. It was this lack of knowledge that doomed them.
The Greenland Norse needed to know about insulating clothing and how to hunt marine mammals.
The Anasazi about soil conservation.
The Easter Islanders about sustainable forestry.
Given that almost all examples of situations we want to avoid are situations where we don't have enough knowledge, I think this is a strong indication that we need to build AGIs and the new knowledge that comes with them as quickly as possible.
The danger lies in not having the knowledge needed to save ourselves.
GM
*P(Doom) is the probability that AIs kill us all any given year.
GM
GM
Johannes Gutenberg >> Martin Luther
# NOSTR over single packet UDP
## TLDR
Send a Nostr event as one-way UDP packet instead of using TCP. This one-way send is very censorship resistant compared to the alternatives. I currently have it implemented on my relay and you can test it now on the command line using nc and @fiatjaf's nak.
'''
nak event -k 1 -c "I don't shake hands, because Ewwwwww!" | nc -u -w1 laantungir.net 443
'''
## The problem:
As far as I know, every circumvention tool [VPN, Tor, Shadowsocks, obfs4] has a handshake. You start off messaging the server, and the server replies before you can send your information. National firewalls detect those handshakes, fingerprint them, probe the handshake, then block the IP or take other action. The handshake is a vulnerability. Every tool plays cat-and-mouse obfuscating it.
For example Tor bridges are vulnerable to active probing. The adversary connects to a suspected bridge and sends data. If the server responds with a valid obfs4 handshake, the adversary knows it is a bridge. This is how many Tor bridges get blocked.
## The idea:
UDP Nostr eliminates the handshake entirely. The Nostr event is already signed before it touches the network. The signature replaces the handshake. There is no SYN, no TLS ClientHello, no SNI, no key exchange, no recognizable structure — just a blob of bytes in one UDP packet under 1472 bytes.
The adversary can send a probe, but the relay doesn't respond at all. No handshake to detect. No TCP RST to inject (UDP has no RST). No DNS to poison.
## Live example — full zero-config round-trip
My relay has fully implemented UDP Nostr.
**command line**
```bash
# Console 1 - Set up a live watch for the nak default events on the relay
nak req -a 79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 --stream laantungir.net/relay
# Console 2 - Send via UDP (no --sec needed, nak uses the default key)
nak event -k 1 -c "Hello!" | nc -u -w1 laantungir.net 443
```
**Python:**
```python
import socket, sys
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.sendto(sys.stdin.buffer.read(), (sys.argv[1], int(sys.argv[2])))
```
```bash
nak event -k 1 -c "Hello!" | python3 send.py laantungir.net 443
```
**JavaScript (Node.js):**
```javascript
const dgram = require("dgram"), s = dgram.createSocket("udp4");
process.stdin.on("data", b => s.send(b, +process.argv[3], process.argv[2]));
```
```bash
nak event -k 1 -c "Hello!" | node send.js laantungir.net 443
```
## An example of largest kind:1 that fits in one packet
With the default nak key, empty tags, and a 10-digit timestamp, the Nostr JSON overhead (structural syntax + hex-expanded id/pubkey/sig) is ~340 bytes, leaving **~1132 characters of content** in the 1472-byte UDP budget. Below is an illustrative event at full capacity — its single-line JSON form is exactly 1472 bytes on the wire, one Ethernet frame, unfragmented. (The `id` and `sig` shown are placeholders for readability; a real event carries a SHA-256 `id` and valid Schnorr `sig`.)
```json
{"id":"426462725f7061636b65745f626f756e646172795f746573745f303030303030",
"pubkey":"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
"created_at":1772019044,
"kind":1,
"tags":[],
"content":"The cypherpunk problem: how do two computers communicate freely when the network between them is controlled by an adversary? The standard approaches are anonymity (hide which computer is talking) and decentralization (make copies everywhere so you can't stop them all). But there is a third approach that is less explored: protocol substrate hardening. Design the communication protocol so that interference requires violating physics or OS-level guarantees. The simplest example: fit your message in a single UDP datagram under 1472 bytes. At this size, your message is exactly one Ethernet frame. The adversary cannot block it without blocking all UDP traffic on that port. They cannot fragment it. They cannot reassemble it. They cannot probe for a handshake because there is no handshake. The Nostr event is self-validating: it carries its own signature. The signature replaces the handshake. This is the key insight. Every other protocol announces itself with a handshake. TCP has SYN. TLS has ClientHello. QUIC has its Initial packet. WireGuard has its handshake initiation. All of these create a pattern that can be fingerprinted and blocked. A Nostr event over UDP has no pattern. It is just bytes on the wire. The receiver validates the signature using only the pubkey in the event. No shared secrets. No session setup. No state. This is the no-handshake property. It is the fundamental advantage of Nostr over every other protocol for censorship resistance. Combine this with the MTU boundary and you have a protocol that cannot be blocked without blocking all UDP traffic. The adversary faces a dilemma: block UDP entirely and break the internet, or let your messages through. This is the asymmetry we exploit.",
"sig":"4b57c22b1797b109530ffe5d04cabac468b1a5942873a5141334ecbc77694fc968a1b941979ba13602fceb1dad8014ab6469c6ae9cef0b5668cc23ad1449e103"}
```
## Future work
I'm currently working on an encryption scheme specifically for this protocol.
http://kn2jam4kyz6s5wacyozo3do3d2zsvh4to45uh7xliulwdust6zjuvnad.onion/git/laantungir/udp_nostr
http://npub1crpldvy49ef8z34wlacwujnfudy4nd7k96aqdx5wgn6ckztz7z8q9t59ud.fips/git/laantungir/udp_nostr
For example Tor bridges are vulnerable to active probing. The adversary connects to a suspected bridge and sends data. If the server responds with a valid obfs4 handshake, the adversary knows it is a bridge. This is how many Tor bridges get blocked.
## The idea:
UDP Nostr eliminates the handshake entirely. The Nostr event is already signed before it touches the network. The signature replaces the handshake. There is no SYN, no TLS ClientHello, no SNI, no key exchange, no recognizable structure — just a blob of bytes in one UDP packet under 1472 bytes.
The adversary can send a probe, but the relay doesn't respond at all. No handshake to detect. No TCP RST to inject (UDP has no RST). No DNS to poison.
## Live example — full zero-config round-trip
My relay has fully implemented UDP Nostr.
**command line**
```bash
# Console 1 - Set up a live watch for the nak default events on the relay
nak req -a 79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 --stream laantungir.net/relay
# Console 2 - Send via UDP (no --sec needed, nak uses the default key)
nak event -k 1 -c "Hello!" | nc -u -w1 laantungir.net 443
```
**Python:**
```python
import socket, sys
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.sendto(sys.stdin.buffer.read(), (sys.argv[1], int(sys.argv[2])))
```
```bash
nak event -k 1 -c "Hello!" | python3 send.py laantungir.net 443
```
**JavaScript (Node.js):**
```javascript
const dgram = require("dgram"), s = dgram.createSocket("udp4");
process.stdin.on("data", b => s.send(b, +process.argv[3], process.argv[2]));
```
```bash
nak event -k 1 -c "Hello!" | node send.js laantungir.net 443
```
## An example of largest kind:1 that fits in one packet
With the default nak key, empty tags, and a 10-digit timestamp, the Nostr JSON overhead (structural syntax + hex-expanded id/pubkey/sig) is ~340 bytes, leaving **~1132 characters of content** in the 1472-byte UDP budget. Below is an illustrative event at full capacity — its single-line JSON form is exactly 1472 bytes on the wire, one Ethernet frame, unfragmented. (The `id` and `sig` shown are placeholders for readability; a real event carries a SHA-256 `id` and valid Schnorr `sig`.)
```json
{"id":"426462725f7061636b65745f626f756e646172795f746573745f303030303030",
"pubkey":"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
"created_at":1772019044,
"kind":1,
"tags":[],
"content":"The cypherpunk problem: how do two computers communicate freely when the network between them is controlled by an adversary? The standard approaches are anonymity (hide which computer is talking) and decentralization (make copies everywhere so you can't stop them all). But there is a third approach that is less explored: protocol substrate hardening. Design the communication protocol so that interference requires violating physics or OS-level guarantees. The simplest example: fit your message in a single UDP datagram under 1472 bytes. At this size, your message is exactly one Ethernet frame. The adversary cannot block it without blocking all UDP traffic on that port. They cannot fragment it. They cannot reassemble it. They cannot probe for a handshake because there is no handshake. The Nostr event is self-validating: it carries its own signature. The signature replaces the handshake. This is the key insight. Every other protocol announces itself with a handshake. TCP has SYN. TLS has ClientHello. QUIC has its Initial packet. WireGuard has its handshake initiation. All of these create a pattern that can be fingerprinted and blocked. A Nostr event over UDP has no pattern. It is just bytes on the wire. The receiver validates the signature using only the pubkey in the event. No shared secrets. No session setup. No state. This is the no-handshake property. It is the fundamental advantage of Nostr over every other protocol for censorship resistance. Combine this with the MTU boundary and you have a protocol that cannot be blocked without blocking all UDP traffic. The adversary faces a dilemma: block UDP entirely and break the internet, or let your messages through. This is the asymmetry we exploit.",
"sig":"4b57c22b1797b109530ffe5d04cabac468b1a5942873a5141334ecbc77694fc968a1b941979ba13602fceb1dad8014ab6469c6ae9cef0b5668cc23ad1449e103"}
```
## Future work
I'm currently working on an encryption scheme specifically for this protocol.
Gitea on NOSTR
udp_nostr
Send Nostr events as single UDP datagrams — no handshake, no connection, no state.
Gitea on NOSTR
udp_nostr
Send Nostr events as single UDP datagrams — no handshake, no connection, no state.
Gitea on NOSTR
udp_nostr
Send Nostr events as single UDP datagrams — no handshake, no connection, no state.
