捕获ALT+TAB事件：全屏锁屏窗口防切换技术咨询

Alright, let's dig into fixing this ALT+TAB bypass issue with your lock screen on RHEL6 running FVWM. The problem here is that ALT+TAB is handled at two layers: the window manager (FVWM) itself, and your application's event pipeline. Let's break down the solutions step by step to make sure your lock screen stays secure.

Since FVWM controls the window switching logic, disabling its ALT+TAB binding while the lock screen is up is the most direct way to prevent switching. Here's how to do it:

• First, locate your FVWM config file—on RHEL6 this is usually ~/.fvwm2rc or /etc/fvwm/config.
• Check your current ALT+TAB binding by running:

  fvwm-command "Show KeyBindings"
  

  You'll likely see something like this (the exact syntax depends on your setup):

  Key Tab A M WindowList Root c c NoDeskSort, CurrentDesk
  

• When your lock screen starts, use fvwm-command to overwrite this binding with a "no-op" (empty action):

  fvwm-command "Key Tab A M nop"
  

  Adjust the modifiers (A M) to match your actual binding—A stands for Alt, M for Meta/Modifier.
• Once the user authenticates and the lock screen closes, restore the original binding:

  fvwm-command "Key Tab A M WindowList Root c c NoDeskSort, CurrentDesk"
  

• Make sure your application has permission to run fvwm-command—it should work for the user running the app, since FVWM is their session manager.

Even if you handle the WM level, adding app-level capture acts as a fallback. wxWidgets lets you globally filter events before they reach the window manager:

• Override wxApp::FilterEvent in your application class to catch the ALT+TAB combo:

  bool MyApp::FilterEvent(wxEvent& event)
  {
      if (event.GetEventType() == wxEVT_KEY_DOWN)
      {
          wxKeyEvent& keyEvent = static_cast<wxKeyEvent&>(event);
          // Catch Alt+Tab
          if (keyEvent.AltDown() && keyEvent.GetKeyCode() == WXK_TAB)
          {
              // Consume the event so it never reaches FVWM
              return true;
          }
      }
      // Let all other events pass through normally
      return false;
  }
  

• Configure your lock window to stay on top, be fullscreen, and grab exclusive keyboard focus:

  MyLockWindow::MyLockWindow() 
      : wxFrame(nullptr, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, 
                wxFRAME_NO_TASKBAR | wxFRAME_SHAPED | wxSTAY_ON_TOP)
  {
      ShowFullScreen(true, wxFULLSCREEN_ALL);
      SetFocus();
      Raise();
      // Grab all keyboard input to this window
      GrabKeyboard();
  }
  

• Don't forget to release the keyboard grab when the lock screen closes:

  MyLockWindow::~MyLockWindow()
  {
      ReleaseKeyboard();
  }
  

If your lock screen is built with Qt, use similar global event filtering and focus grabbing:

• Create a custom event filter to catch Alt+Tab:

  class LockScreenEventFilter : public QObject
  {
      Q_OBJECT
  protected:
      bool eventFilter(QObject* obj, QEvent* event) override
      {
          if (event->type() == QEvent::KeyPress)
          {
              QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
              if ((keyEvent->modifiers() & Qt::AltModifier) && 
                  keyEvent->key() == Qt::Key_Tab)
              {
                  // Eat the event so FVWM never sees it
                  return true;
              }
          }
          return QObject::eventFilter(obj, event);
      }
  };
  

• Install the filter in your app's main function:

  int main(int argc, char* argv[])
  {
      QApplication app(argc, argv);
      LockScreenEventFilter filter;
      app.installEventFilter(&filter);
      
      // Launch your lock screen window
      MyLockWindow lockWindow;
      lockWindow.show();
      
      return app.exec();
  }
  

• Configure the Qt lock window to be fullscreen, topmost, and grab keyboard focus:

  MyLockWindow::MyLockWindow(QWidget* parent) 
      : QWidget(parent, Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint)
  {
      showFullScreen();
      setFocus(Qt::ActiveWindowFocusReason);
      grabKeyboard();
  }
  

• Release the keyboard grab when the window closes:

  MyLockWindow::~MyLockWindow()
  {
      releaseKeyboard();
  }
  

For maximum reliability, combine both the FVWM-level binding override and app-level event capture:

1. When the lock screen activates:
   • Call fvwm-command to disable ALT+TAB
   • Grab keyboard focus in your wxWidgets/Qt window
2. When the user authenticates successfully:
   • Restore the original FVWM ALT+TAB binding
   • Release the keyboard grab
   • Close the lock screen

This way, if one layer fails (e.g., fvwm-command doesn't run for some reason), the app-level capture will still block ALT+TAB.

• If FVWM commands aren't working, verify the path to fvwm-command—it's usually in /usr/bin/ on RHEL6.
• For wxGTK, if GrabKeyboard() doesn't work, try calling SetAlwaysOnTop(true) in addition to wxSTAY_ON_TOP.
• For Qt, if the window isn't staying on top, add Qt::X11BypassWindowManagerHint to the window flags (note this disables some WM features, so test carefully).
• Always test both scenarios: launching the lock screen from a terminal, and trying to ALT+TAB out—make sure neither works.

内容的提问来源于stack exchange，提问作者Igor