☰

Gemeinsam genutzte Zwischenablage zwischen mehreren X11-Servern (Xephyr, Xpra usw.)

tag-icon • tag-icon x11 clipboard xpra xephyr
Gemeinsam genutzte Zwischenablage zwischen mehreren X11-Servern (Xephyr, Xpra usw.)

Ich plane, potenziell gefährliche Anwendungen auszuführen(Browser usw.)auf einem separaten X-Server, aber da jeder Server seine eigene Zwischenablage hat, ist es unmöglich, den Link/Text von einem Fenster in ein anderes zu kopieren.

In den meisten Artikeln wird empfohlen, hierfür Skripte mit xclip und anderen ähnlichen Dienstprogrammen zu verwenden.

Aber wieKORREKTeine gemeinsame Zwischenablage erstellen, um nicht versehentlich eine neue Sicherheitslücke zu schaffen?

Antwort1

HINWEIS: Ich aktualisiere die Antwort, um die Strategieänderung widerzuspiegeln – anstatt Xephyr auf einem Server/Container auszuführen, führe ich es in einer Host-/Hauptnutzungsumgebung aus. Der Grund dafür ist, dass das Ausführen von Xephyr auf dem Server/Container so ist, als würde man ein Schloss an einer Innentür statt an der Vordertür anbringen – böswillige Akteure würden um die Innentür herumgehen und direkt über den X-Pipe-Remote-Socket auf die Zwischenablage zugreifen.

Da ich mit dem gleichen Problem der Zwischenablage-Sicherheitslücke konfrontiert war, habe ich es gelöst, indem ich auf dem Host (meinem persönlichen Arbeitsbereich) einen Xephyr ausgeführt und X von den Server-on-Containern an den lokalen Xephyr weitergeleitet habe.

Xephyr läuft auf dem Display ':2', während meine persönlichen Arbeitsbereichsfenster und mein Browser auf dem Standarddisplay ':0' laufen. Diese beiden Displays teilen sich keine Zwischenablage – jedes hat seine eigene Zwischenablage. Nur so kann ich verhindern, dass meine persönliche Arbeitsbereichszwischenablage auf dem Display ':0' ausspioniert wird. Dann habe ich Hotkeys eingerichtet (z. B. Funktionstasten), eine zum Übertragen des Zwischenablageinhalts von ':0' nach ':2' und eine andere für ':2' nach ':0', was vollständige Kontrolle ermöglicht.

In einem Shell-Skript könnte der Code so aussehen

xsel --display :0 --clipboard -o |  xsel --display :2 --clipboard -i

obwohl ich Javascript verwende, wie unten in diesem Beitrag gezeigt.

Ein Shell-Skript zum Starten der X-Weiterleitung könnte etwa so aussehen

Xephyr <args> :2
DISPLAY=:2 ssh -X -R 44713:localhost:4713 user@container <<EOF
DISPLAY=:10 PULSE_SERVER=tcp:localhost:44713 openbox --startup firefox
EOF

obwohl ich dazu ein Javascript-Programm verwende.

Hier ist der JavaScript-Code zum Kopieren zwischen ':0' und ":2", der durch Hotkeys zugeordnet ist. Sie können sehen, dass ein vorübergehendes Meldungsfeld angezeigt wird, um zu bestätigen, dass es funktioniert hat.

#!/usr/bin/env node
`strict`;
const child_process = require('child_process');

// TODO: write unviewable error messasges to system log

function notifySend(title, msg){
  title = title.replace(/"/g, '\\"');
  msg = msg.replace(/"/g, '\\"');
  //msg = msg.replace(/'/g, '\\'')
  try {
    child_process.execSync(`notify-send "${title}" "${msg}"`);
  } catch(e) {
    console.log(`system call "notify-send" failed with ${e.message}`);
  }
}

async function clipXfer(fromDispNum,toDispNum){
  var clipValue;
  let cmd1 = `xsel --display :${fromDispNum} --clipboard --output`;
  let cmd2 = `xsel --display :${toDispNum} --clipboard --input`;
  try {
    clipValue = child_process.execSync(cmd1, { encoding: 'utf-8' });
  } catch(e) {
    throw Error(`Display ${fromDispNum} clipboard is empty`);
  }
  await new Promise((resolve, reject)=>{        
    // eslint-disable-next-line no-unused-vars
    var proc = child_process.exec(cmd2, (error, stdout, stderr) => {
      //if (stdout) console.log(stdout);
      //if (stderr) console.log(stderr);
      if (error) {
        reject(Error(`${error.message}`));
      }
      resolve();
    });
    if (!proc.stdin.write(clipValue))
      reject(Error('clipToCont(), pipe write failed'));
    proc.stdin.end();
  });                    
}


async function main()
{
  let argOff=2;
  if (process.argv.length-argOff<2)
    throw Error('clip-xfer requires two arguments: fromDispNum, toDispNum');
  let fromDispNum = process.argv[argOff];
  let toDispNum = process.argv[argOff+1];
  argOff+=2;
  let f = (outcome)=>{
    notifySend("clipXfer",  `${fromDispNum} => ${toDispNum} ${outcome}`);
  }; 
  await clipXfer(fromDispNum,toDispNum)
    .then(f('SUCCESS'))
    .catch((e)=>{f(`FAILURE, ${e.message}`); throw e;});
}

//console.log(process.argv);
//console.log(process.env);
main()
  .then(()=>{process.exitCode=0;})
  .catch((e)=>{
    console.log(e);
    process.exitCode=1;
  });

Antwort2

ich benutzeAbonnieren. In 98 % der Fälle funktioniert es. In 2 % mache ich Folgendes:

Auf dem Display: 0 laufenkopierenq. Auf dem Display: 1 LaufParzellit. Zum Synchronisieren der Zwischenablage verwende ich

copyq add $(parcellite)

oder nach hinten

copyq read | parcellite -c

Es funktioniert 100%! :-)

verwandte Informationen