Come passare un file da un utente all'altro (senza creare alcuna copia di esso)?

Supponiamo che l'utente "qqq" abbia il file /home/qqq/bigfile.dat e vogliate passarlo all'utente "aaa" senza l'aiuto di root (deve essere di proprietà di "aaa"). Cosa dovrebbero fare gli utenti "qqq" e "aaa"?

Modo ingenuo:

1. uid=qqq$ mv bigfile.dat /home/aaa/
2. uid=aaa$ chown aaa /home/aaa/bigfile.dat # Operation not permitted

Ovviamente può essere fatto usando gli ACL ( uid=qqq$ setfacl u:aaa:rw- /home/aaa/bigfile.dat ) o facendo una copia temporanea ( uid=aaa$ mv bigfile.dat bigfile.dat_ && cat bigfile.dat_ > bigfile.dat && rm bigfile.dat_ ), ma entrambi i modi sembrano avere degli svantaggi.

Entrambi gli utenti sono d'accordo (può impartire qualche comando) a "passare" il file. Dovrebbe essere veloce, preservando inode e altri attributi ecc.

Come si fa in modo pulito?

I vecchi sistemi unix consentivano a qualsiasi utente di chownare i propri file su qualsiasi target. La maggior parte non lo fa più, perché questo ha creato alcuni problemi di sicurezza:

• Se sono presenti quote di utilizzo del disco, l'utente A potrebbe archiviare i file a spese dell'utente B inserendoli in una directory privata. L'utente B non lo saprebbe mai se non confrontando l'utilizzo del disco visibile con le quote e non avrebbe modo di trovare il ladro di quote.

• Alcuni programmi privilegiati (impostano [ug] id eseguibili o demoni) presumono che se un file è di proprietà di un utente, quell'utente ha approvato il contenuto. Se l'utente A potesse chownare un file all'utente B, A potrebbe ingannare il programma privilegiato nell'accettare qualsiasi dato. (Questo è comunque un disegno non sicuro, perché anche se A ha effettivamente scritto il file, A potrebbe non averlo approvato per questo particolare scopo, ma tali programmi esistono e proibire i chown riduce i rischi.)

• Un chown di un utente non root non può essere annullato. Attenzione, è un rischio con cui potresti vivere (e in effetti ci sono altre cose che puoi fare su un filesystem unix che può essere annullato solo se qualche altro utente collabora).

Per quanto ne so, è impossibile cambiare la proprietà di un file sulla maggior parte dei moderni sistemi Unix senza la cooperazione di root. Il root può eseguire il chown o dare a A o B il permesso di farlo tramite sudo, ma ciò richiede un intervento di root più mirato di quanto generalmente sia desiderabile.

Se gli ACL sono abilitati, come hai notato, ciò fornisce la maggior parte degli effetti pratici della chowning.

Se il flusso di lavoro richiede realmente A di essere il proprietario ad un certo punto e B di essere il proprietario in qualche altro punto, ci sono altre opzioni che potresti esplorare.

• B potrebbe usare fakeroot per eseguire un programma e fargli credere che sia eseguito come root, il che consente di simulare un chown che esiste solo nella memoria di Fakeroot ( fakeroot sh -c 'chown B file; su B -c program' ).

• Potresti giocare brutti scherzi con FUSE. Per esempio bindfs ti consente di creare una vista di un albero di directory in cui i file hanno un proprietario diverso ( mkdir view_for_B; bindfs -u B actual_directory view_for_B ).

Puoi spostare il file in uno spazio condiviso su cui entrambi gli utenti hanno accesso in scrittura (o questo tipo di cose non esiste su Linux?), E poi chiedere al proprietario chmod sul ricevitore?

La mia mentalità è radicata in Mac OS X, quindi potrebbe funzionare o meno per te.

Dipende da cosa intendi con "senza l'aiuto di root". Se puoi ottenere root per aggiungere aaa e qqq a qualche nuovo gruppo (qualsiasi nome lo farà) e assicurarti che il file abbia almeno r-- perms per il nuovo gruppo ... (può mantenere rwx per l'utente aaa - quindi tu get = & gt; aaa: newgroup rw-r -----) quindi senza FURTHER aiuto da root aaa puoi modificare e qqq può leggere lo stesso file.

Se vuoi farlo "contro i desideri di root", allora considererei un bug se hai trovato un modo che funzioni. Un sacco di pensiero è andato nell'impedire questo perché è un problema di sicurezza se aaa può mettere un trojan in una directory a cui qqq ha accesso e che potrebbe "accidentalmente" quindi eseguire.

Ok, è davvero sfacciato ma potresti fare:

aaa$ nc -l -p 12000 > bigfile.dat
qqq$ nc 127.0.0.1 12000 < bigfile.dat

O

aaa$ mkfifo /tmp/gimme
aaa$ chmod a+w /tmp/gimme
aaa$ cat /tmp/gimme > bigfile.dat
qqq$ cat bigfile.dat > /tmp/gimme

Se vuoi farlo senza spazio sufficiente per 2 copie di bigfile.dat, puoi usare split e scrivere un loop per inviare 1 chuck alla volta e poi farlo subito.

Il problema principale è che qualcun altro potrebbe fare un nc o un eco e corrompere il tuo file.

Un modo per farlo sarebbe creare un ssh-key che permetta all'utente qqq connettersi come aaa . Come qqq fare

ssh-keygen -t rsa

e decidere se si desidera andare per la chiave senza password o no.

Quindi aggiungere la chiave appena creata a aaa eseguendo questo come qqq :

ssh-copy-id -i ~/.ssh/id_rsa.pub aaa@localhost

Successivamente è possibile spostare i file in questo modo:

scp bigfile.dat aaa@localhost:

(o con il tuo client sftp preferito)

In questo modo, sshd si occuperebbe di cambiare la proprietà.

Usare scp / sftp per il trasferimento locale potrebbe sembrare strano, ma almeno questo funziona! :)