TrustMix: How to Mix Messages in a Mobile Ad-hoc Network Yu Shen, Aiswarya Walter, Stefanie Roos
arXiv:2606.20251v1 [cs.CR] 18 Jun 2026
RPTU University Kaiserslautern-Landau Kaiserslautern, Germany {yu.shen, stefanie.roos}@cs.rptu.de, [email protected]
Abstract—Mix networks are a highly effective way to achieve anonymity, defending against a wide range of traffic-analysis attacks. However, mix networks are usually designed for infrastructure networks and cannot be directly applied in the context of mobile ad hoc networks (MANETs). The few existing solutions for MANETs require advance knowledge of the topology or a trusted central party. In this paper, we present TrustMix, a mix protocol for MANETs that operates without any central trusted party. In TrustMix, parties join groups and then messages are forwarded via multiple groups to provide anonymity. With TrustMix, users only need to find a party nearby that they consider trusted. They then forward the message to this party’s group, and the party shuffles messages before forwarding to other groups, meaning that the original message and the forwarded message cannot be linked. Furthermore, even if the chosen party is adversarial, they can only break the anonymity if all parties in their group are adversarial as all of them contribute to the shuffling. In addition to anonymity, TrustMix also enforces rate limits on the number of messages through the use of linkable ring signatures, which allows detecting that parties send more messages that allowed without revealing identities. We prove the security of our protocol in the random oracle model. We evaluate its anonymity using an existing mix-network simulator and show that TrustMix significantly improves message anonymity. Finally, we present a proof-of-concept Android implementation and show that TrustMix achieves acceptable throughput with 5 mobile devices. Index Terms—Anonymous communication, Mobile Ad-hoc network, Trust
I. I NTRODUCTION Instant messaging applications such as WhatsApp and Signal are widely used to communicate, read the news, or even do business [1]. Most applications require internet access, which may in certain scenarios not be available, e.g., because of an internet shutdown. For example, authorities may block the Internet in a region during a protest, as has occurred in Russia and Iran [9]. Then, most communication tools are not available, and it becomes extremely difficult to communicate with friends or relatives and to access or disseminate information. There already exist tools such as Firechat and Bridgefy that do not require internet access [2]. Instead, they use lowrange radio techniques such as Bluetooth and WIFI Direct to transfer messages. When a sender sends a message, they simply broadcast the message to all of their neighbors, and other users will broadcast the message further until all users receive this message. The broadcast of messages ensures that
the receiver always gets the message if there is at least one path between the sender and the receiver. However, a simple broadcast opens the door for denial-of-service (DoS) attacks, in particular allowing adversaries to flood the network with dummy messages, meaning that a limited number of malicious parties can easily paralyze the network. Moby and Rangzen mitigate DoS attacks by introducing the use of a trust mechanism [18], [20]. With the trust mechanism, only messages from trusted users are forwarded, with the expectation that messages sent by malicious parties end up being dropped before they reach a considerable fraction of the network due to the low trust placed in the parties. However, none of the protocols, not even Moby and Rangzen, provide anonymity in the face of a global passive adversary, as they simply encrypt the message and assume that no one except the receiver can obtain the plaintext message. In such systems, the global passive adversary can easily trace every encrypted message back to the original sender through traffic analysis, enabling the adversary to derive relationships between users, which can reveal sensitive information such as political affiliation. Since the introduction of mix networks by Chaum [5], they have been widely used in distributed systems to increase anonymity [12]. The core idea of a mix network is to have a set of mix nodes collect, transform, and shuffle messages to break the link between senders and receivers. The original design does not suit the nature of MANETs because it assumes fixed topologies and routing strategies. Existing mixinspired MANETs communication protocols such as ARM and ANODR [16], [22] attempt to handle network dynamics through route discovery and by forwarding messages along pre-established paths. In practice, however, intermediate nodes may go offline at any time and network topology can change rapidly, making such route-based designs unsuitable for highly dynamic MANETs. Moreover, the request messages and reply messages to discover routes make them vulnerable to denial of service attacks, as adversaries can flood the whole network with route discovery messages. Motivated by these limitations, we propose TrustMix, a new anonymous communication protocol that combines trustbased forwarding with decentralized mix networks to provide anonymity and DoS resistance under dynamic network conditions. We introduce a trust mechanism into TrustMix
to mitigate the impact of DoS attacks similar to the Moby network [20]. In TrustMix, messages are only exchanged among trusted parties. Hence, messages from malicious parties are dropped with high probability. To ensure the anonymity of the messages, we integrate a mix network protocol in TrustMix. To overcome the limitations of a dynamic network topology, we use a similar idea as Atom [17] to build a free route mix network. In Atom, a mix node consists of a group of parties that collaboratively re-encrypt and shuffle messages, meaning messages are forwarded to arbitrary next hops without revealing plaintexts. Similarly, in TrustMix, users self-organize into groups, and each group collectively acts as a mix node. Senders only select the first group, while subsequent routing decisions are made by intermediary groups. Therefore, users do not need to determine every mix node and messages are resilient to faulty mix nodes. To select groups, each party has a set of other parties they consider trusted and forward to a group with at least one party they trust. This trusted party then assumes a key role in the re-encryption of the message and they choose the next group to forward to, though even if the trust is misplaced, TrustMix provides anonymity as long as a sufficient number of group members are honest. We prove the security of TrustMix and evaluate its anonymity using a simulator, finding that the anonymity provided can be up to 8 to 10 bits. In addition to this, we implement a prototype of TrustMix on Android devices and benchmark its delay and throughput, showing that the latency increases approximately linearly in the number of group members. In short, TrustMix has the following contributions: • We design an anonymous trust discovery protocol that enables DoS mitigation without revealing the relationship of users. • We design the first trust-based re-encryption mix protocol for MANETs. • We evaluate the anonymity of TrustMix using a simulator. • We implement an Android WIFI Aware based prototype and evaluate the performance of TrustMix. II. R ELATED WORKS In this section, we introduce the works most closely related to TrustMix, including three areas: mix networks, anonymous communication protocols for mobile ad hoc networks, and trust mechanisms for decentralized systems.
continuous cover traffic but arranges mixes in layers so that each route contains one mix from each layer. All systems above require that the topology of the mix network be known to users when sending a message, and changes of the topology or availability of mix nodes may lead to protocol failure. In an MANET with dynamic topology, it is difficult for users to obtain the network topology on time. In contrast to sender-routed mix networks, Atom introduces the idea of a re-encryption-based mix network where intermediaries are able to re-encrypt a message with the public key of an arbitrary party and forward the message to this party [17]. Atom also organizes multiple nodes into a single mix group, allowing correct mixing of messages even when some nodes are unavailable. These properties make Atom suitable for MANETs due to its fault tolerance and flexible message routing method. However, Atom relies on reliable group assignment by a trusted party, an assumption that is difficult to realize in a decentralized MANET. B. Anonymous MANETs Due to the flexibility of mobile ad hoc networks, MANETbased applications such as Bridgefy have become common tools for communication during Internet shutdowns or blackouts [2]. To provide anonymity in such environments, several protocols have been proposed with different design goals. Rangzen is designed to broadcast a message anonymously in a MANET with potential adversaries that attempt to paralyze the network [18]. Rangzen uses a prioritization mechanism, in which messages from parties that share more mutual contacts with the current node have a higher priority. In such a way, messages from adversaries likely have a lower priority and may be dropped by intermediary parties under congestion. Similarly to Rangzen, Moby performs anonymous peer to peer communication in a MANET using a trust based prioritization mechanism [20]. Amigo further expands the use cases of MANETs by supporting secure group communication [14], supporting dynamic group creation, membership management, and anonymous messaging over MANETs. However, all of the anonymous communication protocols discussed above assume that the adversary cannot monitor the traffic of the entire network. Consequently, these protocols remain vulnerable to traffic analysis attacks, motivating the need for systems that provide stronger message anonymity.
A. Mix networks
C. Trust mechanisms for decentralized systems
Since the proposal of mix networks by Chaum [5], they have become a fundamental architecture for anonymous communication. In Chaum’s original design, the sender selects a sequence of mix nodes and applies layered encryption. Afterwards, each mix node collects incoming messages, decrypts them, and forwards them to the next mix node or the receiver, thereby breaking the linkability between senders and receivers of messages. Vuvuzela [23] employs a single chain of mix nodes combined with heavy cover traffic to provide strong privacy for message metadata. Similarly, Loopix [19] uses
Trust mechanisms are widely studied in decentralized systems to mitigate active attacks without centralized authorities. As mentioned in the previous section, both Moby and Rangzen use a trust mechanism where each party assigns a trust score to each message and prioritizes messages according to trust values. In Rangzen, message receivers calculate the trust value of a message based on the number of social contacts shared between them and the message sender. In contrast, the trust value of a message in Moby is updated at every forwarding step, where the new trust value is calculated based on the
previous trust value of the message and the trust value of the forwarder. Anix introduces a method to remotely establish trust relationships in MANETs over several rounds of communication [15]. Concretely, each user generates a new pseudonym every time they send a message. When a user receives a trustworthy message together with the public key corresponding to the sender’s pseudonym, the receiver can choose to initiate the trust establishment process by broadcasting their identifier encrypted by the public key, allowing the original sender to track subsequent messages. If choosing to establish mutual rust, the original sender broadcasts the encrypted form of their own identifier in return, leading to the establishment of twoway trust. In TrustMix, we adopt a trust establishment process similar to Anix to find trusted parties near each other without revealing the identifier of each participant. III. T HREAT MODEL We consider a mobile ad hoc network during internet shutdowns during which devices communicate without fixed infrastructure and dynamically organize into groups that collaboratively perform message mixing and forwarding. The network topology is highly dynamic and communication links are unreliable. We focus on three adversarial goals: denialof-service, modifying the content of messages, and linking senders and receivers to break anonymity. For denial-of-service attacks, attacks that completely prevent communication, physical capture of all devices, and global radio jamming are out of scope. Rather, we focus on local, internal attacks where malicious parties flood the network or drop messages. For the anonymity and message integrity, we adopt a threat model similar to that of Moby [20] but with a stronger global passive adversary. We assume that a probabilistic polynomialtime (PPT) adversary can corrupt a subset of nodes and fully control their behavior, but cannot break standard cryptographic primitives. With corrupted nodes, the adversary can read the internal state of the corrupted nodes, modify their behavior, inject, drop, delay, or flood messages, and collude across all compromised devices. In addition, the adversary can observe the traffic patterns of all communication links. Although monitoring of all channels may not be feasible, we provide such information to adversaries to provide strong anonymity guarantees for TrustMix. IV. P ROTOCOL The goal of TrustMix is to anonymously mix messages in decentralized mobile ad hoc networks. Unlike Atom, which assigns fixed groups beforehand, we allow users to form a group, leave a group, and join a group during protocol execution, meaning that TrustMix can adapt to topology changes. Moreover, we consider the occurrence of failures of users by allowing groups to process incoming messages in the presence of several non-responsive members. For k non-responsive users, Atom requires at least k + 1 honest users to ensure the message can be processed correctly. In our protocol, we only
require one honest party in the group, regardless of the number of non-responsive users. However, the honest party needs to be chosen and trusted by the previous message forwarders in our protocol. We ensure that if the selected trusted user is honest, incoming messages of all group members are shuffled securely, and no one can link shuffled messages to original messages with a non-negligible probability. To prevent forging and modification of messages by group members as well as DoS attacks, a misbehavior detection mechanism is integrated to find misbehaving parties in our protocol. Our protocol consists of a setup phase and a mixing phase. The setup can be executed by any set of users to create a set of group public keys for a new group, such that each group member is associated with a group public key. Later, if a party wants to forward a message to this group and a member of this group is trusted by the forwarder, the forwarder can choose the member as the next trusted forwarder and encrypt the message under the corresponding group public key. In a group, all incoming messages are broadcast to every party in the group, including messages for other groups’ group public keys and messages to be mixed. When a new message arrives, group members store it in a message pool until there are enough messages to be mixed. If the message pool is full, the message mix phase is performed. The mixing phase has 6 steps: • DoS-resistant incoming message handling: for each incoming message, the previous forwarder appends its signature. This signature is generated using a trusted public key of a member of the current group. Members of the current group verify the signature and broadcast the incoming message if the signature is valid. Otherwise, the incoming message is dropped. If the number of messages signed by the same trusted public key exceeds a limit, subsequent messages signed by the same key are discarded. • Verifiable shuffling: in this step, incoming messages are shuffled to increase the anonymity of messages. Initially, all incoming messages are stored in a list. For each group member, an identical message list is maintained since every message is broadcast to every member. Then, every group member initializes the shuffling of the message list using the group public key assigned to it. • Decryption and check: in the previous step, several messages were shuffled using a public key different from the public key used for encryption. In this step, users decrypt a special message to check and remove messages shuffled using a wrong public key. • Anonymous public key re-encryption: after shuffling of messages, the trusted forwarder needs to decide the next trusted forwarder and re-encrypt the message for the next trusted forwarder. The current trusted forwarder asks other group members to re-encrypt the message using an anonymous group public key that is created from the group public key of the next trusted forwarder and a randomly sampled public key to ensure other members are not able to learn who the next trusted forwarder is.
Decryption with the anonymous secret key: to remove one layer of encryption added in the previous step, the trusted group member decrypts the re-encrypted message using the corresponding secret key of the randomly sampled public key. Afterwards, the incoming message is encrypted using the group public key of the next trusted forwarder anonymously. • Forwarding: group members forward messages to a group decided by the trusted forwarder.
•
A. Setup In the setup phase, we construct one distinct group public key for every group member. We use a Secure Distributed Key Generation scheme to ensure 1. a message can be processed only with the participation of the trusted forwarder and at least nmin − 1 other group members where nmin is the minimum number of required participants 2. a message can be processed when n − nmin group members are unresponsive and the trusted forwarder remains responsive where n is the number of members in a group. To generate a group public key for the i-th member of a group, we use the Secure Distributed Key Generation protocol proposed by Gennaro et al. [8] with threshold (n, 2n − nmin ) to generate the public key and partial secret keys of the group. After key generation, the i-th member holds n + 1 − nmin key pairs for the i-th group public key gpki , while other members hold exactly one pair. Consequently, messages encrypted under gpki can be decrypted only by combining the secret keys of the i − th member with at least additional nmin − 1 secret keys. The group public key generation process is executed periodically, so new users can be included continuously after a waiting time. Members only need to adjust the n value according to the number of members in the group. B. Anonymous trusted party discovery and DoS prevention In this section, we present the design of our anonymous trusted party discovery protocol. It enables users to send messages to nearby trusted parties, while keeping trust relationships secret. We also introduce a trust-based DoS-resistant incoming message handling mechanism in this section. An advantage of Moby is that it can mitigate DoS attacks by only forwarding and receiving messages from trusted parties. To prevent DoS attacks from other groups, we let group members only receive messages from trusted parties and forward messages only to trusted parties. To achieve this goal, we need a trusted party discovery protocol to let group members know which party in neighboring groups is trusted. A straightforward approach would be to broadcast the public keys of trusted parties. However, this method reveals the trust relationship between users that can compromise privacy and break message unlinkability. For example, if a message is sent from a trusted party of a specific group member and this group member forwards a message later, adversaries are able to link these two messages if the trust relationship between the group member and the message sender is known.
To avoid this issue, we design an anonymous trusted party discovery protocol to protect the unlinkability of messages. Similarly to Anix [15], we assume that there is a trust public key P Ki for each user, and such keys are only known by trusted parties of a user. As the first step in trusted party discovery, each party generates a pseudonym nym every time it joins a group. This pseudonym is essentially a randomly generated public key P Knym and the corresponding private key SKnym is kept secret. To inform trusted parties about a user, this user signs P Knym using its trust secret key SKi . So, trusted parties of this user know that the anonymous public key P Knym is generated by one of its trusted users. We use the key blind signature scheme proposed by Denis et al. [6] similar to Anix to ensure that other parties are not able to gain knowledge about P Ki based on the signatures generated using SKi . Afterwards, the signed P Knym acts as the anonymous identifier of the user and is broadcast to all neighboring groups. To prevent DoS attacks, such identification messages also need to be signed collaboratively by group members. Therefore, the identification message of every group member is aggregated and signed by a group public key. Unlike the group public key owned by different members, this group public key is not generated for a specific trusted group mechanism, and each member has the same number of shares for the corresponding private key. In such a way, a group only needs to sign and broadcast the identification message once unless there are new members joining this group. For the corresponding trusted parties in neighboring groups who know the public key, they can verify the signature and know P Knym of the trusted parties in the received identification message. As mentioned above, group members only process messages signed by a known trusted public key. So, group members need a way to add trusted parties’ keys to an identical list maintained by all group members, which we refer to as the trust list, without losing anonymity. P Knym cannot be used directly because it is a long-term key that potentially multiple parties, namely all trusted parties of the corresponding user, can link to the real identity, allowing adversaries to infer relationships through long-term observations. Instead of P Knym , we let a party calculate an anonymized trust key Hash(P K2 ||P Knym ) T P K = P K1 where P K1 is the trust public key of the trusted party in the neighbor group, P K2 is the trust public key of the user itself, P Knym is the pseudonym of the user, and Hash maps a string to a scalar of the underlying group. The trust key now combines the public key of both parties and also a randomly generated pseudonym. Thus, different users have different trust keys even if they trust the same party. Also, if a user joins a new group, they agree on a new trust key with all of their trusted parties, as P Knym is group-dependent. As a result, unless an adversary knows both P K1 and P K2 , it cannot infer trust relationships with non-negligible probability. After the calculation of anonymized trust keys, group members aggregate their anonymized trust keys using the multiparty private set union (MPSU) protocol proposed by Gao
et al. [7] to hide the owner of each anonymized trust key. Such a PSU operation has an upper limit on the set size, so malicious parties are not able to apply DoS attacks by adding a large number of trusted parties. With PSU operations, adversaries cannot link an anonymized trust key to a specific member. The owner of P K1 can calculate the secret key as T SK = SK1 · Hash(P K2 ||P Knym ) where SK1 is its own secret key, P Knym is the pseudonym it has received and verified before, and P K2 is the corresponding trust public key for the pseudonym, considering ElGamal encryption scheme is used. Later, if it wants to forward a message to the group of the trusted party, it can sign the message using T SK because T P K is added to the neighbor group trust list if the trusted party executes the trust discovery protocol correctly. To realize a DoS-resistant incoming message handling, all messages except identification messages must be signed with an anonymized trust key. Accordingly, group members process an incoming message only if it carries a valid signature under a key contained in the group’s trust list. However, using signatures under a fixed anonymized trust key would allow any group member to link multiple incoming messages, since all such signatures are publicly verifiable under the same key. To provide anonymity for signers while still enabling abuse detection, we employ a linkable ring signature (LRS) scheme [24]. To sign messages with LRS, the sender of messages needs to know the ring to be used beforehand. Therefore, the trust list is also broadcast to neighboring groups after the anonymized trust keys are aggregated from the group members. Then, the sender can sign a message using T SK it holds and the ring of a group. LRS supports signatures to a specific ”event-id”. We use the current timestamp as the ”event-id”. Hence, signatures generated using the same T SK under the same event-id are linkable to each other by the linkability of LRS, and corresponding messages can be identified and dropped by group members. Consequently, a party cannot flood a group with dummy messages. The trust mechanism alone is not sufficient to resist traffic analysis, since an adversary can link trusted forwarders with potential senders by observing traffic patterns. In particular, consider a scenario in which several users trust the same group member and forward their messages to that party. Later, the trusted group member will handle all those messages, while other members do not have messages to process. In this case, the adversary can learn that the senders of these messages trust a specific group member. For subsequent messages from the same senders, the adversary can link the outgoing messages of the corresponding trusted group member to messages sent from those senders with a non-negligible probability, which weakens the unlinkability guarantees of TrustMix. To avoid this problem, we require potential senders to transmit dummy messages when they have no real messages to send. Assuming an anonymized trust key can be used to sign up to k messages per minute without being linkable, and the owner of this key only has a messages to send, it generates k − a dummy messages and forwards them to the corresponding trusted party. In practice, a sender sends k dummy messages every
minute and stores messages to be sent in a list. When a dummy message is to be sent, the dummy message is dropped and replaced with the first message in the list if the list is not empty. As a result, group members exhibit a uniform outgoing traffic pattern over time, preventing an adversary from inferring relationships between message senders and group members based on the traffic pattern. C. TrustMix After the anonymous trusted party discovery, group public keys and identification information are broadcast to neighboring groups so neighbors learn about trusted parties nearby and their group public keys. When a sender sends a message, it randomly chooses a party from all its nearby trusted parties as the trusted forwarder. The sender then encrypts its message under the group public key of the chosen trusted forwarder, signs this message using the corresponding T SK, and forwards the resulting ciphertext to the group of the trusted forwarder When receiving messages, parties wait for enough messages similar to a threshold mix network. If there are enough messages to be mixed, they start the verifiable shuffling as mentioned before. The incoming messages are in the form of (m · gpkir1 , g r1 ) where r1 is an unknown random number and i is the index of the chosen trusted forwarder, as the ElGamal encryption system is used in TrustMix. To shuffle messages, the public key of the messages is required. However, each group member has a different group public key, and group members do not know which public key is the correct one. We introduce the expansion-and-shuffling procedure to solve this issue. We assume that all parties can be the trusted forwarder for every message and shuffle messages with every group public key. We denote the incoming message list kept by the member j as list j. For messages in the list j, member j shuffles them using gpkj . Concretely, a group member samples a new random number r2 , calculates (m · gpkir1 · gpkj r2 , g r1 · g r2 ) for every m on the list, and shuffles the ciphertexts obtained with a random permutation. Hence, we can obtain a valid encrypted message (m · gpki r1 +r2 , g r1 +r2 ) if the correct public key is used, i.e., j = i. Otherwise, we have a message (m · gpkir1 · gpkj r2 , g r1 · g r2 ) that can only be decrypted to a random group element. Afterwards, the shuffled list is forwarded to the next member of the group (the next member is the member (j + 1) mod n if the index of the current member j). The group key index j is also sent with the shuffled message so that the member j + 1 knows the key used to shuffle the received messages. The member j + 1 shuffles the received messages with gpkj and sends them to the member j + 2. This process continues until member j − 1, which means that every participant has shuffled the messages. For each shuffling, members generate a proof based on the verifiable shuffling algorithm proposed by Groth [10]. Hence, they cannot shuffle messages with a wrong group public key. In practice, shuffling processes of different group keys can be parallelized to accelerate the shuffling of messages. The remaining challenge is how to detect and remove malformed ciphertexts from the shuffled output. To address this,
the sender transmits two related ciphertexts with each message: ′ ′ m1 = (m · gpki r1 , g r1 ) and m2 = (m−1 · gpki r1 , g r1 ). These two ciphertexts are processed together throughout the shuffling procedure and enable group members to verify message correctness without revealing the content of a message. Both m1 and m2 are shuffled using the same expansion-and-shuffling procedure described above. However, it is essential that the two ciphertext lists are shuffled under the same hidden permutation so that corresponding pairs remain aligned. The verifiable shuffle scheme of Groth [10] guarantees that for a list of inputs x1 , . . . , xk and outputs y1 , . . . , yk , there exists a permutation π and randomizers such that yπ(i) = xi ·g ri . In our construction, we maintain two lists (m1,1 , . . . , m1,k ) and (m2,1 , . . . , m2,k ), which are shuffled independently to produce (y1,1 , . . . , y1,k ) and (y2,1 , . . . , y2,k ). To prove that the same permutation was applied to both lists, group members additionally prove that the products of (y1,1 · y2,1 , . . . , y1,k · y2,k ) form a valid shuffle of (m1,1 ·m2,1 , . . . , m1,k ·m2,k ). A valid proof guarantees that each y1,j is paired with its correct counterpart y2,j , preserving the correspondence between the two ciphertext components. After shuffling, decryption and check takes place. we multiply m1j and m2j for all j. If m1j and m2j are shuffled using the correct group public key, they should be the form ′ ′ of (m · gpki r , g r ) and (m−1 · gpki r , g r ) where r and r′ are two secret ′random numbers. Thus, the multiplication ′ equals (gpki r+r , g r+r ), that is, the encryption of 1. If a wrong group public key is used, messages are in the′ form of ′ ′ r1′ r1 r2 −1 r1 +r2 ) and (m ·gpki ·gpkk r2 , g r1 +r2 ) (m·gpki ·gpkj , g where gpki is the group public key used to encrypt the message, gpkj is the group public key used to shuffle the message, r1 and r1′ are random numbers determined by the previous group, r2 , r2′ are random numbers chosen by current group members. ′Then, the multiplication of two messages ′ ′ ′ equals (gpki r1 +r1 · gpkj r2 +r2 , g r1 +r1 +r2 +r2 ). Hence, group members are able to check whether a message is in the correct form by decrypting the multiplication of two linked messages. If the decrypted result equals 1, the integrity check of the message passes, and the owner of the corresponding public key is the trusted forwarder of this message. Otherwise, the wrong public key is used to shuffle this message, and the corresponding message should be dropped. Similarly to Atom [17], a proof showing that a member has decrypted the message using the correct secret key is generated during the decryption of the messages to prevent malicious behaviors. In conclusion, group members know there is a message for a specific group member but are unable to link it to the corresponding incoming message. It is possible that the number of ciphertext pairs that decrypt to 1 is less than the number of messages in the incoming message list. This may occur either because some group members misbehave during the decryption process or because some messages are malformed. In the former case, misbehavior can be detected since participants generate proofs of correct decryption, which can be verified by other group members to identify misbehaving parties. In the latter case,
malformed messages are simply discarded without further consequences. After decryption and check, the trusted forwarder of the current group chooses the next trusted forwarder in a neighboring group and initializes the anonymous public key reencryption. To hide the identity of the next trusted forwarder, it asks group members to re-encrypt the ciphertext under an anonymous group public key apk. apk is the product of the next trusted forwarder’s group public key gpki′ and a randomly sampled public key rpk, chosen by the current trusted forwarder. Although every message is end-to-end encrypted, adversaries are able to link a received message to a specific sender based its cipher text. Therefore, we leverage a zeroknowledge proof [4] that shows ∃(i, rpk, rsk) where gpki′ · rpk = apk ∧rpk = g rsk to prevent the trusted forwarder from embedding its own public key into apk to learn the content of a message. After re-encryption, the ciphertext pair is in the form of (m · apk r1 , g r1 )||(m−1 · apk r2 , g r2 ). In the last step of the message processing (decryption with the anonymous secret key), the trusted forwarder removes the blinding factor rpk in the ciphertext by computing (g r1 )rsk = rpk r1 and dividing it out from the first component, r r yielding (m · gpk ′ i 1 , g r1 ). Similarly, (m−1 · gpki′ 2 , g r2 ) is calculated for the inverse message. The trusted forwarder must generate a zero-knowledge proof that it knows the secret key rsk corresponding to the rpk used to generate apk, and that the transformation from apk-encryption to gpki′ -encryption is performed correctly using this same rsk. This ensures that the ciphertext was not manipulated using incorrect keys. After this step, the resulting ciphertext pair is correctly encrypted under the group public key of the next trusted forwarder. V. S ECURITY In TrustMix, the trusted party routes the message to the next group. For parties who accidentally trust the adversary, the adversary is able to route the message to a malicious group and decrypt the message without any honest participants. Such a behavior cannot be prevented in re-encryption based mixing protocols if the forwarder is malicious. Therefore, we only prove the security of TrustMix for honest groups similar to the security analysis of Atom [17]. By an honest group, we mean a group such that either i) the forwarder selected as the trusted party is honest or ii) there are at least n − nmin + 1 honest parties ensuring that there is at least one honest participant during the shuffling and decryption of messages. Compared with Atom, TrustMix does not rely on the ”many-trust assumption” [17] if the trusted party is honest and provides a similar security level when the trusted party is an adversary. We prove two security properties for TrustMix: Message unlinkability ensures that outgoing messages and incoming messages of a group are unlinkable, whereas message integrity ensures that messages cannot be modified or forged, not even by the trusted forwarder. In our proofs, we assume that the adversary controls the trusted forwarder. This represents the strongest adversarial setting and avoids redundant arguments
for cases in which the adversary controls at most nmin group members but not the trusted forwarder, since in those scenarios the adversary obtains less information than when the trusted forwarder is compromised. In the security games of our proofs, we simulate the shuffling process under the assumption that at least one participant in each group is honest. We use a simulator to simulate the shuffling process with at least one honest participant based on the random oracle model. Concretely, we use the shuffling scheme proposed by Groth [10] that provides a Special Honest Verifier Zero-Knowledge (SHVZK) argument of knowledge for correctness shuffling. Informally, this means that a prover can convince an honest verifier that a set of ciphertexts is a valid re-encryption and permutation of an input set, without revealing the underlying permutation or plaintexts, while guaranteeing that any prover that succeeds must know such a permutation and the corresponding randomness. By the soundness of the SHVZK argument of knowledge for correct shuffling, no adversary can produce an incorrect shuffle that is accepted, and by the zero-knowledge property, no information about the permutation is leaked. Therefore, in our proofs we abstract away the concrete multi-party shuffling procedure and replace it with a simulator that models the shuffle via a random oracle. Specifically, the oracle selects a random permutation π and re-randomizes all incoming messages so π is hidden for the adversary. Regarding the decryption process after shuffling, it is obvious that decryption of encrypted 1 does not leak any information about the underlying plaintext message or the applied permutation. Therefore, we abstract away the concrete decryption procedure and give the adversary with the correctly shuffled ciphertexts in our security games. It simulates the outcome of the decryption phase while not weakening the adversary. A. Integrity of messages Integrity implies that an adversary cannot alter the content of incoming messages during the execution of a protocol. To prove the integrity of TrustMix, we simulate TrustMix with a game GM Integrity as described in Algorithm 1 and show that a PPT adversary A is not able to tamper with an incoming message with a non-negligible probability. In Algorithm 1, k messages, trust public keys, and trust secret keys are generated using random oracle Oram at first. It implies that messages are sent from parties that are not controlled by the adversary, so A does not know the trust secret key. The case when some messages are sent from parties controlled by A, it is equivalent to the case where there are fewer incoming messages, i.e., lower k, which is still covered by Algorithm 1. By the correctness of the underlying key generation protocol [8], each participant should hold a public/secret key pair for each group public key after the key generation process. In our security proofs, we abstract away the concrete multi-party key generation protocol and instead simulate its outcome as follows: A and Oram each generates 1 public key for each group public key. It simulates the case where there is at least one honest party during the
construction of k group public keys. Afterwards, we use Oram to encrypt and sign generated messages and forward the signed ciphertext to A. During the encryption of a message, a random permutation p for the k group public keys is generated by Oram to ensure A does not know which group public key is used to encrypt a message. Similarly, a random permutation π is also generated for the incoming message. In Line 7 of Algorithm 1, we let Oram permute the generated messages based on π and re-randomize them to simulate the shuffling of incoming messages with at least one honest participant. Afterwards, A chooses a shuffled message to be attacked. Next, A chooses the group public keys of the next group and also the anonymous key apk and the corresponding proof of apk. If the proof cannot be verified correctly, A loses the game. If the proof is correct, Oram outputs the re-encrypted message with the selected apk to A to simulate a correct execution of the re-encryption algorithm. Here, we assume that a verifiable re-encryption scheme that satisfies correctness like the ChaumPedersen proof [5] is used, so A cannot forge the message in this step. If the proof is not correct, the honest party notices the existence of adversaries and stops the execution of the protocol. Afterwards, A needs to replace the anonymous key with the actual group public key of the next proof. A outputs the message encrypted by the next group public key and the proof that shows the re-encryption is done correctly. If the output message is not the original message and the proof can be verified successfully, A wins the game. Definition 1 (Integrity). A protocol satisfies integrity if any Probabilistic Polynomial-Time (PPT) adversary A can not win message integrity game GM Integrity in Algorithm 1 with a non-negligible probability. Theorem 1. If the shuffling scheme provides an SHVZK argument of knowledge for correctness of the shuffling, the reencryption scheme satisfies correctness, the underlying zeroknowledge proof protocol satisfies correctness and soundness, and there is at least one honest participant during the execution of TrustMix, TrustMix satisfies message integrity. Proof. In GM Integrity , after selecting the message to be attacked, A chooses an anonymous public key apk with a proof showing that apk = gpki′ · rpk and A know the corresponding secret key rsk for rpk where i is an arbitrary index for the generated group public keys of A. Then, A receives the re-encrypted message and needs to output the corresponding outgoing message with a proof for the selected incoming message in Line 15 of Algorithm 1. By the soundness and correctness of the proof system underlying V erif y2, acceptance′′ implies the existence of witnesses such ′′ ′′ ′′ that mA = mb · apk r1,b /g r1,b ·rsk and g r1,b ·rsk = rpk r1,b hold. ′′ ′′ So, mA = mb · apk r1,b /rpk r1,b holds. Because the proof also r ′′ requires that apk equals gpki′ · rpk, mA = mb · gpk ′ i 1,b holds r ′′
′ 2,b ultimately. Similarly, m′A = m−1 . Therefore, any b · gpk i accepting output must correspond to a correct re-encryption of the challenged message. Hence, no PPT adversary A can win GM Integrity with a non-negligible probability.
Algorithm 1 GM Integrity 1: (mi , T P Ki , T SKi )i∈1..k ← O
is at least one honest participant during the execution of TrustMix, TrustMix satisfies message unlinkability.
ram
2: A → (pki )i∈1..k 3: (pkihonest )i∈1..k ← O ram 4: A ← (gpki := pki · pkihonest )i∈1..k ← O ram r1,i r2,i −1 5: A ← (mi · gpkpi , g r1,i , mi · gpkpi , g r2,i , sigi )i∈1..k ←
Oram ′ ′ r1,ik+j r1,π 6: A ← ( mπi · gpkpπi i · gpkj , g r1,πi +r1,ik+j , m−1 πi · r2,π
r′
′
gpkpπi i · gpkj 2,ik+j , g r2,πi +r2,ik+j )i∈1..k,j∈1..k ← Oram ′ ′ ′′ ′′ 7: let r1,π = r1,πi + r1,kπi +pπ , r2,π = r2,πi + r2,kπi +pπ i i i
′′ r1,π
r ′′
i
′′ r2,π
r ′′
i 2,πi 8: A ← ( mπi · gpkpπi i , g 1,πi , m−1 )i∈1..k πi · gpkpπi , g 9: b ← A 10: A → ((gpki′ )i∈1..k , apk, δ)
11: δ : A knows rsk, rpk such that ∃i : gpki′ · rpk = apk ∧
rpk = g rsk 12: if !V erif y(apk, (gpki′ )i∈1..k , δ) then 13: return 0 14: end if −1 r ′′ r ′′ r ′′ r ′′ 15: A ← (mb · apk 1,b , g 1,b , mb · apk 2,b , g 2,b ) ← O ram ′′ ′′ r r 16: A → (mA , g 1,b , m′A , g 2,b , δ ′ ) ′ 17: δ : A knows rsk, rpk such that ∃i : gpki′ · rpk = apk ∧ ′′ ′′ rpk = g rsk ∧ mb · apk r1,b /mA = g r1,b ·rsk ∧ m−1 · b ′′ ′′ apk r2,b /m′A = g r2,b ·rsk −1 r ′′ r ′′ r ′′ r ′′ 18: if V erif y2( mA , g 1,b , m′A , g 2,b , mb · apk 1,b , g 1,b ,mb · ′′ ′′ ′′ r r2,b r2,b apk , g , apk, δ ′ ) ∧ mA ̸= mb · gpki′ 1,b then 19: return 1 20: end if 21: return 0 B. Unlinkability of messages The unlinkability game GM U nlinkability described in Algorithm 2 is almost the same as GM Integrity except that the goal of A is to link an outgoing message to an incoming message now. Instead of letting A choose the index of a message by itself, Oram chooses the incoming messages with a randomly selected index b in GM U nlinkability , so A can guess the index b later. Afterwards, the same re-encryption and verification process as in GM Integrity occurs. In Line 18 of Algorithm 2, however, A needs to output the guessed index b′ instead of outputting a modified message. If the guessed b′ is equal to the index selected by Oram before, A wins GM U nlinkability . Definition 2 (Unlinkability). A protocol satisfies unlinkability if any Probabilistic Polynomial-Time (PPT) adversary A cannot win the message unlinkability game GM U nlinkability described in Algorithm 2 with a probability higher than 1/k + negl where negl is a negligible probability and k is the number of messages. Theorem 2. If the Decisional Diffie–Hellman assumption holds, the shuffling scheme provides an SHVZK argument of knowledge for correctness of the shuffling, the re-encryption scheme satisfies correctness, the underlying zero-knowledge proof protocol satisfies correctness and soundness, and there
Algorithm 2 GM U nlinkability 1: (mi , T P Ki , T SKi )i∈1..k ← O ram 2: A → (pki )i∈1..k 3: (pkihonest )i∈1..k ← O ram
4: A ← (gpki := pki · pkihonest )i∈1..k ← O ram r1,i r2,i −1 5: A ← (mi · gpkpi , g r1,i , mi · gpkpi , g r2,i , sigi )i∈1..k ←
Oram ′ ′ r1,ik+j r1,π 6: A ← ( mπi · gpkpπi i · gpkj , g r1,πi +r1,ik+j , m−1 πi · r2,π
r′
′
gpkpπi i · gpkj 2,ik+j , g r2,πi +r2,ik+j )i∈1..k,j∈1..k ← Oram ′
′
′′ = r1,πi + r1,kπi +pπ 7: let r1,π i ′′ r1,π
r ′′
i
′′ = r2,πi + r2,kπi +pπ , r2,π i ′′ r2,π
i
r ′′
i 2,πi 8: A ← ( mπi · gpkpπi i , g 1,πi , m−1 )i∈1..k πi · gpkpπi , g
9: b ← O ram 10: A → ((gpki′ )i∈1..k , apk, δ) 11: δ : A knows rsk, rpk such that ∃i : gpki′ · rpk = apk ∧
rpk = g rsk 12: if !V erif y(apk, (gpki′ )i∈1..k , δ) then 13: return 0 14: end if −1 r ′′ r ′′ r ′′ r ′′ 15: A ← (mb · apk 1,b , g 1,b , mb · apk 2,b , g 2,b ) ← O ram r ′′ r′ 16: A → (mA , g 1,b , m′A , g 2,b , δ ′ ) ′ 17: δ : A knows rsk, rpk such that ∃i : gpki′ · rpk = apk ∧ ′′ ′′ rpk = g rsk ∧ mb · apk r1,b /mA = g r1,b ·rsk ∧ m−1 · b ′′ ′′ r2,b r2,b ·rsk apk /mB = g −1 r ′′ r ′′ r ′′ r ′′ 18: if V erif y2( mA , g 1,b , m′A , g 2,b , mb · apk 1,b , g 1,b ,mb · ′′ ′′ ′′ r2,b r2,c ′ ′ r1,b apk , g , apk, δ ) ∧ mA ̸= mb · gpki then 19: A → b′ 20: if b′ == b then 21: return 1 22: end if 23: return 0 24: end if
Proof. We prove the unlinkability as a sequence of games, and remove steps that do not influence A’s winning rate gradually. After the shuffling of messages, A obtains a uniformly randomly permutation of re-randomized ciphertexts as described in Line 6 of Algorithm 2. To show the re-randomized ciphertexts and the re-encryption of the chosen ciphertext are not helpful for A to win the game, we define a sequence of hybrid games H0 , H1 · · · H2k2 +2k where H0 is GM U nlinkability . In the first 2k 2 games, the Diffie-Hellman elements of the shuffled ciphertexts in Line 6 of Algorithm 2 are replaced ′ by 2k 2 uniformly random group elements g xi . We need 2k 2 games because the shuffling of k pairs of encrypted messages and inverse messages under k group public keys generates 2k 2 ciphertexts. Similarly, 2k Diffie–Hellman elements of correctly shuffled ciphertexts in Line 8 of Algorithm 2 are also replaced by 2k uniformly random group elements. For
Algorithm 3 G2M U nlinkability
this with the win rate of G2M U nlinkability , we obtain
1: (mi )i∈1..k ← O ram 2: A → (pki )i∈1..k 3: (pkihonest )i∈1..k ← O ram 4: A ← (gpki := pki · pkihonest )i∈1..k ← O ram
P r[A wins GM U nlinkability ] 2
≤ 1/k +
r1,i r2,i −1 5: A ← (mi · gpkpi , g r1,i , mi · gpkpi , g r2,i , sigi )i∈1..k ← ram
O
′
′
← (mπi · g xi·k+j , g r1,πi +r1,ik+j , m−1 · πi ′ r2,πi +r2,ik+j ram g ,g )i∈1..k,j∈1..k ← O ′ ′ ′′ ′′ = r + r 7: let r1,π 1,π i 1,kπi +pπ , r2,πi = r2,πi + r2,kπi +pπ i 6: A
x′k2 +i·k+j
′′
r ′′
i
′′
r ′′
i
xi+k 8: A ← ( mπi · g xi , g 1,πi , m−1 , g 2,πi )i∈1..k πi · g ram 9: b ← O 10: A → ((gpki′ )i∈1..k , apk, δ) 11: δ : A knows rsk, rpk such that ∃i : gpki′ · rpk = apk ∧
rpk = g
rsk
12: if !V erif y(apk, (gpki′ )i∈1..k , δ) then 13: return 0 14: end if −1 r ′′ r ′′ r ′′ r ′′ 15: A ← (mb · apk 1,b , g 1,b , mb · apk 2,b , g 2,b ) ← O ram 16: A → b′ 17: if b′ == b then 18: return 1 19: end if
ciphertexts related to apk, we are not able to replace them with random group elements because apk and gpk ′ are chosen by A, and it can decrypt the ciphertexts to check whether it is from a random group element or a valid message. Finally, G2M U nlinkability is obtained where all ciphers after shuffling except the re-encryption of the chosen message are replaced with random elements. In G2M U nlinkability , ciphertexts after shuffling received by ′ A are of the form (mi · g xi , gir ) and (mi −1 · g yi , g ri ) where all exponents are chosen independently and uniformly at random. For any fixed message mi , the distribution of mi · g xi is uniform. Therefore, ciphertexts in Line 6 and Line 8 of Algorithm 3 are independent of the chosen index b from the view of A in G2M U nlinkability . For the ciphertexts in Line 15 of Algorithm 3, the only component that depends on the chosen index b is the plaintext message mb . We can assume that A obtains mb by decrypting the ciphertexts using the secret key corresponding to apk. However, knowing mb does not reveal the corresponding incoming message, since the incoming ciphertexts are distributed as independent ElGamal encryptions of the plaintexts under uniformly random randomness. Consequently, conditioned on mb , every incoming ciphertext is also equally likely to correspond to it. Hence, P r[A wins G2M U nlinkability ] = 1/k. Meanwhile, if an adversary can distinguish Hj from Hj+1 , it implies that this adversary is capable of distinguishing whether the output ciphertext contains gpkiri or a random number g xi , which can be used to break the DDH assumption. Hence, |P r[A(Hj ) = 1] − P r[A(Hj+1 = 1)]| ≤ AdvDDH where P r[A(Hj ) = 1] is the probability that A wins Hj . Combining
2kX +2k
|P r[A(Hj ) = 1] − P r[A(Hj+1 = 1)]|
j=0
≤ 1/k + (2k 2 + 2k) · AdvDDH As AdvDDH is negligible, (2k 2 + 2k) · AdvDDH is negligible. In conclusion, A cannot win GM U nlinkability with a probability non-negligibly higher than 1/k and TrustMix satisfies unlinkability. VI. E VALUATION We evaluate TrustMix both as a proof-of-concept Android implementation on real phones and as a simulation to scale to hundreds of users, allowing us to characterize the level of anonymity. A. Proof-of-Concept implementation We implement TrustMix for a single group and evaluate the performance of TrustMix with a different number of participants. As different groups are able to process messages independently, the results of our implementation can be used to estimate the throughput of TrustMix. Our implementation [3] is based on the WIFI-aware feature of Android phones. In our implementation, users find nearby devices through WIFI-aware discovery, which provides information about other devices, including device ID, application version, and starting timestamp. After receiving discovery messages from all members of the group, an index is assigned to each member deterministically based on their device ID and timestamp. Afterwards, each pair of participants establishes a direct connection and the group key construction is executed as described in Section IV. In our implementation, we use the P-256 curve based ECC encryption scheme to realize 128-bit security [13]. We let a specific member generate messages and broadcast the generated messages to simulate messages collected from neighbors. Afterwards, each party executes TrustMix as described in Section IV. We also implement the Atom shuffling algorithm [17] using the same framework for comparison. In our evaluation, we vary the number of users in a group and measure the time required to mix 100 messages and compare TrustMix with Atom. We keep the number of messages fixed because our simulation shows that a higher number of messages in the pool only has a minor influence on the anonymity of messages. The time consumption of each step is recorded locally by each device and the final result is the average of results in all devices. For the key exchange between participants, it can be completed in a second, and we ignore it in our result. We use five smartphones in our evaluation: two Samsung S25 devices (Snapdragon 8 Elite, Android 15) and three Samsung S21 devices (Snapdragon 888, Android 13). Experiments with one or two devices are conducted using
only S25 phones. For experiments involving more devices, we incrementally add one S21 phone each time the number of participants increases. Those phones are placed on the same table.
25
Time (seconds)
20
TrustMix - Shuffling TrustMix - Decryption TrustMix - Re-encryption Atom - Shuffling Atom - Re-encryption
15 10 5 0
1
2
3 4 Number of Participants
We let each group generate 8 messages per second and run an exiting mix network simulator [11] to evaluate the anonymity of the generated messages over 60 seconds. We run our simulation with 100 groups in a 10 ∗ 10 square 10 times and calculate the mean of obtained results. To simulate the message shuffling of TrustMix, we let the simulator use the threshold mix strategy, that means a node shuffles messages in the message pool only when the number of messages reaches a defined threshold. We evaluate the anonymity of TrustMix varying message pool size, number of mix nodes that every message goes through, and the number of corrupted groups. Specifically, for each output message, Mixim provides the probability distribution over possible senders, from which we compute entropy [21] and report the average across all messages.
5
Fig. 1: Time consumption to mix 100 messages with different number of participants As shown in Figure 1, the time required for only one participant is low as no communication is involved, whereas for two or more participants, the required time increases linearly, as participants sequentially apply the shuffling, decryption, and re-encryption operations to a set of messages. For the comparison of TrustMix and Atom, we find that the shuffling time of Atom is about half that of TrustMix, which is due to the fact that TrustMix processes two messages for every message, the encrypted message itself and its inverse. Shuffling of messages with multiple group public keys in a group does not significantly influence the speed of TrustMix because different participants shuffle messages using different group public keys in parallel. The same re-encryption process is performed by both TrustMix and Atom, so they have a similar re-encryption time. Overall, the throughput of TrustMix is approximately 45% that of Atom. However, TrustMix can deal with more misbehavior than Atom at the price of efficiency. For the increased number of messages, the processing time will increase linearly considering the time to shuffle, decrypt, re-encrypt, and exchange messages increase linearly as the number of messages increase. Although the throughput of TrustMix for a 5-user group is only about 3.6 messages per second, it still shows that TrustMix can be used in scenarios where messages are sent with low frequency and high anonymity is required. ‘ B. Anonymity For the evaluation of anonymity, we simulate groups as nodes in a square system where each group has four neighbors on the top, bottom, left, and right sides. In practice, the number of neighboring groups depends on the density of devices, physical constraints, and the group formation strategy. To focus on the intrinsic anonymity properties of TrustMix and to avoid confounding effects of network topologies, we only evaluate TrustMix in a square topology.
Fig. 2: Anonymity entropy of TrustMix with a varying pool size and a different number of mixes Figure 2 illustrates that the mixing significantly improves the anonymity of the message considering that forwarding messages without mixing results in an anonymity entropy equal to 1, because the adversary is able to trace each message back to its sender based on traffic patterns. As the pool size increases, so does the entropy, as there are more messages that a message can be confused with. However, the increase tapers off at around a pool size of 60, as the fixed number of messages per group during a period limits the anonymity. In addition, increasing the number of mixing hops further improves anonymity, since messages are shuffled across more groups with a larger set of messages. However, the benefit diminishes as the number of hops increases, indicating decreasing returns from a high number of hops. In simulations with varying numbers of corrupted groups, we assume that the adversary is capable of decrypting and observing the plaintexts of all messages forwarded to corrupted groups. By a corrupted group, we mean that every member inside the group is controlled by the adversary. Consequently, once a message is forwarded to a corrupted group, subsequent mixing does not increase its anonymity entropy since the adversary can forward all incoming messages to another corrupted group. Figure 3 shows that anonymity entropy decreases approximately linearly as the ratio of adversaries increases. Although the effectiveness of TrustMix is limited when a large fraction of the network is controlled by adversaries, the results still indicate that it can provide a high level of anonymity when the majority of participants are honest.
Fig. 3: Anonymity entropy of TrustMix under different adversary ratios
VII. C ONCLUSION In conclusion, TrustMix realizes a significant anonymity increase in the square topology and even with the existence of active adversaries in the network. Meanwhile, our Proofof-Concept implementation shows the feasibility of TrustMix with real devices. Although the improvement of the anonimity in practice will depend on the underlying network topology and node connectivity, our results still show that TrustMix is effective in enlarging the anonymity sets through mixing and can be expected increase the message anonymity in different topologies. R EFERENCES [1] Martin R. Albrecht, Jorge Blasco, Rikke Bjerg Jensen, and Lenka Mareková. Collective information security in large-scale urban protests: the case of hong kong. In Michael D. Bailey and Rachel Greenstadt, editors, 30th USENIX Security Symposium, USENIX Security 2021, August 11-13, 2021, pages 3363–3380. USENIX Association, 2021. [2] Martin R. Albrecht, Raphael Eikenberg, and Kenneth G. Paterson. Breaking bridgefy, again: Adopting libsignal is not enough. In Kevin R. B. Butler and Kurt Thomas, editors, 31st USENIX Security Symposium, USENIX Security 2022, Boston, MA, USA, August 10-12, 2022, pages 269–286. USENIX Association, 2022. [3] Anonymous. https://anonymous.4open.science/r/trustmix-e4a7. Anonymous code repository, 2026. Accessed: 2026-01. [4] Eli Ben-Sasson, Alessandro Chiesa, Eran Tromer, and Madars Virza. Succinct non-interactive zero knowledge for a von neumann architecture. In Kevin Fu and Jaeyeon Jung, editors, Proceedings of the 23rd USENIX Security Symposium, San Diego, CA, USA, August 20-22, 2014, pages 781–796. USENIX Association, 2014. [5] David Chaum and Torben Pryds Pedersen. Wallet databases with observers. In Ernest F. Brickell, editor, Advances in Cryptology CRYPTO ’92, 12th Annual International Cryptology Conference, Santa Barbara, California, USA, August 16-20, 1992, Proceedings, volume 740 of Lecture Notes in Computer Science, pages 89–105. Springer, 1992. [6] Frank Denis, Edward Eaton, Tancrède Lepoint, and Christopher A. Wood. Key blinding for signature schemes. Internet-Draft draft-irtfcfrg-signature-keyblinding-03, Internet Engineering Task Force, 2023. [7] Jiahui Gao, Son Nguyen, and Ni Trieu. Toward A practical multi-party private set union. Proc. Priv. Enhancing Technol., 2024(4):622–635, 2024. [8] Rosario Gennaro, Stanislaw Jarecki, Hugo Krawczyk, and Tal Rabin. Secure distributed key generation for discrete-log based cryptosystems. In Jacques Stern, editor, Advances in Cryptology - EUROCRYPT ’99, International Conference on the Theory and Application of Cryptographic Techniques, Prague, Czech Republic, May 2-6, 1999, Proceed-
ing, volume 1592 of Lecture Notes in Computer Science, pages 295–310. Springer, 1999. [9] Margarita Grinko, Sarvin Qalandar, Dave Randall, and Volker Wulf. Nationalizing the internet to break a protest movement: Internet shutdown and counter-appropriation in iran of late 2019. Proc. ACM Hum. Comput. Interact., 6(CSCW2):1–21, 2022. [10] Jens Groth and Steve Lu. Verifiable shuffle of large size ciphertexts. In Tatsuaki Okamoto and Xiaoyun Wang, editors, Public Key Cryptography - PKC 2007, 10th International Conference on Practice and Theory in Public-Key Cryptography, Beijing, China, April 16-20, 2007, Proceedings, volume 4450 of Lecture Notes in Computer Science, pages 377–392. Springer, 2007. [11] Iness Ben Guirat, Devashish Gosain, and Claudia Dı́az. Mixim: Mixnet design decisions and empirical evaluation. In WPES ’21: Proceedings of the 20th Workshop on Workshop on Privacy in the Electronic Society, Virtual Event, Korea, 15 November 2021, pages 33–37. ACM, 2021. [12] Harry Halpin. Nym credentials: Privacy-preserving decentralized identity with blockchains. In Crypto Valley Conference on Blockchain Technology, CVCBT 2020, Rotkreuz, Switzerland, June 11-12, 2020, pages 56–67. IEEE, 2020. [13] Darryl Hankerson, Alfred Menezes, and Scott Vanstone. Guide to Elliptic Curve Cryptography. Springer, 2004. [14] David Inyangson, Sarah Radway, Tushar M. Jois, Nelly Fazio, and James Mickens. Amigo: Secure group mesh messaging in realistic protest settings. In Chun-Ying Huang, Jyh-Cheng Chen, Shiuh-Pyng Shieh, David Lie, and Véronique Cortier, editors, Proceedings of the 2025 ACM SIGSAC Conference on Computer and Communications Security, CCS 2025, Taipei, Taiwan, October 13-17, 2025, pages 4244–4258. ACM, 2025. [15] Sina Kamali and Diogo Barradas. Anix: Anonymous blackout-resistant microblogging with message endorsing. In Marina Blanton, William Enck, and Cristina Nita-Rotaru, editors, IEEE Symposium on Security and Privacy, SP 2025, San Francisco, CA, USA, May 12-15, 2025, pages 1381–1399. IEEE, 2025. [16] Jiejun Kong and Xiaoyan Hong. ANODR: anonymous on demand routing with untraceable routes for mobile ad-hoc networks. In Proceedings of the 4th ACM Interational Symposium on Mobile Ad Hoc Networking and Computing, MobiHoc 2003, Annapolis, Maryland, USA, June 1-3, 2003, pages 291–302. ACM, 2003. [17] Albert Kwon, Henry Corrigan-Gibbs, Srinivas Devadas, and Bryan Ford. Atom: Horizontally scaling strong anonymity. In Proceedings of the 26th Symposium on Operating Systems Principles, Shanghai, China, October 28-31, 2017, pages 406–422. ACM, 2017. [18] Adam Lerner, Giulia Fanti, Yahel Ben-David, Jesus Garcia, Paul Schmitt, and Barath Raghavan. Rangzen: Anonymously getting the word out in a blackout. CoRR, abs/1612.03371, 2016. [19] Ania M. Piotrowska, Jamie Hayes, Tariq Elahi, Sebastian Meiser, and George Danezis. The loopix anonymity system. In Engin Kirda and Thomas Ristenpart, editors, 26th USENIX Security Symposium, USENIX Security 2017, Vancouver, BC, Canada, August 16-18, 2017, pages 1199–1216. USENIX Association, 2017. [20] Amogh Pradeep, Hira Javaid, Ryan Williams, Antoine Rault, David R. Choffnes, Stevens Le Blond, and Bryan Ford. Moby: A blackoutresistant anonymity network for mobile devices. Proc. Priv. Enhancing Technol., 2022(3):247–267, 2022. [21] Andrei Serjantov and George Danezis. Towards an information theoretic metric for anonymity. In International Workshop on Privacy Enhancing Technologies, pages 41–53. Springer, 2002. [22] Stefaan Seys and Bart Preneel. ARM: anonymous routing protocol for mobile ad hoc networks. Int. J. Wirel. Mob. Comput., 3(3):145–155, 2009. [23] Jelle van den Hooff, David Lazar, Matei Zaharia, and Nickolai Zeldovich. Vuvuzela: scalable private messaging resistant to traffic analysis. In Ethan L. Miller and Steven Hand, editors, Proceedings of the 25th Symposium on Operating Systems Principles, SOSP 2015, Monterey, CA, USA, October 4-7, 2015, pages 137–152. ACM, 2015. [24] Yuxi Xue, Xingye Lu, Man Ho Au, and Chengru Zhang. Efficient linkable ring signatures: New framework and post-quantum instantiations. In Joaquı́n Garcı́a-Alfaro, Rafal Kozik, Michal Choras, and Sokratis K. Katsikas, editors, Computer Security - ESORICS 2024 - 29th European Symposium on Research in Computer Security, Bydgoszcz, Poland, September 16-20, 2024, Proceedings, Part IV, volume 14985 of Lecture Notes in Computer Science, pages 435–456. Springer, 2024.