Add support for BitTorrent Protocol Version 3 and 3.1

[absolutep]

Suggestion

Tixati's developer has proposed updates to the BitTorrent protocol, starting with Version 3 and extended in Version 3.1.

Version 3 focuses on retiring SHA-1 and integrating modern hash algorithms (e.g., SHA2-256, SHA3-256).

Version 3.1 builds on this with proof-of-work for info integrity, protections against DHT metadata sniffing, and enforced encryption in peer connections. These are extensions of the existing protocol, maintaining full backward compatibility.

Implementing these updates in BiglyBT would enhance security and ensure compatibility with modern torrents.

Key specifications:

1. Protocol Version 3

2. Protocol Version 3.1

3. Full BitTorrent Specification

If these changes align with BiglyBT's scope, implementation in an upcoming release would be appreciated.

[parg]

When the major clients implement it then I'll consider it

[i990049]

I suggest to add libp2p protocol to encry the transfer, media library app support it. libtorrent won't accept and enable new protocol, such as webtorrent/webRTC protocol is still disable in libtorrent 2.x. May be libp2p protocol can be install as pluggin just like uTP.

[absolutep]

Tixati has implemented version 3 and version 3.1 in their new release v3.39.
Please, check If these changes align with BiglyBT's scope, implementation etc, Thank you.

[absolutep]

When the major clients implement it then I'll consider it

UPDATE as of today.
qBittorrent devs have agreed to implement it as soon as Tixati developer submits drafts to official BEP and Tixati dev has said he will submit BEP this week.

[parg]

I haven't confirmed I will add support, I said I'd consider it.

The BEP needs to go through some form of review, merely submitting it isn't sufficient surely?

[parg]

I don't see any BEP(s), has this effort been abandoned?

[absolutep]

I have left a comment about it. Waiting for developer to reply.

[absolutep]

Developer's answer

[absolutep]

Update = https://forum.tixati.com/support/8586

[absolutep]

copy pasting here

Backward Compatibility

This protocol is fully backward compatible.

V1-only clients: Ignore piece_hashes and info_pow as unknown keys, continuing to use SHA-1 for all operations.

V3-aware clients: Verify info_pow first. Then use both the original SHA-1 hashes in pieces AND the hashes in piece_hashes for data integrity checks on each piece.

Frequently Asked Questions

Why not just use BEP 52 (v2) "Hybrid" torrents?

Hybrid v1+v2 torrents still require "padding files" to align file boundaries with the Merkle tree structure. This complicates the torrent creation process and creates massive overhead in torrents that have a large number of small files. Also, to implement a client that correctly manages a v1 AND v2 swarm simultaneously, while keeping file data and state synchronized, is extremely difficult. V3.0 requires zero changes to underlying file data or alignment and is very easy to add to any existing client, without any major changes to program architecture.

Does info_pow make torrent creation too slow for users?

No. A typical difficulty of 20 bits takes less than a second on a modern CPU, but creates a massive cumulative barrier for an attacker.

=====================================================================================================

1. Hybrid v1+v2 torrents do create fragmented swarms

This is a real, under-acknowledged problem,

What actually happens with BEP-52 hybrids

v1 peers discover each other via the v1 info-hash

v2 peers discover each other via the v2 info-hash

These swarms are logically distinct

Data sharing between them is indirect at best and depends on a client acting as a bridge

So in practice:

A v2-only seeder cannot seed to v1-only leechers

A v1-only seeder cannot seed to v2-only leechers

Availability and swarm health are split : This is especially painful during long transition periods (which BitTorrent is famous for).

Why v3 improves this

v3 uses one v1-looking info-hash

v1, v3, and v3-enhanced clients all participate in the same swarm

No parallel DHTs, no duplicate trackers, no split peer sets

======================================================================================================

2. v3 enables true simultaneous seeding across versions

This is another legitimate advantage.

With hybrid v1+v2

A client must:

Track two info-hashes

Maintain separate peer sets

Translate piece state across two validation systems

That’s hard, fragile, and easy to get wrong.

With v3

v1 clients seed v3 data naturally

v3 clients seed v1 data naturally

No dual bookkeeping, no dual swarm logic

This reinforces earlier point that:

v3 is architecturally easy to add to existing clients related to swarm health, not just developer convenience.

============================================================================================

3. Tracker and website reality (this one matters socially)

This point is not theoretical — it’s about how BitTorrent is actually used today.

Current ecosystem reality

Many torrent websites:

Accept only v1 torrents

Index only the v1 info-hash

Ignore or reject v2-only torrents

Hybrid torrent downside

The v2 info-hash is effectively invisible

Users downloading via v2 rely on bridging behavior

Tooling and moderation pipelines remain v1-centric

v3’s advantage

Single info-hash

Fully compatible with existing websites, trackers, moderation tools

No ecosystem-wide coordination required

This addresses a practical deployment concern that protocol purists often ignore.

[absolutep]

Hi, this is copy paste from my attempt to code protocol v3 which I tried yesterday. You can read further here = Tribler/tribler#8945

`

`import hashlib
import os

--- BENCODING DECODER ---

def bdecode(data):
def decode_next(index):
if data[index:index+1] == b'i':
end = data.index(b'e', index)
number = int(data[index+1:end])
return number, end + 1

    elif data[index:index+1] == b'l':
        lst = []
        index += 1
        while data[index:index+1] != b'e':
            item, index = decode_next(index)
            lst.append(item)
        return lst, index + 1

    elif data[index:index+1] == b'd':
        dct = {}
        index += 1
        while data[index:index+1] != b'e':
            key, index = decode_next(index)
            value, index = decode_next(index)
            dct[key] = value
        return dct, index + 1

    elif data[index:index+1].isdigit():
        colon = data.index(b':', index)
        length = int(data[index:colon])
        start = colon + 1
        end = start + length
        return data[start:end], end

    else:
        raise ValueError("Invalid bencode")

result, _ = decode_next(0)
return result

--- BENCODING ENCODER ---

def bencode(value):
if isinstance(value, int):
return b'i' + str(value).encode() + b'e'

elif isinstance(value, bytes):
    return str(len(value)).encode() + b':' + value

elif isinstance(value, str):
    return bencode(value.encode())

elif isinstance(value, list):
    return b'l' + b''.join(bencode(x) for x in value) + b'e'

elif isinstance(value, dict):
    items = sorted(value.items())
    return b'd' + b''.join(bencode(k) + bencode(v) for k, v in items) + b'e'

else:
    raise TypeError("Unsupported type")

--- LOAD TORRENT ---

def load_torrent(path):
with open(path, 'rb') as f:
return bdecode(f.read())

--- HASHES ---

def compute_hashes(torrent):
info = torrent[b'info']
encoded_info = bencode(info)

sha1 = hashlib.sha1(encoded_info).hexdigest()
sha256 = hashlib.sha256(encoded_info).hexdigest()

return sha1, sha256

--- MERKLE ---

def merkle_root(hashes):
if not hashes:
return b""

while len(hashes) > 1:
    new_level = []
    for i in range(0, len(hashes), 2):
        left = hashes[i]
        right = hashes[i+1] if i+1 < len(hashes) else left
        new_level.append(hashlib.sha256(left + right).digest())
    hashes = new_level

return hashes[0]

def hash_file_v2(file_path, piece_length):
leaf_hashes = []
with open(file_path, "rb") as f:
while True:
chunk = f.read(piece_length)
if not chunk:
break
leaf_hashes.append(hashlib.sha256(chunk).digest())

return merkle_root(leaf_hashes), leaf_hashes

--- VERSION DETECTION ---

def detect_version(info):
if b'pieces' in info and b'file tree' in info:
return "Hybrid (v1 + v2)"
elif b'file tree' in info:
return "BitTorrent v2"
elif b'pieces' in info:
return "BitTorrent v1"
return "Unknown"

--- FILES ---

def parse_file_tree(tree, base_path=""):
files = []
for name, value in tree.items():
name = name.decode()
if b'' in value:
files.append({
"path": base_path + name,
"length": value[b''][b'length']
})
else:
files.extend(parse_file_tree(value, base_path + name + "/"))
return files

def extract_files(info):
if b'length' in info:
return [{
"path": info.get(b'name', b'unknown').decode(),
"length": info[b'length']
}]

elif b'files' in info:
    return [{
        "path": b'/'.join(f[b'path']).decode(),
        "length": f[b'length']
    } for f in info[b'files']]

elif b'file tree' in info:
    return parse_file_tree(info[b'file tree'])

return []

--- PIECES ---

def extract_piece_info(info, torrent):
piece_length = info.get(b'piece length', 0)

if b'pieces' in info:
    return piece_length, len(info[b'pieces']) // 20

elif b'piece layers' in torrent:
    total = sum(len(v) // 32 for v in torrent[b'piece layers'].values())
    return piece_length, total

return piece_length, 0

--- MAGNET ---

def generate_magnet(info, sha1, sha256):
name = info.get(b'name', b'unknown').decode()
magnet = f"magnet:?dn={name}"

if sha1:
    magnet += f"&xt=urn:btih:{sha1}"
if sha256:
    magnet += f"&xt=urn:btmh:1220{sha256}"

return magnet

--- V3 HELPERS ---

def build_multihash(sha1_hex, sha256_hex):
sha1_bytes = bytes.fromhex(sha1_hex)
sha256_bytes = bytes.fromhex(sha256_hex)

return {
    b"sha1": b'\x11' + bytes([len(sha1_bytes)]) + sha1_bytes,
    b"sha256": b'\x12' + bytes([len(sha256_bytes)]) + sha256_bytes
}

def build_v3_infohash(info):
encoded = bencode(info)
sha1 = hashlib.sha1(encoded).hexdigest()
sha256 = hashlib.sha256(encoded).hexdigest()
return sha1, sha256, build_multihash(sha1, sha256)

--- V3.1 HASHING ---

def build_piece_hashes_v31(file_path, piece_length):
sha256_hashes = []
sha3_hashes = []

with open(file_path, "rb") as f:
    while True:
        chunk = f.read(piece_length)
        if not chunk:
            break
        sha256_hashes.append(hashlib.sha256(chunk).digest())
        sha3_hashes.append(hashlib.sha3_256(chunk).digest())

return {
    b"SHA2-256": b"".join(sha256_hashes),
    b"SHA3-256": b"".join(sha3_hashes)
}

--- HYBRID CREATOR ---

def create_hybrid_torrent(file_path, piece_length=262144):
file_name = os.path.basename(file_path)
file_size = os.path.getsize(file_path)

root, leaf_hashes = hash_file_v2(file_path, piece_length)

file_tree = {
    file_name.encode(): {
        b"": {
            b"length": file_size,
            b"pieces root": root
        }
    }
}

piece_hashes_v31 = build_piece_hashes_v31(file_path, piece_length)

info = {
    b"name": file_name.encode(),
    b"piece length": piece_length,
    b"file tree": file_tree,
    b"piece_hashes": piece_hashes_v31,
    b"index_method": b"SHA2-256"
}

sha1, sha256, multihash = build_v3_infohash(info)

return {
    b"info": info,
    b"piece layers": {root: b"".join(leaf_hashes)},
    b"infohashes": multihash,
    b"meta version": 3
}

--- MAIN ---

if name == "main":
path = input("Enter .torrent file path: ").strip()

torrent = load_torrent(path)
info = torrent[b'info']

print("\n--- Torrent Info ---")
print("Name:", info.get(b'name', b'Unknown').decode())
print("Version:", detect_version(info))

files = extract_files(info)

print("\n--- Files ---")
total_size = 0
for f in files:
    print(f"{f['path']} ({f['length']} bytes)")
    total_size += f['length']

print("\nTotal Size:", total_size, "bytes")

piece_length, num_pieces = extract_piece_info(info, torrent)

print("\n--- Pieces ---")
print("Piece Length:", piece_length)
print("Number of Pieces:", num_pieces)

sha1, sha256 = compute_hashes(torrent)

print("\n--- Hashes ---")
print("SHA-1:", sha1)
print("SHA-256:", sha256)

print("\n--- Magnet ---")
print(generate_magnet(info, sha1, sha256))

# --- CREATE HYBRID ---
print("\n--- Create Hybrid Torrent ---")
file_path = input("Enter file path: ").strip()

if os.path.isfile(file_path):
    new_torrent = create_hybrid_torrent(file_path)
    output = os.path.basename(file_path) + ".hybrid.torrent"
    save_torrent(new_torrent, output)
    print("✅ Created:", output)
else:
    print("❌ Invalid file path")``

This sub-section was provided by Tribler developer

def save_torrent(torrent, output_path):
with open(output_path, "wb") as f:
f.write(bencode(torrent))

from hashlib import sha256
from random import randint

info = b'4:infod5:filesld6:lengthi6e4:pathl3:abc9:file2.txteed6:lengthi6e4:pathl3:abc9:file3.txteed6:lengthi6e4:pathl3:abc9:file4.txteed6:lengthi6e4:pathl3:def9:file6.avieed6:lengthi6e4:pathl3:def9:file5.txteed6:lengthi6e4:pathl9:file1.txteee4:name14:torrent_create12:piece lengthi16384e6:pieces20:\xdd\xed}"\xe2\xabE\x04\xe5\x8e\xe0\xb3\x1a\xd4\xba\xfe\xc0\xce\xe1We'
difficulty = 24
maxnonce = 2**64-1

nonce = (0).to_bytes(8, "big")
hashed = sha256(nonce + info).digest()

while not ("".join(bin(b)[2:].zfill(8) for b in hashed)).startswith("0" * difficulty):
nonce = (randint(0, maxnonce)).to_bytes(8, "big")
hashed = sha256(nonce + info).digest()

print("Found nonce", nonce)
print("Found hash", hashed)

[parg]

no thanks