Welcome to the Katzenpost Blog. Here you will find two categories: News and Releases.
This is the multi-page printable view of this section. Click here to print.
- Katzenpost at 37C3
- Audio Engineering Considerations for a Modern Mixnet
- Website Relaunch and migration to Hugo
- Monthly News Update (May 2019)
- Monthly News Update (April 2019)
- Monthly News Update (Nov 2018)
- Monthly News Update (Feb 2018)
Katzenpost at 37C3
Dr. Eva Infeld and surveillance expert and developer Leif Ryge held a session at the Chaos Communication Congress about the current state of the project, some of the things we’re working on, and some of the pitfalls many anonymity systems fall into. Building an anonymity system fit for our dystopian age is a hard problem, but we’re doing it.
Audio Engineering Considerations for a Modern Mixnet
Modern Mixnets have a unique set of requirements when it comes to processing audio. The bandwidth is scarce, but we expect to use modern devices and have ample processing power. We aim to secure the communication against even sophisticated attacks that come from capturing the metadata, and prioritize tools that are free, open source and written with security in mind. In this unique setting, we present a set of recommendations for implementing codecs, DSPs, and sophisticated noise reduction tools, to deliver either impressive quality at low bandwidth or good quality at impressively low bandwidth.
Read Research PaperAudio Engineering Considerations for a Modern Mixnet
PDF / 295K
Website Relaunch and migration to Hugo
To match all the code development in Katzenpost in the last year, it was time for a website relaunch. Our site was a migration from Sphincs to Hugo and utilizes the well crafted and maintained Docsy theme.
To match all the code development in Katzenpost in the last year, it was time for a website relaunch. Our site was a migration from Sphinx, which is primarily for documentation, to Hugo which is wildly configurable for all sorts of websites. Given the technical nature and need for nice documentation interface, we used the well crafted and maintained Docsy theme.
Monthly News Update (May 2019)
The last few weeks have been very busy. I now have the basic working prototype implementation of a new Katzenpost messaging system. This new system has mutual location hiding properties for communication partners because recipients retreive their messages from a remote spool using a Sphinx SURB based protocol. SPHINX SPHINXSPEC
Naming things is tricky. I had to call it something:
This messaging system is inspired by agl’s pond, obviously. See agl’s pond.
I forked agl’s Double Ratchet from pond:
Also forked agl’s PANDA:
Communication partners use a remote spool service which is now, memspool but later it will be a replicating CRDT:
In order to exchange double ratchet keys and spool identities to form a bidirectional cryptographic channel, clients make use of the PANDA service. That is to say, PANDA (Phrase Automated Nym Discovery Authentication) is just another mixnet service like the memspool service mentioned above.
The user interface I wrote is a CLI terminal interface and it really kind of sucks. I’m feeling rather inspired by Special’s golang Ricochet. The UI and the backend are two separate processes and communicate by unix domain socket. Cool. Maybe I should do a similar construction that way someone else can later write a crazy C++ Gtk UI for this thing. Although I suspect this strategy doesn’t work well with Android. Unclear. At any rate, catshadow is crash fault tolerant, I hope. It is also internally way more simple than mailproxy and doesn’t use database transactions or anything like that. State is persisted to disk in an encrypted statefile… passphrase, argon2, nacl secretbox of course.
Anyway describing this whole thing is basically a paper worth of words which I shall attempt to articulate later. The overall strategy for Katzenpost should be for this client to merely serve as a demonstration. Whereas it would be far better to help another software project integrate with Katzenpost. Projects such as Briar and Wire come to mind. That having been said, I’d like to soon start a volunteer operated Katzenpost mix network so that we have some real infrastructure that allows us to start using catshadow to send each other encrypted messages. The amount of metadata we leak onto the network will depend on how many people use the system, number of mixes and of course how it is tuned. Since tuning is currently an unsolved problem, it’s all just a fun game anyway.
OK folks that’s all for now. I am not sure exactly what the next steps should be and I’m planning on deliberating while I discuss it with my colleagues and advisors. Either I will start a demo mixnet all on one machine that we can use to try out catshadow or I will attempt to instigate a volunteer operated mixnet. Things will get very cool once we have multiple applications that can use the mixnet. :)
Monthly News Update (April 2019)
The Panoramix grant project funded by the European Commission has officially ended but the Katzenpost free software project lives on. Masala and I continue to work on Katzenpost for grant money given to us by Samsung.
We recently learned a few things about mixnet design in a series of design meetings. The conclusions from our learnings is too much information and detail for this here post. However I will summarize some of our conclusions below. Our discussions usually revolved around mixnet CRDT applications, client reliability, message spool server design, client decoy traffic and, preventing attacks: statistical disclosure and active confirmation attacks.
Although far from complete, we added some design considerations to the following draft specification documents:
https://github.com/katzenpost/docs/blob/master/drafts/client.rst https://github.com/katzenpost/docs/blob/master/drafts/deaddrop.rst https://github.com/katzenpost/docs/blob/master/drafts/decoy_traffic.rst
The new Katzenpost mixnet design will work as follows:
Clients will NOT send each other messages directly to each other’s Provider. A client’s Provider and spool ID is kept secret while clients share remote spool identities and remote spool Providers with each other instead. This allows a threat model of mutual distrust between clients. This design can help prevent clients from leaking more metadata such as geographical location.
Messages are encrypted as follows: Firstly, the higher layer communications channel mechanism will use a modern cryptographic ratchet for forward secrecy and post compromise security properties. However, this ciphertext will be encapsulated by the Noise X oneway handshake. The nonce used by Noise X ensures that even if the client transmits the ratchet ciphertext, the Noise X ciphertext will always look different. This accomplishes our goal of not leaking retransmissions to spool Providers.
Spool servers are now kept outside of the Katzenpost mix server source repository. That is to say, we make use of a plugin system for our mix server so that Providers can add arbitrary services to the mix network. We intend to use an iterative approach to designing and implementing remote message spools. The basic messaging use case as described above can be improved in the future by implementing the message spools as CRDT’s. This will allow spools to be replicated and this eliminates single points of failure in the network. In contrast the original Loopix design, each client has a single message spool on their Provider. If this Provider has an outage then that client will be unable to access their message spool.
Clients and mixnet plugin services will together optionally make use of a publish subscribe protocol.
Clients will send normal and decoy traffic in accordance with the timing provided by the original Loopix tuning parameters: λP, λL, λD, λM.
Our mission is to enable other communications software projects to use mix networks to reduce their metadata leakage. To that end we have been working on mixnet client libraries that can be used by anyone. Although in the future we are planning to write a generic client daemon which you can interact with using a Unix domain socket. We hope that this will be an effective combination for enabling other projects to use a Katzenpost mix network.
Although we are still in an unstable and rapid development phase we made some recent improvements to the Katzenpost mix server:
Made it support running in networked environments with NAT devices.
Added a new plugin system which is hopefully less annoying to use than our existing gRPC based plugin system. The new plugin system uses CBOR over HTTP over Unix domain sockets. Katzenpost mix server plugins allow you to add arbitrary query/response services to your mix network. That is, you send a SURB and a query payload to a service and it can send one reponse using that SURB.
I’ve provided some “echo” service plugins as examples of how to write plugins for Katzenpost in our server_plugins repo:
HOWEVER, we have for over a year supported BTC and Zcash cryptocurrency submitions via the “currency” plugin, here:
Other areas of improvement include fixing some bugs in the Voting Authority server and changing our PKI document to include all the Loopix tuning parameters: λP, λL, λD, λM. Thanks to Masala and Moritz we made recent progress in implementing a continuous integration system that runs kimchi based integration tests.
Yes, Katzenpost is a general purpose transport for message oriented applications. All client applications using the mix network look the same. My “elite dark mixnet wallet” for Zcash will have a traffic profile of λP, λL, λD just like mixnet chat client. Just as soon as we stabilize our client library we will actively seek collaborations with application developers.
I’ve made a few screencasts to explain about mix networks and Katzenpost:
Katzenpost Introduction draft https://www.youtube.com/watch?v=vDJihqksd6w
A Brief Introduction to mix networks https://www.youtube.com/watch?v=1VMUb47QhfE
Mix Network Topology https://www.youtube.com/watch?v=bxk4H_X_OsM
Introduction to Statistical Disclosure Attacks and Defenses for Mix Networks https://www.youtube.com/watch?v=pHLbe1JKrAQ
I wrote some notes about making mixnet components in Rust that are binary compatible with existing Katzenpost components
The goal should be binary compatibility with the golang implementation of Katzenpost such that the existing golang components can interoperate with the new Rust components. Perhaps the biggest advantage of using Rust would be for writing mixnet clients as opposed to mix servers. A Rust mixnet client could easily present a FFI that could be used by user interfaces written in Java for Android and Swift for iOS.
I wrote several relavant rust crates:
Sphinx binary compatibility
The rust Sphinx uses the exact same cryptographic primitives as the golang implementation. Therefore it should be fairly easy to make them binary compatible. They should share test vectors.
Mix link layer binary compatibility
Currently this mix link layer crate uses
however if the Katzenpost link layer were to upgrade to
Kyber then the task of making this crate binary compatibility
would be greatly simplified.
Here’s an implementation of Kyber:
mix_link crate uses the snow Noise protocol library implementation:
However we SHOULD patch snow with Kyber PQ KEM hybrid forward secrecy. Here’s the snow github ticket for this task:
Current work in progress rust mix server:
Development progress has halted due to not being able to interoperate with the existing Katzenpost Directory Authority system.
Monthly News Update (Nov 2018)
This is our second edition of katzenpost news. There’s been a lot of progress since the last report I posted many months ago.
Firstly I’d like to mention our future development plans:
- mix and directory authority key agility
- generative testing for the voting Directory Authority system
- generative testing for all of the things where appropriate
- load and performance testing the mix server
- design and development of an application agnostic mixnet client message oriented protocol library
- design and development of one or more applications that use our new mixnet protocol client library
- potentially assist in integration with other software projects that want to use a mixnet transport protocol
Our recent accomplishments include:
- Eradication of our usage of JOSE/JWS and usage of the golang Jose library. We no longer use JOSE/JWS for signing mix descriptors and directory authority documents. Instead we use the “cert” library I wrote which gives us certificate format agility AND cryptographic algorithmic agility.
golang implementation: https://github.com/katzenpost/core/tree/master/crypto/cert
- Our mix server now has a language agnostic plugin system for adding mixnet services. We have a modular API that allows you to write new services in golang and staticly compile them into the binary, however this new plugin system allows you to add services using external programs as plugins. These external plugins use gRPC over Unix domain socket to talk to the mix server (Provider). Using these plugins we can make new mixnet protocols that are either one way or strict call and response protocols that use SURBs to send the replies.
Here’s the mix server documentation for this new feature: https://github.com/katzenpost/docs/blob/master/handbook/mix_server.rst#external-kaetzchen-plugin-configuration
Here’s the Kaetzchen specification document which explains a bit how this plugin system works although it doesn’t discuss implementation details: https://github.com/katzenpost/docs/blob/master/specs/kaetzchen.rst
This repository contains an “echo service” written in Rust, Golang and Python. Also it contains a plugin to perform crypto currency submissions, the idea being that mixnets can be used to transport a transaction blob to a Provider service which then submits the transaction to the database, the blockchain or whatever:
- we now have a set of incomplete Katzenpost Handbook documents:
Mailproxy Client Daemon https://github.com/katzenpost/docs/blob/master/handbook/mailproxy.rst
Katzenpost Mix Server Infrastructure https://github.com/katzenpost/docs/blob/master/handbook/mix_server.rst
Katzenpost Mix Network Public Key Infrastructure https://github.com/katzenpost/docs/blob/master/handbook/nonvoting_pki.rst
Torification of Katzenpost https://github.com/katzenpost/docs/blob/master/handbook/tor.rst
Katzenpost Voting Directory Authority https://github.com/katzenpost/docs/blob/master/handbook/voting_pki.rst
- we now have a HACKING guide for new Katzenpost developers:
- we now have a release process and some binary releases:
- We have released the voting Directory Authority (mixnet PKI) implementation since it is known to work properly as far as we were able to test thus far. This was more work and more difficult than we originally anticipated for both design and programming the implementation.
The design of this PKI was not fully supported by the Panoramix grant project because our academic collaborators were not under official obligation to work on this given that our three month period of design work officially ended. Thus, we were fortunate to receive their advice anyway.
Our specification document is rather still rather incomplete unfortunately:
Masala has done most of the development work and together we fixed some bugs in the implementation. The design of our PKI is a synthesis of design ideas that come from some brilliant minds and we’d like to thank Yawning Angel, Claudia Diaz, Ania Piotrowska and Nick Mathewson.
Our PKI uses a Shared Random Value to seed the randomization of our topology. We’d like to thank George Kandianakis for answering our questions about Tor’s hash based commit and reveal shared random value protocol.
What does randomizing our topology mean? Loopix and Katzenpost use the stratified topology which means that the client’s path selection must select a mix from each layer. This topology is enforced by our mix link layer protocol. The PKI generates and publishes a network consensus document\ and this specifies which mixes belong in which topology layer.
When one or more mix network layers change such that they only contain mixes operated by a single operators or contain only one mix that is what we mean by imbalanced. “Too few security domains” gives too much control over path selection to one or more mix operators.
The voting Directory Authority servers detect these mix outages by the absense of a newly uploaded mix descriptors for the voting round. Upon detecting this threshold event the shared random value is used to seed topology randomization. Claudia and Ania rightly pointed out that we MUST try to avoid rerandomization, it is detrimental to the anonymity properties of the mix network because it splits each mix’s anonymity set into two. That is, incoming messages for each mix are either from layer X or from layer Y, this topology distinction in message source means that those two categories of messages will not be mixed together and this is what is meant by splitting the anonymity set into two.
Masala and I fixed a plethora of race conditions in client and server code for both the Directory authority and mix servers.
I added a prototype mixnet client and server for supporting Adam Langely’s PANDA protocol:
PANDA was used in Pond, and Pond has sadly been abandoned by it’s creator. I would like there to be many useful mixnet clients, including a kind of “Pond replacement” that can perform key exchanges using PANDA.
During the last section of my mixnet talk at Bornhack 2018 I demonstrated the mixnet PANDA client and server working:
Sincerely, David Stainton
Monthly News Update (Feb 2018)
katzenpost monthly news
This is our first edition of katzenpost monthly news. I’ll be summarizing recent events from our first hackfest in Athens in early December 2017 to the present.
What we did in Athens:
- setup a test mix network
- remote collaboration with Yawning Angel to fix bugs and add features to the server side
- wrote some basic installation documentation
- Moritz created and deployed the katzenpost website with glossary and FAQ
- explored technical issues related to python and java language bindings to golang libraries
- discussed at length the possibilies for various kinds of mixnet clients
- Vincent wrote a prototype android instant messenger client
- met with the GrNet people and told them how to install a katzenpost mix network and answered their questions
- meskio and kaliy added an external user db interface for Provider authentication
- meskio wrote prototype python clients for testing purposes
- we had many group discussion about mix network design
- special guest visitor: George Kadianakis from Tor Project
Since that time we have been working on our PKI specification. Nick Mathewson sent us a six page review of our spec and Yawning sent a two page reply; both of these e-mails contain lots of design details and have been useful in our editing of the spec thus far:
Additionally since the Athens hackfest I, masala and Yawning have made changes so that interaction with the nonvoting PKI to NOT use HTTP but instead uses our Noise based wire protocol (which incidentally uses a Post Quantum hybrid key exchange). The PKI spec has been updated with these new changes. If you are curious about our wire protocol you can read about it here:
During the Brussels hackfest we:
worked on our Google Summer of Code project submission AND additional work on our website: https://katzenpost.mixnetworks.org/contribute.html https://github.com/katzenpost/mixnet_uprising/wiki/Project-Ideas
kwadronaut and I used a server on our test mixnet to test out Yawning’s new Provider postgres database interface for spool and user authentication databases; Postgres is optional but it is much high performance than boltdb which has no granular transactional locks.
Vincent improved upon the java and python bindings to client library, currently this client library is known as “mailproxy”
Vincent wrote an android k9mail katzenpost prototype for demonstrations
held lengthy discussions about autoresponder based keyserver for the purpose of distributing client encryption keys
we collectively wrote rough draft specifications for autoresponder services known as kaetzchen and a keyserver:
autoresponder protocol known as kaetzchen https://github.com/katzenpost/docs/blob/master/drafts/kaetzchen.txt
keyserver specification (rough draft) https://github.com/katzenpost/docs/blob/master/drafts/keyserver.txt
masala wrote a golang CLI client: https://github.com/katzenpost/demotools/tree/master/cliclient
masala worked on making bandwidth overhead estimations of the PKI protocol: https://github.com/mixmasala/docs/blob/mix_bandwidth_estimation/drafts/pki-bandwidth-estimate.txt https://github.com/mixmasala/docs/blob/mix_bandwidth_estimation/tuning/bw.py
Note: Bandwidth and scaling estimations is something that Nick Mathewson has requested in his review of our PKI specification document.
had conversations with several guests at our hackfest including:
- Claudia Diaz
- video conference with Yawning Angel
- the developers of sequoia-pgp https://sequoia-pgp.org/
- Harry Halpin
- an associate of Harry who is involved in the crypto currency financial industry
Tg created NixOS packages for the katzenpost components https://github.com/katzenpost/nixpkgs
and NixOS katzenpost configuration for automatic deployment to linux containers: https://github.com/katzenpost/nixops
meskio and kaliy: worked on a number of things, including
LEAP based account registration for katzenpost Providers
setup Prometheus to monitor our test mixnet
performed stress tests to determine how network load would be affected by various client concurrency levels and bandwidth usage: https://github.com/katzenpost/katzsim
Since the Brussels hackfest, Masala and I visited Claudia Diaz and Tariq Elahi at KU Leuven to discuss mix network designs. In particular we asked various questions about the AQMs used in the Katzenpost server side and later got clarification from Yawning. We also discussed mix network tuning and learned that the preferred method of tuning mixnets is to run lots of simulations and use different kinds of analysis to determine an appropriate set of tuning parameters.
During this discussion Tariq mentioned that their simulations are likely not using the exact same AQMs as Katzenpost server side. We decided that these simulations could be executed using our “mixnet emulator” which is called kimchi. It runs an entire katzenpost mix network and nonvoting authority in a single golang process.
We patiently await for a response to our query: “What features should the mixnet emulator/simulator have?”
Yawning recently implemented the keyserver:
and the mailproxy client side for interacting with the keyserver:
Since then Yawning’s focus has been to improve server side stability and performance. You can see his task list here: https://github.com/orgs/katzenpost/projects/2
Masala and I have been working on writing a voting directory authority server.
Currently our test mixnet works because Yawning has not only written most of the code but he also wrote a nonvoting Directory Authority PKI. However, the nonvoting PKI is not suitable for production use where a decentralized design should be used to achieve the desired security properties.
Beyond our officially sanctioned work on this project, and in my free time, I’ve been exploring other use-cases for mixnets. I’ve been thinking about “strong location hiding properties”. What I came up with is a kind of kaetzchen dead drop service where you can retreive messages from a remote Provider. The client would never directly interact with the remote Provider but instead only uses the mixnet to retrieve messages.