What is Tox Protocol and How Does it Work

Tox Protocol is an open-source, peer-to-peer (P2P) communication platform that allows users to make voice and video calls, send messages, and share files securely and privately. It's like a private messaging app, but without the need for a central server.

Tox Protocol uses a decentralized architecture, which means that users communicate directly with each other, without relying on a third-party server to facilitate the connection. This makes Tox Protocol more secure and resistant to censorship.

Tox Protocol uses the DTLS-SRTP protocol for secure voice and video calls, and the AES-256-CBC encryption algorithm for secure messaging and file transfer. These protocols ensure that all data is encrypted and protected from interception or eavesdropping.

If this caught your attention, see: Ip Voice Call

Tox's security features are built on top of the NaCl library, which provides end-to-end encryption and perfect forward secrecy. This means that only the intended recipient can read the content of messages, and even if a secret encryption key becomes compromised, an adversary won't be able to decrypt messages from previous sessions.

For more insights, see: How to Send Encrypted Text Messages

All traffic over Tox is encrypted, and users have the ability to message friends, join chat rooms, voice/video chat, and send files. Tox uses a peer-to-peer network with no central servers, making it difficult for anyone to intercept or eavesdrop on conversations.

Tox clients use a unique Tox ID, which is derived from a user's public key and stored on a Distributed Hash Table (DHT). This allows users to find and connect with each other directly, without relying on a central server.

Group chats in Tox use the NaCl/libsodium cryptography library for all cryptographic operations, ensuring end-to-end encryption and guaranteeing message confidentiality, integrity, and repudability.

Here are the encryption algorithms used in Tox:

To prevent MITM attacks, Tox establishes 1-to-1 connections between peers, using a session key unique to each pair of peers. This ensures that private messages are truly private.

Tox also uses session keypairs and shared symmetric keys to prevent an adversary from decrypting messages from previous sessions in the event of a security breach.

Message handling in Tox is quite unique. Unlike traditional instant messaging apps, Tox doesn't have central servers like XMPP or Matrix, so both parties need to be online for messages to be sent and received.

This can lead to situations where messages are stored on the sender's phone, waiting to be delivered when the receiving party reconnects to the network. Some Tox-enabled messengers prevent the user from sending the message if the other party has disconnected, while others show the message as sent, but it's actually just stored locally.

The Tox protocol defines a specific format for messages, which includes a length and contents. The length is represented by 1 byte for messages of length 1 to 1372 bytes, or a variable length for longer messages. The contents are a UTF-8 byte string.

Here's a breakdown of the message format:

Message lengths can range from 1 byte to 1372 bytes, with the first byte indicating the message type and the remaining bytes containing the actual message as a UTF8 byte string.

Consider reading: Short Message Peer-to-Peer

The message structure is standardized, with a clear format that clients can follow.

A message can be one of four types: accept, pause, kill, or seek, each indicated by a specific control type value.

Here's a breakdown of the message structure:

The message id, or packet id, is a 1-byte value that identifies the message.

Suggestion: Message Session Relay Protocol

The status message is a feature of Tox clients that allows users to share a message with their friends. This message is sent whenever a user comes online or changes their status.

The status message is encoded as a UTF-8 byte string and can be up to 1007 characters long. It's sent to each friend every time they come online and whenever the status message is changed.

Here's a breakdown of the status message packet:

The status message packet starts with a 1-byte header containing the value 0x31, followed by the status message itself.

Lossy Packet Payloads are a crucial aspect of toxcore's message handling. They're sent at least every 1 second, and more frequently when packets are being received.

Toxcore tries to resend these packets through the DHT every 20 seconds. This isn't an overly aggressive resend rate.

Packet request packets are sent at least every 1 second in toxcore and more when packets are being received. This ensures that the network stays up-to-date and functioning properly.

Toxcore's resend rate is a reasonable 20 seconds, which allows for efficient data transmission without overwhelming the network.

If a packet request packet is sent and not received, toxcore will resend it through the DHT. This ensures that the packet is delivered even if there are connectivity issues.

See what others are reading: Samsung Ativ S

The plaintext header is a crucial part of the Toxcore Network, and it's relatively straightforward. It contains a Toxcore Network Packet Kind, which identifies the type of packet being sent.

This packet kind is used to determine the type of message being sent. The Toxcore Network Packet Kind is a single byte that specifies the packet type.

The plaintext header also contains the sender's public encryption key, which is 32 bytes long. This key is used for encryption purposes.

The Tox network is a self-organizing swarm of nodes, with each node also known as a "Tox node". This network relies on a module called DHT, which stands for Distributed Hash Table.

The DHT only runs on UDP and is used to find the IP and port of nodes and establish a direct route to them. It uses hole punching if necessary to establish a connection.

Every node in the Tox DHT has a unique ephemeral Key Pair, consisting of a DHT Secret Key and a DHT Public Key. The DHT Public Key acts as the node address and is renewed every time the Tox instance is closed or restarted.

Groupchat connections can go down, causing peers to become disconnected or the group to split into multiple connected components. To fix this, peers keep track of "frozen" peers who are no longer visible in the group.

If a frozen peer becomes active again, it's unfrozen and moved back to the peer list, and a name message is sent to the group.

Worth a look: Video Coding Experts Group

The Transport Protocol in Tox is a transport layer protocol that sits directly below the Tox protocol itself. It's used to establish a connection between nodes in the Tox network.

Tox supports two transport protocols: UDP and TCP. The choice of protocol is determined by a single bit, where 0 represents UDP and 1 represents TCP.

The binary representation of the Transport Protocol is a single bit, which is stored in the least significant bit of a byte. If encoded as a standalone value, the bit is stored in the least significant bit of a byte.

The human-readable representation for UDP is UDP and for TCP is TCP. This makes it easy to understand and work with the protocol.

Here's a breakdown of the Transport Protocol:

The Transport Protocol is used to determine how data is transmitted between nodes in the Tox network. It's an essential part of the Tox protocol and allows for efficient and reliable communication between nodes.

Timeouts and reconnection are crucial aspects of maintaining a stable groupchat connection.

Group connections can go down, causing peers to become disconnected from the group or splitting the group into multiple connected components.

To ensure the group becomes fully connected again, peers keep track of peers who are no longer visible in the group, known as "frozen" peers.

A peer is considered frozen after remaining inactive for 60 seconds, which means it's removed from the peer list and added to a separate list of frozen peers.

Frozen peers are disregarded for all purposes except reintegration.

If a frozen peer becomes active, it's unfrozen, and a name message is sent to the group to notify all peers of its return.

Any existing peer with the same public key is removed from the peer list or frozen peers list when a new peer is added.

Peer Management is a crucial aspect of the Tox protocol. A new peer connection is established with a 2-byte length field, followed by a 2-byte uint16_t peer number, a 32-byte long term public key, and a 32-byte DHT public key.

When we connect to a new peer, the protocol checks if the peer's public key matches any frozen peer. If a match is found, a rejoin packet is sent to the peer along the friend connection, and a groupchat connection is created to the peer, marked as introducing us.

The new peer connection is then marked with a peer online packet, which is sent to the peer. This ensures that the peer is notified of our online status.

If this caught your attention, see: Collabora Online

User status is a crucial aspect of peer management in Tox enabled messengers. It determines whether a user is available to receive messages or not.

There are three possible user statuses: online, away, and busy. These statuses are represented by the uint8_t status code, which can be 0 for online, 1 for away, or 2 for busy.

The USERSTATUS packet is used to send the user status of a peer to others. This packet should be sent every time to each friend every time they come online and each time the user status is changed.

Here's a breakdown of the USERSTATUS packet:

The user status is updated in real-time, allowing friends to know whether the user is available or not. This feature is essential for effective communication and helps prevent unnecessary messages from being sent when the recipient is not available.

Take a look at this: Duckduckgo Search Not Working

When a new peer joins a chat, the peer that invited them will send a new peer message to warn everyone, and the new peer's DHT public key must be set to the one in the message.

To manage peers, Toxcore sends a new peer message to warn everyone when a new peer joins, and adds the new peer to the peer list if it's not already there.

If a new peer message is received, the peer in the message's DHT public key must be set to the one in the message.

Toxcore also checks whether the public key of a new peer is that of any frozen peer, and if so, sends a rejoin packet to the peer along the friend connection.

Here's a breakdown of the contents of a new peer message:

A peer info request packet contains an empty payload and requests a peer to send information about themselves.

Toxcore currently sends 1 cookie request packet every second 8 times before killing the connection if there are no responses.

Only friends of a peer can find it and connect to it, and indirectly makes sure non-friends cannot find the IP address of the peer when knowing the Tox address of the friend.

For more insights, see: Packet Layer Protocol

So, you've sent out an invite to your team, and now you're waiting for responses. A clear and concise invite response is essential for effective peer management.

The response should include the team member's availability, which can be a simple yes or no, or a specific date and time.

A well-crafted invite response also sets the tone for the meeting, so be sure to include any relevant details, such as the agenda or any necessary materials.

In our previous example, we saw how Sarah responded to the invite with a clear and concise message that included her availability and a brief note about her schedule.

Discover more: List of SIP Response Codes

Group Chat is a fundamental feature of Tox (protocol), allowing users to communicate with multiple friends at once. The protocol includes several packet types related to group chat, including INVITE_GROUPCHAT (0x60), ONLINE_PACKET (0x61), DIRECT_GROUPCHAT (0x62), MESSAGE_GROUPCHAT (0x63), and LOSSY_GROUPCHAT (0xC7).

These packet types enable users to invite friends to a group chat, mark friends as online, send direct messages, and more. For example, the INVITE_GROUPCHAT packet (0x60) is used to invite a friend to a group chat.

Tox core stores important information about group chats, including the long-term private key, current nospam value, friends' public keys, and any friend requests the user is currently sending. This information is stored in a specific format, which will be explained later.

The TCP server plays a crucial role in group chat functionality, acting as a relay between two peers. It supports sending packets blindly through it to clients with a specific public key (OOB packets), but does not provide feedback on packet arrival. This is useful for sending data to friends who may not know the user is connected to the current TCP server.

Here are some key packet types related to group chat:

Group chats can be a bit complex, but let's break it down. There are specific packet IDs for different group chat actions, including INVITE_GROUPCHAT (0x60), ONLINE_PACKET (0x61), DIRECT_GROUPCHAT (0x62), MESSAGE_GROUPCHAT (0x63), and LOSSY_GROUPCHAT (0xC7).

These packet IDs are used to communicate different types of information within a group chat. For example, the INVITE_GROUPCHAT packet is used to invite someone to a group chat.

To facilitate group chats, the messenger stores important information, including the long-term private key, the current nospam value, friends' public keys, and any friend requests being sent. This information is used to establish and maintain connections between group chat participants.

The messenger also stores optional data, such as usernames, status messages, and more. However, the exact format of this data is explained later in the toxcore save format.

If the TCP server is enabled, it will act as a relay between two peers, allowing them to connect to each other. This is done by having both peers indicate to the server that they want to connect to each other.

Worth a look: Eyeball Chat

Here are the packet IDs for group chat actions:

It's worth noting that the TCP server can also be used to send packets blindly to clients with a specific public key (OOB packets). However, the server does not provide any feedback on whether the packet arrived or not.

See what others are reading: Mobile Web Server

If you leave a group chat and then rejoin, the system will update the peer's DHT public key in the group chat peer list. This change ensures that all members have the most up-to-date information.

The system creates a group chat connection for the peer, marked as introducing the peer, and sends a peer online packet to the peer. This packet notifies the peer that they have been reintroduced to the group.

This process happens after unfreezing the peer if it was frozen.

Private groups in Tox can only be joined by receiving an invite from someone on your friend list. If the group is private, no information about it is stored in the DHT.

Readers also liked: DuckDuckGo Private Browser

To join a private group, you need someone in your friend list to send you an invite. This is the only way to access a private group in Tox.

If a public group is set to private, its information in the DHT will expire within a few minutes. This means you won't be able to find or access the group after it's been made private.

If this caught your attention, see: Control and Provisioning of Wireless Access Points Protocol

Friend Requests are a double-edged sword in private communication, making it easy to connect with others but also vulnerable to unwanted attention.

Most social media platforms allow users to send friend requests, which can be accepted or declined by the recipient. However, some platforms, like Facebook, also allow users to send friend requests to people they don't know, increasing the risk of receiving unwanted requests.

It's essential to review and manage your friend requests regularly to maintain a healthy online presence.

Additional reading: Xiaohongshu Users

To join a private group, you need someone in your friend list to send you an invite.

Private groups don't show up in the DHT, so no peer or group information will be visible.

If a public group is set to private, its DHT information will expire within a few minutes.

The formula for calculating the number of packets sent in the last 1.2 seconds is based on the difference between the current and previous send queue sizes.

Custom private packets can be used to send arbitrary data to a specific peer, and must be greater than 0 bytes and not exceed TOX_MAX_CUSTOM_PACKET bytes.

Request packets for key rotation should be sent at least once every 10 minutes by the peer whose permanent public encryption key is closest to the group Chat ID.

If a receiving peer doesn't receive a key rotation request packet after 10 minutes plus 12 seconds, the connection should be severed.

Tox uses a relay system to help connect users across different networks. This system allows users to communicate with each other even if they're not on the same network.

Relays act as intermediaries, forwarding messages between users. They help ensure that messages are delivered efficiently and securely.

Relays are also responsible for broadcasting messages to multiple recipients. This means that a single message can be sent to multiple users at the same time, making communication more efficient.

Dht Announcements allow groups to be joined by anyone with the Chat ID, leveraging the Tox DHT network for public group chats.

This functionality has the same underlying structure as normal Tox friend announcements, including onion routing for added security.

Group announcements can be made without worrying about congestion control, as priority packets can be sent even when the network is congested.

Toxcore uses this approach for all non-file transfer packets, ensuring that normal message packets can still be sent even when file transfers are happening.

Tcp Relays (0xf1) are used to share a list of TCP relays with a confirmed peer, allowing for mutual TCP relays to be maintained when direct connections can't be established.

This packet is sent to every confirmed peer whenever a new TCP relay is added, or periodically if there are no shared TCP relays with a given peer.

The packet structure includes a variable length field for the contents, which is packed with TCP relays.

A unique perspective: Ftp Protocol Tcp or Udp

Here's a breakdown of the contents:

Toxcore decides whether to send an announce packet to one of the 4 peers in the announce response by checking if the peer would be stored as one of the stored closest peers if it responded.

Broadcast (0xf3) is a special type of message that can be sent to all nodes on a network. It's like shouting to everyone within earshot.

A broadcast message is identified by the opcode 0xf3, which is a hexadecimal code that tells nodes to forward the message to all their neighbors. This opcode is crucial for ensuring the message reaches its intended destination.

Broadcasting is particularly useful for discovering new nodes on a network, which is why it's often used in the "Discovery" phase. In this phase, nodes send broadcast messages to announce their presence.

The discovery phase is essential for building a network, and broadcast messages play a vital role in making it happen.

Readers also liked: Dropbox Lan Sync Discovery Protocol Wireshark

Error Handling is crucial when working with Tox, as it allows users to recover from unexpected situations and maintain a seamless experience. Tox's error handling mechanism ensures that the communication remains secure even when errors occur.

Tox's protocol is designed to handle errors in a way that doesn't compromise the security of the communication. This is achieved through the use of a robust error handling mechanism.

When a connection is lost, Tox's error handling mechanism automatically initiates a reconnection process, ensuring that the communication continues uninterrupted. This process is initiated by the Tox client, which continuously checks for a stable connection.

The reconnection process is handled by the Tox client, which also handles the disconnection and reconnection of the connection. This ensures that the communication remains secure and uninterrupted.

Tox's error handling mechanism also ensures that the communication remains secure even when errors occur. This is achieved through the use of end-to-end encryption and secure key exchange.

Readers also liked: What Transport Layer Protocol Does Dns Normally Use

Tox (protocol) differentiates between two types of text: Plain Text and Cipher Text. Cipher Text may be transmitted over untrusted data channels.

The Tox protocol uses a Combined Key, a Nonce, and a Plain Text to encrypt data using crypto_box_afternm. This process transforms Sensitive Plain Text into Cipher Text.

The encryption function can also perform decryption, but it's essential to use the correct functions to ensure message authentication. The protocol uses xsalsa20 symmetric encryption and poly1305 authentication for secure data transmission.

Here's a brief overview of the encryption process:

Handshake packet payloads follow specific structures. If the request type is an invite request, the receiving peer must respond with a INVITE_REQUEST packet. If the request type is a peer info exchange, the receiving peer must respond with a PEER_INFO_RESPONSE packet followed immediately by a PEER_INFO_REQUEST packet.

To understand the objectives of the Tox protocol, it's essential to grasp its goals and non-goals. The protocol aims to solve specific problems, and this section provides a clear overview of what those problems are.

The Tox protocol differentiates between two types of text: Plain Text and Cipher Text. Plain Text can be either Sensitive or Non Sensitive, and Sensitive Plain Text must be transformed into Cipher Text using the encryption function before transmission over untrusted data channels.

The encryption function is a crucial component of the Tox protocol, taking a Combined Key, a Nonce, and a Plain Text, and returning a Cipher Text. It uses crypto_box_afternm to perform the encryption.

The protocol also includes a decryption function, which takes a Combined Key, a Nonce, and a Cipher Text, and returns either a Plain Text or an error. This function is essential for retrieving the original message from the encrypted data.

The Tox protocol uses a symmetric encryption method, specifically xsalsa20, and includes message authentication using poly1305. This ensures the integrity and confidentiality of the data being transmitted.

Here's a summary of the Tox protocol's objectives:

The Tox protocol is a powerful tool for secure and anonymous communication, but like any technology, it has its limitations. One of the main limitations is that it's designed for real-time communications, which means you can't send messages if the recipient isn't online.

The Tox protocol supports a wide range of features, including text messaging, voice and video calls, chat rooms, and file transfer. However, not all clients may implement these features, so it's essential to check with the specific client you're using.

The Tox protocol differentiates between two types of text: Plain Text and Cipher Text. Plain Text can be Sensitive or Non Sensitive, and Sensitive Plain Text must be transformed into Cipher Text using the encryption function before it can be transmitted over untrusted data channels.

Here are some of the features supported by the Tox protocol:

The Tox protocol uses a combination of symmetric encryption and authentication to ensure the security and integrity of messages. Specifically, it uses xsalsa20 symmetric encryption and poly1305 authentication.

Here's an interesting read: End-to-end Encryption

In the Conferences (0x14) section, you'll find a list of saved conferences. This section contains a variety of information about each conference, including the number of peers and the title of the conference.

The length of each conference entry is determined by the type of conference, with groupchat conferences taking up 1 byte, 32 bytes, 4 bytes, 2 bytes, 2 bytes, 4 bytes, 1 byte, and an unknown amount of bytes for the title and list of peers.

A groupchat conference entry includes the following information: the groupchat type, groupchat ID, message number, lossy message number, peer number, number of peers, title length, and the title itself.

Here's a breakdown of the information stored in each groupchat conference entry:

Each peer in the conference is stored, including frozen peers, and they all start as frozen when the conference is reloaded.

Custom packets (0xF2) are used to send arbitrary data to the group. They can be used for client-side features.

A custom packet must be greater than 0 bytes, and may not exceed TOX_MAX_CUSTOM_PACKET bytes.

A broadcast packet payload indicates that a peer has changed their status or nickname. Statuses must be of type USERSTATUS.

The broadcast packet payload structure is as follows:

Toxcore keeps the 8 closest peers to each key it is searching (or announcing itself to). It starts by sending announce requests to random peers for all the public keys it is searching for.

The protocol uses a combination of TCP and UDP for data transmission, with TCP being used for reliable connections and UDP for real-time data transfer.

The protocol's packet structure consists of a header and a payload, with the header containing source and destination IP addresses, port numbers, and sequence numbers.

In the protocol's default configuration, the maximum transmission unit (MTU) is set to 1500 bytes, which can be adjusted according to network requirements.

The protocol uses a sliding window mechanism to manage data flow, with the window size being determined by the sender's buffer size and the receiver's advertised window.

The protocol's congestion control mechanism uses a combination of slow-start and congestion avoidance algorithms to prevent network congestion.

A fresh viewpoint: Data Center Locations Azure

The Tox protocol has several clients that you can use to connect and communicate with others. One of the most feature-complete clients is qTox, which is made using the Qt toolkit.

qTox is promoted by the Tox protocols homepage and is available at https://qtox.github.io/.

There's also a console client called Toxic, which is made with Ncurses and has a source code available at https://github.com/Jfreegman/toxic.

If you're looking for a client with a graphical user interface, Toxygen is a good option, made with Python 3 and PyQt5. It has both Linux and Windows versions, and you can find the source code at https://github.com/toxygen-project/toxygen.

For a lightweight client, µTox is a good choice, written in pure C and available for various platforms like Linux, *BSD, MacOS, and Windows.

If you're comfortable with the command line, ratox is another option, which is also written in pure C and can be used with pipes. It's available for Linux, *BSD, and MacOS.

Related reading: Windows Messenger