add btv2 infohash

2025-11-25 20:24:54 +01:00
parent 81d4295427
commit a2ac04563e
16 changed files with 812 additions and 13 deletions
@@ -0,0 +1,200 @@
+import {createHash} from 'crypto';
+import {SimpleHash} from './SimpleHash';
+import {encode} from 'bencodec';
+import {basename} from 'path';
+
+/**
+ * BitTorrent v2 Info Hash Hasher (BEP 52)
+ *
+ * Implements BitTorrent v2 file hashing with:
+ * - Fixed 16KB block size
+ * - SHA-256 merkle tree
+ * - Info hash computation
+ *
+ * Architecture:
+ * 1. Streaming: Accumulates file data into 16KB blocks
+ * 2. Block hashing: SHA-256 hash each complete block
+ * 3. Merkle tree: Build balanced tree from block hashes
+ * 4. Info hash: SHA-256(bencode(info_dict))
+ */
+export class BtihV2Hasher implements SimpleHash {
+    private static readonly BLOCK_SIZE = 16 * 1024; // 16KB fixed by BEP 52
+
+    private blockHashes: Buffer[] = [];
+    private currentBlock: Buffer[] = [];
+    private currentBlockSize: number = 0;
+    private fileSize: number = 0;
+    private fileName: string = 'unknown';
+
+    /**
+     * Optional: Set filename for info dictionary
+     * If not set, defaults to 'unknown'
+     */
+    setFileName(fileName: string): void {
+        this.fileName = basename(fileName);
+    }
+
+    /**
+     * Update hasher with new data chunk
+     * Accumulates chunks into 16KB blocks and hashes each complete block
+     */
+    update(data: Uint8Array): SimpleHash {
+        const buffer = Buffer.from(data);
+        this.fileSize += buffer.length;
+
+        let offset = 0;
+        while (offset < buffer.length) {
+            const remaining = BtihV2Hasher.BLOCK_SIZE - this.currentBlockSize;
+            const toRead = Math.min(remaining, buffer.length - offset);
+
+            // Accumulate chunk into current block
+            this.currentBlock.push(buffer.subarray(offset, offset + toRead));
+            this.currentBlockSize += toRead;
+            offset += toRead;
+
+            // When block is complete, hash it
+            if (this.currentBlockSize === BtihV2Hasher.BLOCK_SIZE) {
+                this.finalizeBlock();
+            }
+        }
+
+        return this;
+    }
+
+    /**
+     * Finalize current block by hashing it and storing the hash
+     */
+    private finalizeBlock(): void {
+        if (this.currentBlock.length === 0) return;
+
+        const blockData = Buffer.concat(this.currentBlock);
+        const blockHash = createHash('sha256').update(blockData).digest();
+        this.blockHashes.push(blockHash);
+
+        // Reset current block
+        this.currentBlock = [];
+        this.currentBlockSize = 0;
+    }
+
+    /**
+     * Compute final info hash
+     *
+     * Steps:
+     * 1. Finalize any partial block
+     * 2. Build merkle tree from block hashes
+     * 3. Construct info dictionary (name, length, pieces_root)
+     * 4. Bencode info dict
+     * 5. SHA-256 of bencoded data = info hash
+     */
+    digest(): Buffer {
+        // Finalize any remaining partial block
+        if (this.currentBlockSize > 0) {
+            this.finalizeBlock();
+        }
+
+        // Handle empty file edge case
+        if (this.blockHashes.length === 0) {
+            // Empty file: hash empty block
+            const emptyHash = createHash('sha256').update(Buffer.alloc(0)).digest();
+            this.blockHashes.push(emptyHash);
+        }
+
+        // Build merkle tree to get pieces root
+        const piecesRoot = this.buildMerkleTree(this.blockHashes);
+
+        // Construct info dictionary (BEP 52 v2 format)
+        const infoDict = {
+            name: this.fileName,
+            length: this.fileSize,
+            'piece length': this.computePieceLength(this.fileSize),
+            'pieces root': piecesRoot,
+            'meta version': 2 // BitTorrent v2
+        };
+
+        // Bencode the info dictionary
+        const bencodedInfo = encode(infoDict);
+
+        // Info hash = SHA-256 of bencoded info dict
+        const infoHash = createHash('sha256').update(bencodedInfo).digest();
+
+        return infoHash;
+    }
+
+    /**
+     * Build balanced merkle tree from leaf hashes
+     *
+     * Algorithm (from BEP 52 reference implementation):
+     * 1. Pad to power of 2 with zero hashes
+     * 2. Recursively pair adjacent hashes
+     * 3. Hash each pair: SHA-256(left || right)
+     * 4. Repeat until single root hash remains
+     */
+    private buildMerkleTree(hashes: Buffer[]): Buffer {
+        if (hashes.length === 0) {
+            throw new Error('Cannot build merkle tree from empty hash list');
+        }
+
+        // Pad to next power of 2 with zero hashes
+        let paddedHashes = [...hashes];
+        const targetSize = this.nextPowerOfTwo(paddedHashes.length);
+        const zeroHash = Buffer.alloc(32); // 32 bytes of zeros for SHA-256
+        while (paddedHashes.length < targetSize) {
+            paddedHashes.push(zeroHash);
+        }
+
+        // Build tree by repeatedly pairing and hashing
+        while (paddedHashes.length > 1) {
+            const parentHashes: Buffer[] = [];
+
+            for (let i = 0; i < paddedHashes.length; i += 2) {
+                const left = paddedHashes[i];
+                const right = paddedHashes[i + 1];
+                const combined = Buffer.concat([left, right]);
+                const parentHash = createHash('sha256').update(combined).digest();
+                parentHashes.push(parentHash);
+            }
+
+            paddedHashes = parentHashes;
+        }
+
+        return paddedHashes[0];
+    }
+
+    /**
+     * Compute piece length using BEP 52 formula
+     *
+     * Formula: piece_length = 16KB * 2^n
+     * where: file_size / piece_length < 2048
+     *
+     * This ensures each file has between 1024 and 2047 pieces
+     */
+    private computePieceLength(fileSize: number): number {
+        if (fileSize === 0) {
+            return BtihV2Hasher.BLOCK_SIZE; // 16KB for empty files
+        }
+
+        let pieceLength = BtihV2Hasher.BLOCK_SIZE; // Start at 16KB
+        const maxPieces = 2048;
+
+        // Increase piece length until we have < 2048 pieces
+        while (Math.ceil(fileSize / pieceLength) >= maxPieces) {
+            pieceLength *= 2;
+        }
+
+        return pieceLength;
+    }
+
+    /**
+     * Find next power of 2 >= n
+     */
+    private nextPowerOfTwo(n: number): number {
+        if (n === 0) return 1;
+        n--;
+        n |= n >> 1;
+        n |= n >> 2;
+        n |= n >> 4;
+        n |= n >> 8;
+        n |= n >> 16;
+        return n + 1;
+    }
+}