flux-dl 1.0.0

package/src/utils/cookieManager.js

@@ -0,0 +1,110 @@
+const fs = require('fs');
+const path = require('path');
+
+class CookieManager {
+  constructor() {
+    this.cookies = {};
+  }
+
+  // Lade Cookies aus Netscape-Format (cookies.txt)
+  loadFromFile(filepath) {
+    try {
+      if (!fs.existsSync(filepath)) {
+        console.log('No cookies.txt found, continuing without cookies');
+        return false;
+      }
+
+      const content = fs.readFileSync(filepath, 'utf8');
+      const lines = content.split('\n');
+
+      for (const line of lines) {
+        // Überspringe Kommentare und leere Zeilen
+        if (line.startsWith('#') || line.trim() === '') {
+          continue;
+        }
+
+        // Parse Netscape cookie format (Tab-getrennt)
+        const parts = line.split('\t');
+        if (parts.length >= 7) {
+          const domain = parts[0];
+          const name = parts[5];
+          let value = parts[6];
+
+          // Entferne ungültige Zeichen (Newlines, etc.)
+          value = value.replace(/[\r\n]/g, '').trim();
+          
+          // Überspringe leere oder ungültige Cookies
+          if (!name || !value) {
+            continue;
+          }
+
+          // Speichere Cookie
+          if (!this.cookies[domain]) {
+            this.cookies[domain] = {};
+          }
+          this.cookies[domain][name] = value;
+        }
+      }
+
+      const cookieCount = Object.values(this.cookies).reduce((sum, domain) => 
+        sum + Object.keys(domain).length, 0
+      );
+
+      console.log(`✓ Loaded ${cookieCount} cookies from ${filepath}`);
+      return true;
+
+    } catch (error) {
+      console.warn('Failed to load cookies:', error.message);
+      return false;
+    }
+  }
+
+  // Hole Cookies für eine Domain
+  getCookiesForDomain(domain) {
+    const cookies = {};
+
+    // Suche nach exakter Domain und Wildcard-Domains
+    for (const [cookieDomain, domainCookies] of Object.entries(this.cookies)) {
+      if (domain.endsWith(cookieDomain.replace(/^\./, ''))) {
+        Object.assign(cookies, domainCookies);
+      }
+    }
+
+    return cookies;
+  }
+
+  // Erstelle Cookie-String für Header
+  getCookieString(domain) {
+    const cookies = this.getCookiesForDomain(domain);
+    
+    // Filtere und validiere Cookies
+    const validCookies = Object.entries(cookies)
+      .filter(([name, value]) => {
+        // Entferne ungültige Zeichen
+        const cleanValue = value.replace(/[\r\n\t]/g, '');
+        return name && cleanValue && cleanValue.length > 0;
+      })
+      .map(([name, value]) => {
+        // Säubere den Wert
+        const cleanValue = value.replace(/[\r\n\t]/g, '').trim();
+        return `${name}=${cleanValue}`;
+      });
+    
+    return validCookies.join('; ');
+  }
+
+  // Füge Cookie manuell hinzu
+  addCookie(domain, name, value) {
+    if (!this.cookies[domain]) {
+      this.cookies[domain] = {};
+    }
+    this.cookies[domain][name] = value;
+  }
+
+  // Prüfe ob Cookies vorhanden sind
+  hasCookies() {
+    return Object.keys(this.cookies).length > 0;
+  }
+}
+
+module.exports = CookieManager;

package/src/utils/encryption.js

@@ -0,0 +1,102 @@
+const crypto = require('crypto');
+
+class VideoEncryption {
+  constructor(secretKey = 'your-secret-key-change-this') {
+    this.secretKey = secretKey;
+    this.algorithm = 'aes-256-cbc';
+  }
+
+  // URL verschlüsseln
+  encryptUrl(url, expiresIn = 3600) {
+    const expiryTime = Date.now() + (expiresIn * 1000);
+    
+    const data = JSON.stringify({
+      url: url,
+      expires: expiryTime
+    });
+
+    const iv = crypto.randomBytes(16);
+    const key = crypto.scryptSync(this.secretKey, 'salt', 32);
+    const cipher = crypto.createCipheriv(this.algorithm, key, iv);
+    
+    let encrypted = cipher.update(data, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    
+    // IV + verschlüsselte Daten kombinieren
+    const token = iv.toString('hex') + ':' + encrypted;
+    
+    return {
+      token: token,
+      encryptedUrl: `encrypted://${Buffer.from(token).toString('base64')}`
+    };
+  }
+
+  // URL entschlüsseln
+  decryptUrl(encryptedUrl) {
+    try {
+      // Base64 dekodieren
+      const token = encryptedUrl.replace('encrypted://', '');
+      const decoded = Buffer.from(token, 'base64').toString('utf8');
+      
+      const [ivHex, encrypted] = decoded.split(':');
+      
+      const iv = Buffer.from(ivHex, 'hex');
+      const key = crypto.scryptSync(this.secretKey, 'salt', 32);
+      const decipher = crypto.createDecipheriv(this.algorithm, key, iv);
+      
+      let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+      decrypted += decipher.final('utf8');
+      
+      const data = JSON.parse(decrypted);
+      
+      // Prüfe Ablaufzeit
+      if (Date.now() > data.expires) {
+        throw new Error('URL expired');
+      }
+      
+      return data.url;
+    } catch (error) {
+      throw new Error(`Decryption failed: ${error.message}`);
+    }
+  }
+
+  // Signatur für URL erstellen (HMAC)
+  signUrl(url, expiresIn = 3600) {
+    const expiryTime = Math.floor(Date.now() / 1000) + expiresIn;
+    const message = `${url}:${expiryTime}`;
+    
+    const hmac = crypto.createHmac('sha256', this.secretKey);
+    hmac.update(message);
+    const signature = hmac.digest('hex');
+    
+    return {
+      url: url,
+      expires: expiryTime,
+      signature: signature,
+      signedUrl: `${url}?expires=${expiryTime}&signature=${signature}`
+    };
+  }
+
+  // Signatur verifizieren
+  verifySignature(url, expires, signature) {
+    const message = `${url}:${expires}`;
+    
+    const hmac = crypto.createHmac('sha256', this.secretKey);
+    hmac.update(message);
+    const expectedSignature = hmac.digest('hex');
+    
+    // Zeitbasierte Prüfung
+    if (Math.floor(Date.now() / 1000) > expires) {
+      throw new Error('URL expired');
+    }
+    
+    // Signatur-Prüfung
+    if (signature !== expectedSignature) {
+      throw new Error('Invalid signature');
+    }
+    
+    return true;
+  }
+}
+
+module.exports = VideoEncryption;

package/src/utils/requestSpoofing.js

@@ -0,0 +1,141 @@
+const axios = require('axios');
+
+class RequestSpoofing {
+  constructor() {
+    this.userAgents = [
+      // Chrome on Windows
+      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      // Firefox on Windows
+      'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
+      // Edge on Windows
+      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0',
+      // Safari on Mac
+      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15',
+      // Chrome on Android
+      'Mozilla/5.0 (Linux; Android 13) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.144 Mobile Safari/537.36'
+    ];
+    
+    this.currentIndex = 0;
+  }
+
+  getRandomUserAgent() {
+    const ua = this.userAgents[this.currentIndex];
+    this.currentIndex = (this.currentIndex + 1) % this.userAgents.length;
+    return ua;
+  }
+
+  getBrowserHeaders(referer = null) {
+    const headers = {
+      'User-Agent': this.getRandomUserAgent(),
+      'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
+      'Accept-Language': 'en-US,en;q=0.9',
+      'Accept-Encoding': 'gzip, deflate, br',
+      'Connection': 'keep-alive',
+      'Upgrade-Insecure-Requests': '1',
+      'Sec-Fetch-Dest': 'document',
+      'Sec-Fetch-Mode': 'navigate',
+      'Sec-Fetch-Site': 'none',
+      'Sec-Fetch-User': '?1',
+      'Cache-Control': 'max-age=0'
+    };
+
+    if (referer) {
+      headers['Referer'] = referer;
+    }
+
+    return headers;
+  }
+
+  getVideoDownloadHeaders(videoUrl, referer) {
+    // KRITISCH: Range-Header für YouTube Downloads
+    return {
+      'User-Agent': this.getRandomUserAgent(),
+      'Accept': '*/*',
+      'Accept-Language': 'en-US,en;q=0.9',
+      'Connection': 'keep-alive',
+      'Range': 'bytes=0-',
+      'Referer': referer || 'https://www.youtube.com/',
+      'Sec-Fetch-Dest': 'video',
+      'Sec-Fetch-Mode': 'no-cors',
+      'Sec-Fetch-Site': 'cross-site'
+    };
+  }
+
+  async makeRequest(url, options = {}) {
+    const config = {
+      url: url,
+      method: options.method || 'GET',
+      headers: options.headers || this.getBrowserHeaders(options.referer),
+      timeout: options.timeout || 30000,
+      httpsAgent: new (require('https').Agent)({
+        rejectUnauthorized: false
+      }),
+      maxRedirects: 5,
+      validateStatus: (status) => status < 500
+    };
+
+    if (options.responseType) {
+      config.responseType = options.responseType;
+    }
+
+    try {
+      const response = await axios(config);
+      return response;
+    } catch (error) {
+      throw new Error(`Request failed: ${error.message}`);
+    }
+  }
+
+  async downloadStream(url, referer, onProgress) {
+    // Prüfe ob URL gültig ist
+    if (!url || !url.startsWith('http')) {
+      throw new Error('Invalid download URL');
+    }
+
+    const headers = this.getVideoDownloadHeaders(url, referer);
+    
+    const config = {
+      url: url,
+      method: 'GET',
+      headers: headers,
+      responseType: 'stream',
+      httpsAgent: new (require('https').Agent)({
+        rejectUnauthorized: false
+      }),
+      maxRedirects: 10,
+      timeout: 0, // Kein Timeout für große Downloads
+      decompress: false, // WICHTIG: Keine automatische Dekompression
+      validateStatus: (status) => status >= 200 && status < 400
+    };
+
+    try {
+      const response = await axios(config);
+      
+      if (response.status === 403) {
+        console.warn('Warning: Received 403 status, but continuing...');
+      }
+      
+      if (onProgress) {
+        const totalLength = response.headers['content-length'];
+        let downloadedLength = 0;
+
+        response.data.on('data', (chunk) => {
+          downloadedLength += chunk.length;
+          if (totalLength) {
+            const percent = Math.round((downloadedLength / totalLength) * 100);
+            onProgress(percent, downloadedLength, totalLength);
+          }
+        });
+      }
+
+      return response.data;
+    } catch (error) {
+      if (error.response && error.response.status === 403) {
+        throw new Error('403 Forbidden - Video URL requires valid signature. The N-parameter transformation may have failed.');
+      }
+      throw error;
+    }
+  }
+}
+
+module.exports = RequestSpoofing;

package/src/utils/signatureDecoder.js

@@ -0,0 +1,164 @@
+const axios = require('axios');
+const vm = require('vm');
+
+class SignatureDecoder {
+  constructor() {
+    this.cache = new Map();
+  }
+
+  async decodeSignature(signatureCipher, videoId, userAgent) {
+    // Parse signatureCipher
+    const params = new URLSearchParams(signatureCipher);
+    const url = params.get('url');
+    const s = params.get('s');
+    const sp = params.get('sp') || 'signature';
+
+    if (!s) {
+      return url; // Keine Signatur nötig
+    }
+
+    // Player-Code laden und Signatur entschlüsseln
+    const signature = await this.decipher(s, videoId, userAgent);
+    
+    // URL mit entschlüsselter Signatur zurückgeben
+    return `${url}&${sp}=${encodeURIComponent(signature)}`;
+  }
+
+  async decipher(signature, videoId, userAgent) {
+    // Player-URL finden
+    const playerUrl = await this.getPlayerUrl(videoId, userAgent);
+    
+    if (this.cache.has(playerUrl)) {
+      const decipherFunc = this.cache.get(playerUrl);
+      return decipherFunc(signature);
+    }
+
+    // Player-Code laden
+    const playerCode = await this.fetchPlayerCode(playerUrl, userAgent);
+    
+    // Decipher-Funktion extrahieren
+    const decipherFunc = this.extractDecipherFunction(playerCode);
+    
+    // Cache speichern
+    this.cache.set(playerUrl, decipherFunc);
+    
+    return decipherFunc(signature);
+  }
+
+  async getPlayerUrl(videoId, userAgent) {
+    const response = await axios.get(`https://www.youtube.com/watch?v=${videoId}`, {
+      headers: {
+        'User-Agent': userAgent
+      },
+      httpsAgent: new (require('https').Agent)({
+        rejectUnauthorized: false
+      })
+    });
+
+    const html = response.data;
+    
+    // Player-URL extrahieren
+    const match = html.match(/"jsUrl":"([^"]+)"/);
+    if (!match) {
+      throw new Error('Could not find player URL');
+    }
+
+    let playerUrl = match[1].replace(/\\\//g, '/');
+    
+    if (playerUrl.startsWith('//')) {
+      playerUrl = 'https:' + playerUrl;
+    } else if (playerUrl.startsWith('/')) {
+      playerUrl = 'https://www.youtube.com' + playerUrl;
+    }
+
+    return playerUrl;
+  }
+
+  async fetchPlayerCode(playerUrl, userAgent) {
+    const response = await axios.get(playerUrl, {
+      headers: {
+        'User-Agent': userAgent
+      },
+      httpsAgent: new (require('https').Agent)({
+        rejectUnauthorized: false
+      })
+    });
+
+    return response.data;
+  }
+
+  extractDecipherFunction(playerCode) {
+    // Mehrere Patterns versuchen (YouTube ändert oft die Struktur)
+    const patterns = [
+      /([a-zA-Z0-9$]+)=function\([a-zA-Z]\)\{[a-zA-Z]=\1\.split\(""\)/,
+      /\b([a-zA-Z0-9$]{2,})\s*=\s*function\(\s*a\s*\)\s*\{\s*a\s*=\s*a\.split\(\s*""\s*\)/,
+      /([a-zA-Z0-9$]+)\s*=\s*function\([a-zA-Z]+\)\{[a-zA-Z]+=[a-zA-Z]+\.split\(""\)/
+    ];
+
+    let funcName = null;
+    
+    for (const pattern of patterns) {
+      const match = playerCode.match(pattern);
+      if (match) {
+        funcName = match[1];
+        break;
+      }
+    }
+
+    if (!funcName) {
+      // Fallback: Suche nach signature decipher patterns
+      const altMatch = playerCode.match(/\.sig\|\|([a-zA-Z0-9$]+)\(/);
+      if (altMatch) {
+        funcName = altMatch[1];
+      }
+    }
+
+    if (!funcName) {
+      throw new Error('Could not find decipher function name');
+    }
+
+    // Extrahiere die komplette Funktion
+    const funcPattern = new RegExp(`${funcName.replace(/\$/g, '\\$')}=function\\([a-zA-Z]\\)\\{[^}]+\\}`, 'g');
+    const funcMatch = playerCode.match(funcPattern);
+    
+    if (!funcMatch) {
+      throw new Error('Could not extract decipher function');
+    }
+
+    const funcBody = funcMatch[0];
+    
+    // Finde Helper-Objekt
+    const helperMatch = funcBody.match(/;([a-zA-Z0-9$]+)\./);
+    if (!helperMatch) {
+      throw new Error('Could not find helper object');
+    }
+
+    const helperName = helperMatch[1];
+    
+    // Extrahiere Helper-Objekt
+    const helperPattern = new RegExp(`var ${helperName.replace(/\$/g, '\\$')}=\\{[\\s\\S]+?\\}\\};`, 'g');
+    const helperMatch2 = playerCode.match(helperPattern);
+    
+    if (!helperMatch2) {
+      throw new Error('Could not extract helper object');
+    }
+
+    const helperBody = helperMatch2[0];
+    
+    // Kombiniere und erstelle ausführbare Funktion
+    const code = `
+      ${helperBody}
+      ${funcBody}
+      ${funcName};
+    `;
+
+    // Führe Code in isolierter VM aus
+    const context = {};
+    vm.createContext(context);
+    const decipherFunc = vm.runInContext(code, context);
+
+    return decipherFunc;
+  }
+}
+
+module.exports = SignatureDecoder;