Understanding Overrides

What Are Overrides?

In standard Windows environments, organizations enforce screen saver and session lock policies to automatically lock workstations after a period of inactivity. However, certain applications can temporarily override these policies—preventing the screen saver from activating and the session from locking, even when the user steps away.

These overrides are often implemented by applications that need to maintain continuous operation without interruption. While useful for legitimate business purposes, they create a significant security gap: a workstation that never locks remains vulnerable to unauthorized access indefinitely.

Lockfy Enterprise provides granular governance over these overrides, allowing security teams to control which applications can prevent session locking, for how long, and under what circumstances.

Common Applications That Implement Overrides

Many legitimate business applications use Windows APIs to temporarily prevent the screen saver from activating and the system from locking. Common examples include:

Application Category	Examples	Why They Override
Video Conferencing	Zoom, Microsoft Teams, Webex, Google Meet	Prevents screen lock during presentations, screen sharing, or active calls
Media Players	VLC, Windows Media Player, presentation software	Maintains uninterrupted playback during presentations or training sessions
Medical Imaging	PACS viewers, radiology workstations, surgical displays	Prevents session interruption during critical image review or procedures
Industrial Control	SCADA systems, HMI applications, manufacturing execution systems	Ensures continuous monitoring and control without lock interruptions
Digital Signage	Kiosk software, digital menu boards, information displays	Maintains continuous display of content without interruption
Training & Education	E-learning platforms, simulation software, exam proctoring tools	Prevents lock during tests, simulations, or training modules
Presentation Software	PowerPoint, Keynote, digital whiteboards	Ensures presentations run without interruption

The Security Risk

When an application implements an override, it effectively disables automatic session locking. The security implications include:

Risk	Impact
Unlimited Unattended Access	Workstations remain unlocked indefinitely if the user steps away while an overriding application is running
Bypass of Security Policy	Organizational screen saver and lock policies are effectively disabled
Increased Attack Surface	Attackers have extended windows of opportunity to access unlocked systems
Compliance Violations	Regulatory requirements for session timeouts may be circumvented

How Lockfy Governs Overrides

Lockfy Enterprise does not simply block overrides—it governs them. Security teams can define policies that determine:

Policy Dimension	Description
Allow by Application	Specify which applications are permitted to override lock policies (e.g., Zoom is allowed, VLC is not)
Allow by User Role	Define which user roles can utilize overrides (e.g., presenters allowed, general staff not allowed)
Time-Limited Overrides	Set maximum override duration (e.g., overrides expire after 10 minutes regardless of application)
Environment-Based Rules	Different policies for different environments (e.g., override allowed in conference rooms but not in open offices)
Override Audit Trail	Every override event is logged, including which application initiated it, which user, when, and for how long

Example Override Policy

Environment	Permitted Override Applications	Max Duration	User Roles
Conference Rooms	Zoom, Teams, PowerPoint	60 minutes	All users
Training Labs	E-learning platforms, simulation software	30 minutes	Trainers only
Open Office	None	0 minutes (overrides blocked)	All users
Control Room	SCADA, HMI applications	Unlimited	Operators only

Is it Easy to Override Lock Policies?

To the matter of fact, it is extremely easy to do so. A single line Javascript can disable Lock Policies. And this is why we built Lockfy, to manage those overrides.

// Javascript example:
wakeLock = await navigator.wakeLock.request("screen");


// C# example:
using System;
using System.Runtime.InteropServices;

class Program
{
    // Import the Windows API function
    [DllImport("kernel32.dll")]
    private static extern uint SetThreadExecutionState(uint esFlags);

    // Flags for SetThreadExecutionState
    private const uint ES_CONTINUOUS       = 0x80000000;
    private const uint ES_SYSTEM_REQUIRED  = 0x00000001;
    private const uint ES_DISPLAY_REQUIRED = 0x00000002;

    static void Main()
    {
        try
        {
            Console.WriteLine("Preventing system sleep and display off...");

            // Request wake lock: keep system and display awake
            uint result = SetThreadExecutionState(
                ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED
            );

            if (result == 0)
            {
                Console.WriteLine("Failed to set execution state.");
                return;
            }

            Console.WriteLine("Wake lock active. Press ENTER to release and exit.");
            Console.ReadLine();

            // Release wake lock (restore normal behavior)
            SetThreadExecutionState(ES_CONTINUOUS);
            Console.WriteLine("Wake lock released.");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

The Lockfy Difference

Traditional Approach	Lockfy Enterprise
Overrides are uncontrolled and invisible	Every override is governed by policy and fully visible
Security policies are completely bypassed	Policies adapt to operational needs without creating security gaps
No audit trail of when or why overrides occurred	Complete audit trail of every override event
Unlimited override duration creates indefinite risk	Time-limited overrides ensure sessions eventually lock
One-size-fits-all policy applies to all environments	Granular, context-aware policies by application and workstation

Summary

Overrides are a necessary part of many business operations—but they should not come at the expense of security. Lockfy Enterprise provides the visibility, governance, and control needed to balance operational requirements with the security imperative of protecting unattended workstations.

Ready to Protect Your Workstations?

Book a Demo

Learn how Lockfy Enterprise can provide always-on protection for your organization.