// ==UserScript==

// @name Enhanced Fake Camera for VFS Global (Anti-Detection)

// @namespace [Link]

// @version 3.0

// @description Replaces real camera with photo or video with enhanced anti-detection measures

// @author Original: Brazuca! (Modified for anti-detection)

// @match [Link]

// @match [Link]

// @grant none

// ==/UserScript==

(function() {

'use strict';

// ==================== STATE VARIABLES ====================

let cameraActive = false;

let mediaURL = null;

let videoStream = null;

let canvas = null;

let animationFrameId = null;

let videoElement = null;

let isPaused = false;

// ==================== ADVANCED MOCK VARIABLES ====================

// Store original methods to restore later

 const originalGetUserMedia = [Link];

const originalEnumerateDevices = [Link];

const originalMediaStreamTrack = [Link];

// Mock camera device info

const mockCameraDeviceId = 'mock-camera-' + [Link]().toString(36).substring(2, 15);

const mockCameraGroupId = 'mock-group-' + [Link]().toString(36).substring(2, 15);

const mockCameraLabel = ['HD Webcam', 'USB Camera', 'Integrated Camera']

[[Link]([Link]() * 3)];

// Zoom control variables

let zoomLevel = 1.0;

const zoomIncrement = 0.1;

const maxZoom = 3.0;

const minZoom = 0.5;

// Position control variables

let offsetX = 0;

let offsetY = 0;

// Reference to UI elements

let zoomContainer = null;

let pauseContainer = null;

let pauseButton = null;

let zoomInButton = null;

let zoomOutButton = null;

let zoomCounter = null;

let directionContainer = null;

// ==================== HELPER FUNCTIONS ====================

function createElement(tagName, styles) {

const element = [Link](tagName);

[Link]([Link], styles);

return element;

// Generate a random but realistic camera device ID

function generateMockDeviceId() {

return 'mock-camera-' + [Link]().toString(36).substring(2, 15);

// Function to create realistic camera constraints

function createRealisticConstraints(constraints) {

// Preserve the original constraints where possible

let result = { ...constraints };

// Add realistic video constraints if not already specified

if (![Link] || typeof [Link] === 'boolean') {

[Link] = {

width: { ideal: 1280, min: 640, max: 1920 },

height: { ideal: 720, min: 480, max: 1080 },

 frameRate: { ideal: 30, min: 15 },

facingMode: "user"

};

} else if (typeof [Link] === 'object') {

// Enhance existing video constraints

[Link] = {

...[Link],

deviceId: { exact: mockCameraDeviceId },

frameRate: [Link] || { ideal: 30, min: 15 }

};

return result;

// ==================== MOCK IMPLEMENTATION ====================

async function activateFakeCamera(url, isPhoto = false) {

// Clear previous state

if (cameraActive) {

deactivateFakeCamera();

try {

// Reset zoom and position

zoomLevel = 1.0;
offsetX = 0;

offsetY = 0;

isPaused = false;

mediaURL = url;

canvas = [Link]('canvas');

[Link] = 1280; // Higher resolution for better quality

[Link] = 720; // 16:9 aspect ratio

let ctx = [Link]('2d', { alpha: false, desynchronized: true });

[Link] = true;

[Link] = 'high';

if (isPhoto) {

// Handle photo with quality preservation

let image = new Image();

[Link] = "anonymous";

[Link] = url;

await new Promise((resolve, reject) => {

[Link] = resolve;

[Link] = reject;

setTimeout(() => reject(new Error("Timeout loading image")), 8000);

});
// Calculate ratio to preserve aspect

const ratio = [Link](

[Link] / [Link],

[Link] / [Link]

);

const newWidth = [Link] * ratio;

const newHeight = [Link] * ratio;

// Center image on canvas

const x = ([Link] - newWidth) / 2;

const y = ([Link] - newHeight) / 2;

// Clear canvas with black background

[Link] = '#000';

[Link](0, 0, [Link], [Link]);

// Draw image with high quality

[Link](image, x, y, newWidth, newHeight);

// For photos, create a stream with minimal frames (static image)

videoStream = [Link](5);

// Update UI controls

updateZoomControls(true);
 updatePauseButton(true);

} else {

// Handle video with proper playback

videoElement = [Link]('video');

[Link] = url;

[Link] = true;

[Link] = true;

[Link] = true;

[Link] = true;

[Link] = "anonymous";

// Apply additional attributes to make video seem more realistic

[Link] = 0;

[Link] = () => {

// Adjust canvas dimensions to match video if needed

if ([Link] && [Link]) {

// Keep aspect ratio but maintain quality

const aspectRatio = [Link] / [Link];

if (aspectRatio > 1) {

// Landscape video

[Link] = [Link](1280, [Link]);

[Link] = [Link] / aspectRatio;

} else {

// Portrait or square video

 [Link] = [Link](720, [Link]);

[Link] = [Link] * aspectRatio;

};

try {

await [Link]();

} catch (e) {

[Link]("Warning starting video playback:", e);

// Continue despite error - may be autoplay policy

// Function to draw video frames with zoom and positioning

function drawFrame() {

if (!canvas || !ctx || !videoElement) return;

if ([Link] && [Link]) {

// Calculate base dimensions preserving aspect ratio

const ratio = [Link](

[Link] / [Link],

[Link] / [Link]

);

const baseWidth = [Link] * ratio;

const baseHeight = [Link] * ratio;

// Apply zoom

const scaledWidth = baseWidth * zoomLevel;

const scaledHeight = baseHeight * zoomLevel;

// Calculate centered position with zoom and offset

const baseX = ([Link] - baseWidth) / 2;

const baseY = ([Link] - baseHeight) / 2;

// Offset adjusted for zoom

const x = baseX - ((scaledWidth - baseWidth) / 2) + offsetX;

const y = baseY - ((scaledHeight - baseHeight) / 2) + offsetY;

// Clear with black background

[Link] = '#000';

[Link](0, 0, [Link], [Link]);

// Draw the video frame with applied transformations

[Link](videoElement, x, y, scaledWidth, scaledHeight);

// Update zoom counter if present

if (zoomCounter) {

[Link] = `Zoom: ${[Link](1)}x`;

}
 } else {

// Fallback if video dimensions aren't available

[Link](videoElement, 0, 0, [Link], [Link]);

// Continue animation loop

animationFrameId = requestAnimationFrame(drawFrame);

// Start drawing frames

drawFrame();

// Create stream with higher framerate for smoother video

videoStream = [Link](30);

// Enable UI controls

updateZoomControls(false);

updatePauseButton(false);

// Add realistic tracks metadata to the stream

enhanceStreamWithRealisticTracks(videoStream);

// Override getUserMedia with our enhanced mock implementation

overrideMediaAPIs();
 cameraActive = true;

updateButtons();

[Link](isPhoto ? "Fake photo activated!" : "Fake camera activated!");

} catch (error) {

[Link]("Error activating fake media:", error);

alert("Error loading media. Check the selected file or try a smaller file.");

// Clean up in case of error

deactivateFakeCamera();

function enhanceStreamWithRealisticTracks(stream) {

if (!stream || ![Link] || [Link]().length === 0) return;

// Get the actual video track

const videoTrack = [Link]()[0];

// Add realistic properties to the track

if (videoTrack) {

// Store original methods to be used in our mocked ones

const originalGetSettings = [Link];

const originalGetCapabilities = [Link];

const originalGetConstraints = [Link];

const originalApplyConstraints = [Link];

// Override getSettings to return realistic camera settings

[Link] = function() {

// Start with original settings if available

let settings = {};

try {

settings = [Link](this);

} catch (e) {

// Ignore errors from original method

// Add realistic camera settings

return {

...settings,

deviceId: mockCameraDeviceId,

groupId: mockCameraGroupId,

aspectRatio: [Link] / [Link],

frameRate: 30,

height: [Link],

width: [Link],

resizeMode: "none",

facingMode: "user"

};
};

// Override getCapabilities with realistic camera capabilities

[Link] = function() {

let capabilities = {};

try {

capabilities = [Link](this);

} catch (e) {

// Ignore errors

return {

...capabilities,

deviceId: mockCameraDeviceId,

aspectRatio: {min: 0.5, max: 2.0},

frameRate: {min: 10, max: 60},

height: {min: 240, max: 1080, step: 1},

width: {min: 320, max: 1920, step: 1},

facingMode: ["user", "environment"]

};

};

// Override getConstraints to return fake constraints

[Link] = function() {

let constraints = {};

 try {

constraints = [Link](this);

} catch (e) {

// Ignore errors

return {

...constraints,

deviceId: {exact: mockCameraDeviceId},

aspectRatio: {ideal: [Link] / [Link]},

frameRate: {ideal: 30},

height: {ideal: [Link]},

width: {ideal: [Link]},

facingMode: "user"

};

};

// Override applyConstraints to make it appear to work

[Link] = async function(constraints) {

try {

// Try original method first

return await [Link](this, constraints);

} catch (e) {

// Just return success - we're faking it anyway

return [Link]();
 }

};

// Override label and id with realistic values

[Link](videoTrack, {

'label': {

get: function() { return mockCameraLabel; },

configurable: true

},

'id': {

get: function() { return mockCameraDeviceId + '-track'; },

configurable: true

},

'kind': {

get: function() { return 'video'; },

configurable: true

},

'enabled': {

get: function() { return true; },

set: function(value) { /* Do nothing */ },

configurable: true

},

'muted': {

get: function() { return false; },

configurable: true
 },

'readyState': {

get: function() { return 'live'; },

configurable: true

});

function overrideMediaAPIs() {

// Override getUserMedia to return our fake stream

[Link] = async function(constraints) {

// If camera is not active or constraints explicitly request something other than video,

// fallback to original implementation

if (!cameraActive || (constraints && [Link] && ![Link])) {

return [Link](this, constraints);

// Apply realistic constraints to make the mocked stream look more legitimate

const enhancedConstraints = createRealisticConstraints(constraints);

[Link]("Enhanced constraints:", enhancedConstraints);

// Return our fake video stream

return new Promise((resolve) => {

resolve(videoStream);
 });

};

// Override enumerateDevices to include our fake camera

[Link] = async function() {

try {

// Get the real devices first

const realDevices = await [Link](this);

// If camera is not active, just return real devices

if (!cameraActive) {

return realDevices;

// Filter out any existing video devices that might conflict with ours

const nonVideoDevices = [Link](device => [Link] !== 'videoinput');

// Create our fake device

const fakeCamera = {

deviceId: mockCameraDeviceId,

groupId: mockCameraGroupId,

kind: 'videoinput',

label: mockCameraLabel,

toJSON: function() {

return {
 deviceId: [Link],

groupId: [Link],

kind: [Link],

label: [Link]

};

};

// Add our fake camera to the list

return [...nonVideoDevices, fakeCamera];

} catch (e) {

[Link]("Error in enumerateDevices:", e);

// Fallback to original implementation in case of error

return [Link](this);

};

function deactivateFakeCamera() {

// Stop animation frame if active

if (animationFrameId) {

cancelAnimationFrame(animationFrameId);

animationFrameId = null;

}
// Restore original media APIs

[Link] = originalGetUserMedia;

[Link] = originalEnumerateDevices;

// Clean up resources

if (mediaURL && [Link]('blob:')) {

try {

[Link](mediaURL);

} catch(e) {

[Link]("Error revoking URL:", e);

// Reset state variables

mediaURL = null;

videoStream = null;

canvas = null;

videoElement = null;

isPaused = false;

cameraActive = false;

// Update UI

updateButtons();

updateZoomControls(true);

updatePauseButton(true);
 [Link]("Fake camera deactivated!");

// ==================== UI CONTROL FUNCTIONS ====================

function updateButtons() {

if (!videoButton || !photoButton) return;

if (cameraActive) {

[Link] = '🔴 Disable Media';

[Link] = 'red';

[Link] = '🚫 Import Media';

[Link] = 'gray';

[Link] = true;

} else {

[Link] = '🎥 Activate Video';

[Link] = 'green';

[Link] = ' Import Photo';

[Link] = 'blue';

[Link] = false;

}
function togglePause() {

if (!videoElement) return;

if (isPaused) {

[Link]();

[Link] = ' Pause';

[Link] = "Pause video";

} else {

[Link]();

[Link] = '▶️Play';

[Link] = "Play video";

isPaused = !isPaused;

function updatePauseButton(hide) {

if (!pauseContainer) return;

[Link] = hide ? 'none' : 'flex';

// Reset pause button state

if (!hide && pauseButton) {

isPaused = false;

[Link] = ' Pause';

 [Link] = "Pause video";

function updateZoomControls(hide) {

if (!zoomContainer) return;

[Link] = hide ? 'none' : 'flex';

if (directionContainer) {

[Link] = hide ? 'none' : 'flex';

function adjustZoom(increment) {

// Adjust zoom level with limits

const newZoom = [Link](maxZoom, [Link](minZoom, zoomLevel + increment));

// Only update if there's a real change

if (newZoom !== zoomLevel) {

zoomLevel = newZoom;

// Reset offset when returning to normal zoom

if ([Link](zoomLevel - 1.0) < 0.05) {

offsetX = 0;

offsetY = 0;

}
 }

// ==================== UI CREATION FUNCTIONS ====================

function createDirectionControls() {

const container = createElement('div', {

display: 'flex',

flexDirection: 'column',

alignItems: 'center',

gap: '5px',

marginTop: '10px'

});

// Up button

const upButton = createElement('button', {

padding: '5px 10px',

backgroundColor: '#444',

color: 'white',

border: 'none',

borderRadius: '5px',

cursor: 'pointer',

margin: '0',

fontWeight: 'bold',

width: '30px',

textAlign: 'center'
});

[Link] = '↑';

[Link] = "Move up";

[Link]('click', () => { offsetY += 10; });

// Horizontal buttons container

const horizontalContainer = createElement('div', {

display: 'flex',

gap: '15px',

alignItems: 'center'

});

// Left button

const leftButton = createElement('button', {

padding: '5px 10px',

backgroundColor: '#444',

color: 'white',

border: 'none',

borderRadius: '5px',

cursor: 'pointer',

margin: '0',

fontWeight: 'bold',

width: '30px',

textAlign: 'center'

});
[Link] = '←';

[Link] = "Move left";

[Link]('click', () => { offsetX += 10; });

// Center button

const centerButton = createElement('button', {

padding: '5px 10px',

backgroundColor: '#555',

color: 'white',

border: 'none',

borderRadius: '5px',

cursor: 'pointer',

margin: '0',

fontWeight: 'bold',

width: '30px',

textAlign: 'center'

});

[Link] = '⊙';

[Link] = "Reset position";

[Link]('click', () => {

offsetX = 0;

offsetY = 0;

});

// Right button
const rightButton = createElement('button', {

padding: '5px 10px',

backgroundColor: '#444',

color: 'white',

border: 'none',

borderRadius: '5px',

cursor: 'pointer',

margin: '0',

fontWeight: 'bold',

width: '30px',

textAlign: 'center'

});

[Link] = '→';

[Link] = "Move right";

[Link]('click', () => { offsetX -= 10; });

// Down button

const downButton = createElement('button', {

padding: '5px 10px',

backgroundColor: '#444',

color: 'white',

border: 'none',

borderRadius: '5px',

cursor: 'pointer',

margin: '0',
 fontWeight: 'bold',

width: '30px',

textAlign: 'center'

});

[Link] = '↓';

[Link] = "Move down";

[Link]('click', () => { offsetY -= 10; });

// Assemble horizontal container

[Link](leftButton);

[Link](centerButton);

[Link](rightButton);

// Assemble direction container

[Link](upButton);

[Link](horizontalContainer);

[Link](downButton);

[Link] = 'none'; // Hidden initially

return container;

function createControlPanel() {

// Create main container

const controlPanel = createElement('div', {

 position: 'fixed',

bottom: '10px',

right: '10px',

backgroundColor: 'rgba(0, 0, 0, 0.7)',

padding: '10px',

borderRadius: '5px',

zIndex: '9999',

color: 'white',

fontFamily: 'Arial, sans-serif',

fontSize: '14px',

boxShadow: '0 0 10px rgba(0, 0, 0, 0.5)',

display: 'flex',

flexDirection: 'column',

gap: '10px'

});

// Title

const title = createElement('div', {

fontWeight: 'bold',

textAlign: 'center',

borderBottom: '1px solid #555',

paddingBottom: '5px',

marginBottom: '5px'

});

[Link] = 'Camera Controls';

// Container for video and photo buttons

const mediaButtonsContainer = createElement('div', {

display: 'flex',

gap: '5px',

justifyContent: 'center'

});

// Video button

const videoButton = createElement('button', {

padding: '8px 12px',

backgroundColor: 'green',

color: 'white',

border: 'none',

borderRadius: '5px',

cursor: 'pointer',

flex: '1'

});

[Link] = '🎥 Activate Video';

[Link] = "Select and activate a video file";

[Link]('click', handleVideoButtonClick);

// Photo button

const photoButton = createElement('button', {

padding: '8px 12px',

 backgroundColor: 'blue',

color: 'white',

border: 'none',

borderRadius: '5px',

cursor: 'pointer',

flex: '1'

});

[Link] = ' Import Photo';

[Link] = "Select and use a photo";

[Link]('click', handlePhotoButtonClick);

// Add file input (hidden)

const fileInput = createElement('input', {

display: 'none',

type: 'file'

});

[Link] = 'file';

[Link] = 'image/*,video/*';

// Zoom controls container

zoomContainer = createElement('div', {

display: 'none', // Hidden initially

flexDirection: 'row',

gap: '5px',

alignItems: 'center',
 justifyContent: 'center'

});

// Zoom out button

zoomOutButton = createElement('button', {

padding: '5px 10px',

backgroundColor: '#444',

color: 'white',

border: 'none',

borderRadius: '5px',

cursor: 'pointer',

fontWeight: 'bold'

});

[Link] = '➖';

[Link] = "Zoom out";

[Link]('click', () => adjustZoom(-zoomIncrement));

// Zoom counter

zoomCounter = createElement('span', {

minWidth: '80px',

textAlign: 'center'

});

[Link] = 'Zoom: 1.0x';

// Zoom in button
zoomInButton = createElement('button', {

padding: '5px 10px',

backgroundColor: '#444',

color: 'white',

border: 'none',

borderRadius: '5px',

cursor: 'pointer',

fontWeight: 'bold'

});

[Link] = '➕';

[Link] = "Zoom in";

[Link]('click', () => adjustZoom(zoomIncrement));

// Pause controls container

pauseContainer = createElement('div', {

display: 'none', // Hidden initially

justifyContent: 'center'

});

// Pause/play button

pauseButton = createElement('button', {

padding: '5px 10px',

backgroundColor: '#444',

color: 'white',

border: 'none',
 borderRadius: '5px',

cursor: 'pointer',

width: '100%'

});

[Link] = ' Pause';

[Link] = "Pause video";

[Link]('click', togglePause);

// Create direction controls

directionContainer = createDirectionControls();

// Close button (X in top right corner)

const closeButton = createElement('button', {

position: 'absolute',

top: '5px',

right: '5px',

background: 'none',

border: 'none',

color: 'white',

cursor: 'pointer',

fontSize: '16px',

padding: '0',

margin: '0',

lineHeight: '1'

});
[Link] = '×';

[Link] = "Hide controls";

[Link]('click', () => {

[Link] = 'none';

});

// Minimize button (to show when control panel is hidden)

const minimizeButton = createElement('button', {

position: 'fixed',

bottom: '10px',

right: '10px',

backgroundColor: 'rgba(0, 0, 0, 0.7)',

color: 'white',

border: 'none',

borderRadius: '5px',

padding: '5px 10px',

cursor: 'pointer',

zIndex: '9998',

display: 'none'

});

[Link] = '📷';

[Link] = "Show camera controls";

[Link]('click', () => {

[Link] = 'flex';

[Link] = 'none';
});

// When control panel is closed, show minimize button

[Link]('click', () => {

[Link] = 'block';

});

// Add event listener for file selection

[Link]('change', handleFileSelect);

// Assemble zoom container

[Link](zoomOutButton);

[Link](zoomCounter);

[Link](zoomInButton);

// Assemble pause container

[Link](pauseButton);

// Assemble media buttons

[Link](videoButton);

[Link](photoButton);

// Assemble control panel

[Link](closeButton);

[Link](title);
 [Link](mediaButtonsContainer);

[Link](zoomContainer);

[Link](pauseContainer);

[Link](directionContainer);

[Link](fileInput);

// Add both elements to the document

[Link](controlPanel);

[Link](minimizeButton);

// Store references to elements

[Link] = videoButton;

[Link] = photoButton;

[Link] = fileInput;

// ==================== EVENT HANDLERS ====================

function handleVideoButtonClick() {

if (cameraActive) {

deactivateFakeCamera();

} else {

[Link]('accept', 'video/*');

[Link]();

}
function handlePhotoButtonClick() {

[Link]('accept', 'image/*');

[Link]();

function handleFileSelect(event) {

const file = [Link][0];

if (!file) return;

// Clear the input value so the same file can be selected again

[Link] = '';

const isPhoto = [Link]('image/');

const url = [Link](file);

activateFakeCamera(url, isPhoto);

// ==================== KEYBOARD SHORTCUTS ====================

function setupKeyboardShortcuts() {

[Link]('keydown', (event) => {

// Only if camera is active

if (!cameraActive) return;
switch([Link]) {

case '+':

case '=': // For keyboards where + requires Shift

adjustZoom(zoomIncrement);

break;

case '-':

adjustZoom(-zoomIncrement);

break;

case ' ': // Space bar

if (videoElement) togglePause();

break;

case 'ArrowUp':

offsetY += 10;

break;

case 'ArrowDown':

offsetY -= 10;

break;

case 'ArrowLeft':

offsetX += 10;

break;

case 'ArrowRight':

offsetX -= 10;

break;

case '0': // Reset zoom and position

zoomLevel = 1.0;
 offsetX = 0;

offsetY = 0;

break;

});

// ==================== INITIALIZATION ====================

function init() {

// Create control panel when page is loaded

createControlPanel();

// Setup keyboard shortcuts

setupKeyboardShortcuts();

[Link]("Enhanced Fake Camera for VFS Global initialized!");

// Initialize when DOM is loaded

if ([Link] === 'loading') {

[Link]('DOMContentLoaded', init);

} else {

init();

})();