AgeVerificationManager::refreshCookies() - Code Metrics - Inspection of "Improve age verification cookies handling" - NNTmux/newznab-tmux - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 73c322...402528 )

by Darko

created 2025-12-22 11:29 UTC

AgeVerificationManager::refreshCookies() A

↳ Parent: AgeVerificationManager

Complexity

Conditions	3
Paths	4

Size

Total Lines	20
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	9
c	0
b	0
f	0
dl	0
loc	20
rs	9.9666
cc	3
nc	4
nop	1

<?php

namespace App\Services\AdultProcessing;

use GuzzleHttp\Client;
use GuzzleHttp\Cookie\CookieJar;
use GuzzleHttp\Cookie\FileCookieJar;
use GuzzleHttp\Cookie\SetCookie;

/**
 * Age Verification Cookie Manager
 *
 * Automatically handles age verification for adult sites by:
 * 1. Detecting age verification pages
 * 2. Simulating acceptance (setting appropriate cookies)
 * 3. Persisting cookies to disk for reuse
 * 4. Loading saved cookies automatically
 */
class AgeVerificationManager
{
    /**
     * Cookie storage directory
     */
    private string $cookieDir;

    /**
     * Cookie jar instances per site
     */
    private array $cookieJars = [];

    /**
     * Site-specific age verification configurations
     */
    private array $siteConfigs = [
        'adultdvdempire.com' => [
            'cookies' => [
                ['name' => 'age_verified', 'value' => '1'],
                ['name' => 'age_gate_passed', 'value' => 'true'],
                ['name' => 'over18', 'value' => '1'],
                ['name' => 'ageConfirmed', 'value' => 'true'],
                ['name' => 'isAdult', 'value' => 'true'],
            ],
            'detection' => ['ageConfirmationButton', 'age-confirmation', 'confirm you are over'],
        ],
        'adultdvdmarketplace.com' => [
            'cookies' => [
                ['name' => 'age_verified', 'value' => '1'],
                ['name' => 'over18', 'value' => 'yes'],
                ['name' => 'ageConfirmed', 'value' => 'true'],
            ],
            'detection' => ['age verification', 'are you 18'],
        ],
        'straight.theater.aebn.net' => [
            'cookies' => [
                ['name' => 'age_verified', 'value' => '1'],
                ['name' => 'aebn_age_check', 'value' => 'passed'],
                ['name' => 'over18', 'value' => 'true'],
            ],
            'detection' => ['age verification', 'over 18'],
        ],
        'hotmovies.com' => [
            'cookies' => [
                ['name' => 'age_verified', 'value' => '1'],
                ['name' => 'over18', 'value' => 'true'],
                ['name' => 'ageConfirmed', 'value' => 'true'],
                ['name' => 'hmAgeVerified', 'value' => '1'],
            ],
            'detection' => ['age verification', 'enter'],
        ],
        'popporn.com' => [
            'cookies' => [
                ['name' => 'age_verified', 'value' => '1'],
                ['name' => 'over_18', 'value' => 'yes'],
                ['name' => 'ageVerified', 'value' => 'true'],
                ['name' => 'popAgeConfirmed', 'value' => '1'],
                ['name' => 'adultConsent', 'value' => 'true'],
                // Note: etoken is dynamically set by the server, we can't pre-set it
            ],
            'detection' => ['age verification', 'over 18', 'AgeConfirmation'],
            'redirectBypass' => true, // Indicates this site uses redirect-based verification
        ],
    ];

    /**
     * Constructor
     */
    public function __construct(?string $cookieDir = null)
    {
        if ($cookieDir !== null) {
            $this->cookieDir = $cookieDir;
        } else {
            $this->cookieDir = storage_path('app/cookies/adult_sites');
        }

        // Create cookie directory if it doesn't exist
        if (! is_dir($this->cookieDir)) {
            mkdir($this->cookieDir, 0755, true);
        }
    }

    /**
     * Get cookie jar for a specific site
     * Loads existing cookies or creates new jar
     */
    public function getCookieJar(string $url): FileCookieJar
    {
        $domain = $this->extractDomain($url);

        if (! isset($this->cookieJars[$domain])) {
            $cookieFile = $this->getCookieFilePath($domain);
            $this->cookieJars[$domain] = new FileCookieJar($cookieFile, true);

            // If cookie file is new or empty, set age verification cookies
            if (!file_exists($cookieFile) || filesize($cookieFile) < 10) {
                $this->setAgeVerificationCookies($domain, $this->cookieJars[$domain]);
            }
        }

        return $this->cookieJars[$domain];
    }

    /**
     * Make HTTP request with automatic age verification handling
     */
    public function makeRequest(string $url, array $options = []): string|false
    {
        $domain = $this->extractDomain($url);
        $cookieJar = $this->getCookieJar($url);

        $client = new Client([
            'cookies' => $cookieJar,
            'headers' => [
                'User-Agent' => 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
                'Accept' => 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
                'Accept-Language' => 'en-US,en;q=0.5',
                'Accept-Encoding' => 'gzip, deflate, br',
                'DNT' => '1',
                'Connection' => 'keep-alive',
                'Upgrade-Insecure-Requests' => '1',
            ],
            'allow_redirects' => true,
            'verify' => false, // For development; set to true in production
        ]);

        try {
            $response = $client->get($url, $options);
            $html = $response->getBody()->getContents();

            // Check if we got an age verification page
            if ($this->isAgeVerificationPage($html, $domain)) {
                // Set age verification cookies and retry
                $this->setAgeVerificationCookies($domain, $cookieJar);
                $cookieJar->save($this->getCookieFilePath($domain));

                // Retry request with new cookies
                $response = $client->get($url, $options);
                $html = $response->getBody()->getContents();
            }

            return $html;

        } catch (\Exception $e) {
            error_log("Age Verification Manager: Request failed for {$url}: ".$e->getMessage());

            return false;
        }
    }

    /**
     * Check if response is an age verification page
     */
    private function isAgeVerificationPage(string $html, string $domain): bool
    {
        if (! isset($this->siteConfigs[$domain])) {
            return false;
        }

        $detection = $this->siteConfigs[$domain]['detection'];
        $htmlLower = strtolower($html);

        foreach ($detection as $keyword) {
            if (stripos($htmlLower, strtolower($keyword)) !== false) {
                return true;
            }
        }

        return false;
    }

    /**
     * Set age verification cookies for a domain
     */
    private function setAgeVerificationCookies(string $domain, CookieJar $cookieJar): void
    {
        if (! isset($this->siteConfigs[$domain])) {
            return;
        }

        $cookies = $this->siteConfigs[$domain]['cookies'];
        $expiry = time() + (365 * 24 * 60 * 60); // 1 year

        foreach ($cookies as $cookieData) {
            $cookie = new SetCookie([
                'Name' => $cookieData['name'],
                'Value' => $cookieData['value'],
                'Domain' => '.'.$domain,
                'Path' => '/',
                'Expires' => $expiry,
                'Secure' => true,
                'HttpOnly' => false,
            ]);

            $cookieJar->setCookie($cookie);
        }

        // Save cookies to file
        if ($cookieJar instanceof FileCookieJar) {
            $cookieJar->save($this->getCookieFilePath($domain));
        }
    }

    /**
     * Extract domain from URL
     */
    private function extractDomain(string $url): string
    {
        $parsed = parse_url($url);
        $host = $parsed['host'] ?? '';

        // Remove www. prefix if present
        $host = preg_replace('/^www\./', '', $host);

        // Map known subdomains to main domains
        $domainMap = [
            'straight.theater.aebn.net' => 'straight.theater.aebn.net',
            'adultdvdempire.com' => 'adultdvdempire.com',
            'adultdvdmarketplace.com' => 'adultdvdmarketplace.com',
            'hotmovies.com' => 'hotmovies.com',
            'popporn.com' => 'popporn.com',
        ];

        return $domainMap[$host] ?? $host;
    }

    /**
     * Force refresh cookies for a domain.
     */
    public function refreshCookies(string $url): FileCookieJar
    {
        $domain = $this->extractDomain($url);
        $cookieFile = $this->getCookieFilePath($domain);

        // Clear existing cookie jar
        if (isset($this->cookieJars[$domain])) {
            unset($this->cookieJars[$domain]);
        }

        // Delete old cookie file if exists
        if (file_exists($cookieFile)) {
            unlink($cookieFile);
        }

        // Create new jar with fresh cookies
        $this->cookieJars[$domain] = new FileCookieJar($cookieFile, true);
        $this->setAgeVerificationCookies($domain, $this->cookieJars[$domain]);

        return $this->cookieJars[$domain];
    }

    /**
     * Get cookie file path for a domain
     */
    private function getCookieFilePath(string $domain): string
    {
        $safeName = preg_replace('/[^a-z0-9_-]/', '_', strtolower($domain));

        return $this->cookieDir.'/'.$safeName.'_cookies.json';
    }

    /**
     * Clear cookies for a specific domain
     */
    public function clearCookies(string $domain): bool
    {
        $cookieFile = $this->getCookieFilePath($domain);

        if (file_exists($cookieFile)) {
            unlink($cookieFile);
            unset($this->cookieJars[$domain]);

            return true;
        }

        return false;
    }

    /**
     * Clear all stored cookies
     */
    public function clearAllCookies(): int
    {
        $cleared = 0;
        $files = glob($this->cookieDir.'/*_cookies.json');

        foreach ($files as $file) {
            if (unlink($file)) {
                $cleared++;
            }
        }

        $this->cookieJars = [];

        return $cleared;
    }

    /**
     * Get list of domains with stored cookies
     */
    public function getStoredDomains(): array
    {
        $domains = [];
        $files = glob($this->cookieDir.'/*_cookies.json');

        foreach ($files as $file) {
            $basename = basename($file, '_cookies.json');
            $domain = str_replace('_', '.', $basename);
            $domains[] = $domain;
        }

        return $domains;
    }

    /**
     * Check if cookies exist for a domain
     */
    public function hasCookies(string $domain): bool
    {
        $cookieFile = $this->getCookieFilePath($domain);

        return file_exists($cookieFile) && filesize($cookieFile) > 10;
    }

    /**
     * Get cookie statistics
     */
    public function getCookieStats(): array
    {
        $stats = [
            'total_domains' => 0,
            'total_cookies' => 0,
            'domains' => [],
        ];

        foreach ($this->siteConfigs as $domain => $config) {
            if ($this->hasCookies($domain)) {
                $cookieJar = $this->getCookieJar('https://'.$domain);
                $cookieCount = count($cookieJar);

                $stats['domains'][$domain] = [
                    'has_cookies' => true,
                    'cookie_count' => $cookieCount,
                    'file' => $this->getCookieFilePath($domain),
                ];

                $stats['total_domains']++;
                $stats['total_cookies'] += $cookieCount;
            } else {
                $stats['domains'][$domain] = [
                    'has_cookies' => false,
                    'cookie_count' => 0,
                ];
            }
        }

        return $stats;
    }

    /**
     * Get the cookie directory path
     */
    public function getCookieDirectory(): string
    {
        return $this->cookieDir;
    }
}



1			<?php
2
3			namespace App\Services\AdultProcessing;
4
5			use GuzzleHttp\Client;
6			use GuzzleHttp\Cookie\CookieJar;
7			use GuzzleHttp\Cookie\FileCookieJar;
8			use GuzzleHttp\Cookie\SetCookie;
9
10			/**
11			* Age Verification Cookie Manager
12			*
13			* Automatically handles age verification for adult sites by:
14			* 1. Detecting age verification pages
15			* 2. Simulating acceptance (setting appropriate cookies)
16			* 3. Persisting cookies to disk for reuse
17			* 4. Loading saved cookies automatically
18			*/
19			class AgeVerificationManager
20			{
21			/**
22			* Cookie storage directory
23			*/
24			private string $cookieDir;
25
26			/**
27			* Cookie jar instances per site
28			*/
29			private array $cookieJars = [];
30
31			/**
32			* Site-specific age verification configurations
33			*/
34			private array $siteConfigs = [
35			'adultdvdempire.com' => [
36			'cookies' => [
37			['name' => 'age_verified', 'value' => '1'],
38			['name' => 'age_gate_passed', 'value' => 'true'],
39			['name' => 'over18', 'value' => '1'],
40			['name' => 'ageConfirmed', 'value' => 'true'],
41			['name' => 'isAdult', 'value' => 'true'],
42			],
43			'detection' => ['ageConfirmationButton', 'age-confirmation', 'confirm you are over'],
44			],
45			'adultdvdmarketplace.com' => [
46			'cookies' => [
47			['name' => 'age_verified', 'value' => '1'],
48			['name' => 'over18', 'value' => 'yes'],
49			['name' => 'ageConfirmed', 'value' => 'true'],
50			],
51			'detection' => ['age verification', 'are you 18'],
52			],
53			'straight.theater.aebn.net' => [
54			'cookies' => [
55			['name' => 'age_verified', 'value' => '1'],
56			['name' => 'aebn_age_check', 'value' => 'passed'],
57			['name' => 'over18', 'value' => 'true'],
58			],
59			'detection' => ['age verification', 'over 18'],
60			],
61			'hotmovies.com' => [
62			'cookies' => [
63			['name' => 'age_verified', 'value' => '1'],
64			['name' => 'over18', 'value' => 'true'],
65			['name' => 'ageConfirmed', 'value' => 'true'],
66			['name' => 'hmAgeVerified', 'value' => '1'],
67			],
68			'detection' => ['age verification', 'enter'],
69			],
70			'popporn.com' => [
71			'cookies' => [
72			['name' => 'age_verified', 'value' => '1'],
73			['name' => 'over_18', 'value' => 'yes'],
74			['name' => 'ageVerified', 'value' => 'true'],
75			['name' => 'popAgeConfirmed', 'value' => '1'],
76			['name' => 'adultConsent', 'value' => 'true'],
77			// Note: etoken is dynamically set by the server, we can't pre-set it
78			],
79			'detection' => ['age verification', 'over 18', 'AgeConfirmation'],
80			'redirectBypass' => true, // Indicates this site uses redirect-based verification
81			],
82			];
83
84			/**
85			* Constructor
86			*/
87			public function __construct(?string $cookieDir = null)
88			{
89			if ($cookieDir !== null) {
90			$this->cookieDir = $cookieDir;
91			} else {
92			$this->cookieDir = storage_path('app/cookies/adult_sites');
93			}
94
95			// Create cookie directory if it doesn't exist
96			if (! is_dir($this->cookieDir)) {
97			mkdir($this->cookieDir, 0755, true);
98			}
99			}
100
101			/**
102			* Get cookie jar for a specific site
103			* Loads existing cookies or creates new jar
104			*/
105			public function getCookieJar(string $url): FileCookieJar
106			{
107			$domain = $this->extractDomain($url);
108
109			if (! isset($this->cookieJars[$domain])) {
110			$cookieFile = $this->getCookieFilePath($domain);
111			$this->cookieJars[$domain] = new FileCookieJar($cookieFile, true);
112
113			// If cookie file is new or empty, set age verification cookies
114			if (!file_exists($cookieFile) \|\| filesize($cookieFile) < 10) {
115			$this->setAgeVerificationCookies($domain, $this->cookieJars[$domain]);
116			}
117			}
118
119			return $this->cookieJars[$domain];
120			}
121
122			/**
123			* Make HTTP request with automatic age verification handling
124			*/
125			public function makeRequest(string $url, array $options = []): string\|false
126			{
127			$domain = $this->extractDomain($url);
128			$cookieJar = $this->getCookieJar($url);
129
130			$client = new Client([
131			'cookies' => $cookieJar,
132			'headers' => [
133			'User-Agent' => 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
134			'Accept' => 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,/;q=0.8',
135			'Accept-Language' => 'en-US,en;q=0.5',
136			'Accept-Encoding' => 'gzip, deflate, br',
137			'DNT' => '1',
138			'Connection' => 'keep-alive',
139			'Upgrade-Insecure-Requests' => '1',
140			],
141			'allow_redirects' => true,
142			'verify' => false, // For development; set to true in production
143			]);
144
145			try {
146			$response = $client->get($url, $options);
147			$html = $response->getBody()->getContents();
148
149			// Check if we got an age verification page
150			if ($this->isAgeVerificationPage($html, $domain)) {
151			// Set age verification cookies and retry
152			$this->setAgeVerificationCookies($domain, $cookieJar);
153			$cookieJar->save($this->getCookieFilePath($domain));
154
155			// Retry request with new cookies
156			$response = $client->get($url, $options);
157			$html = $response->getBody()->getContents();
158			}
159
160			return $html;
161
162			} catch (\Exception $e) {
163			error_log("Age Verification Manager: Request failed for {$url}: ".$e->getMessage());
164
165			return false;
166			}
167			}
168
169			/**
170			* Check if response is an age verification page
171			*/
172			private function isAgeVerificationPage(string $html, string $domain): bool
173			{
174			if (! isset($this->siteConfigs[$domain])) {
175			return false;
176			}
177
178			$detection = $this->siteConfigs[$domain]['detection'];
179			$htmlLower = strtolower($html);
180
181			foreach ($detection as $keyword) {
182			if (stripos($htmlLower, strtolower($keyword)) !== false) {
183			return true;
184			}
185			}
186
187			return false;
188			}
189
190			/**
191			* Set age verification cookies for a domain
192			*/
193			private function setAgeVerificationCookies(string $domain, CookieJar $cookieJar): void
194			{
195			if (! isset($this->siteConfigs[$domain])) {
196			return;
197			}
198
199			$cookies = $this->siteConfigs[$domain]['cookies'];
200			$expiry = time() + (365 * 24 * 60 * 60); // 1 year
201
202			foreach ($cookies as $cookieData) {
203			$cookie = new SetCookie([
204			'Name' => $cookieData['name'],
205			'Value' => $cookieData['value'],
206			'Domain' => '.'.$domain,
207			'Path' => '/',
208			'Expires' => $expiry,
209			'Secure' => true,
210			'HttpOnly' => false,
211			]);
212
213			$cookieJar->setCookie($cookie);
214			}
215
216			// Save cookies to file
217			if ($cookieJar instanceof FileCookieJar) {
218			$cookieJar->save($this->getCookieFilePath($domain));
219			}
220			}
221
222			/**
223			* Extract domain from URL
224			*/
225			private function extractDomain(string $url): string
226			{
227			$parsed = parse_url($url);
228			$host = $parsed['host'] ?? '';
229
230			// Remove www. prefix if present
231			$host = preg_replace('/^www\./', '', $host);
232
233			// Map known subdomains to main domains
234			$domainMap = [
235			'straight.theater.aebn.net' => 'straight.theater.aebn.net',
236			'adultdvdempire.com' => 'adultdvdempire.com',
237			'adultdvdmarketplace.com' => 'adultdvdmarketplace.com',
238			'hotmovies.com' => 'hotmovies.com',
239			'popporn.com' => 'popporn.com',
240			];
241
242			return $domainMap[$host] ?? $host;
243			}
244
245			/**
246			* Force refresh cookies for a domain.
247			*/
248			public function refreshCookies(string $url): FileCookieJar
249			{
250			$domain = $this->extractDomain($url);
251			$cookieFile = $this->getCookieFilePath($domain);
252
253			// Clear existing cookie jar
254			if (isset($this->cookieJars[$domain])) {
255			unset($this->cookieJars[$domain]);
256			}
257
258			// Delete old cookie file if exists
259			if (file_exists($cookieFile)) {
260			unlink($cookieFile);
261			}
262
263			// Create new jar with fresh cookies
264			$this->cookieJars[$domain] = new FileCookieJar($cookieFile, true);
265			$this->setAgeVerificationCookies($domain, $this->cookieJars[$domain]);
266
267			return $this->cookieJars[$domain];
268			}
269
270			/**
271			* Get cookie file path for a domain
272			*/
273			private function getCookieFilePath(string $domain): string
274			{
275			$safeName = preg_replace('/[^a-z0-9_-]/', '_', strtolower($domain));
276
277			return $this->cookieDir.'/'.$safeName.'_cookies.json';
278			}
279
280			/**
281			* Clear cookies for a specific domain
282			*/
283			public function clearCookies(string $domain): bool
284			{
285			$cookieFile = $this->getCookieFilePath($domain);
286
287			if (file_exists($cookieFile)) {
288			unlink($cookieFile);
289			unset($this->cookieJars[$domain]);
290
291			return true;
292			}
293
294			return false;
295			}
296
297			/**
298			* Clear all stored cookies
299			*/
300			public function clearAllCookies(): int
301			{
302			$cleared = 0;
303			$files = glob($this->cookieDir.'/*_cookies.json');
304
305			foreach ($files as $file) {
306			if (unlink($file)) {
307			$cleared++;
308			}
309			}
310
311			$this->cookieJars = [];
312
313			return $cleared;
314			}
315
316			/**
317			* Get list of domains with stored cookies
318			*/
319			public function getStoredDomains(): array
320			{
321			$domains = [];
322			$files = glob($this->cookieDir.'/*_cookies.json');
323
324			foreach ($files as $file) {
325			$basename = basename($file, '_cookies.json');
326			$domain = str_replace('_', '.', $basename);
327			$domains[] = $domain;
328			}
329
330			return $domains;
331			}
332
333			/**
334			* Check if cookies exist for a domain
335			*/
336			public function hasCookies(string $domain): bool
337			{
338			$cookieFile = $this->getCookieFilePath($domain);
339
340			return file_exists($cookieFile) && filesize($cookieFile) > 10;
341			}
342
343			/**
344			* Get cookie statistics
345			*/
346			public function getCookieStats(): array
347			{
348			$stats = [
349			'total_domains' => 0,
350			'total_cookies' => 0,
351			'domains' => [],
352			];
353
354			foreach ($this->siteConfigs as $domain => $config) {
355			if ($this->hasCookies($domain)) {
356			$cookieJar = $this->getCookieJar('https://'.$domain);
357			$cookieCount = count($cookieJar);
358
359			$stats['domains'][$domain] = [
360			'has_cookies' => true,
361			'cookie_count' => $cookieCount,
362			'file' => $this->getCookieFilePath($domain),
363			];
364
365			$stats['total_domains']++;
366			$stats['total_cookies'] += $cookieCount;
367			} else {
368			$stats['domains'][$domain] = [
369			'has_cookies' => false,
370			'cookie_count' => 0,
371			];
372			}
373			}
374
375			return $stats;
376			}
377
378			/**
379			* Get the cookie directory path
380			*/
381			public function getCookieDirectory(): string
382			{
383			return $this->cookieDir;
384			}
385			}
386
387

NNTmux / newznab-tmux

Push — master ( 73c322...402528 )

AgeVerificationManager::refreshCookies() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like