Come consentire agli utenti di trasferire file ad altri utenti su Linux

Abbiamo un ambiente di alcune migliaia di utenti che eseguono applicazioni su circa 40 cluster di dimensioni comprese tra 20 nodi di calcolo e 98.000 nodi di calcolo. Gli utenti di questi sistemi generano file di grandi dimensioni (a volte> 1 PB) controllati da autorizzazioni unix tradizionali (gli ACL di solito non sono disponibili o pratici a causa della natura specializzata del filesystem).

Al momento abbiamo un programma chiamato "give", che è un programma suid-root che consente a un utente di "dare" un file a un altro utente quando le autorizzazioni di gruppo sono insufficienti. Quindi, un utente digitare qualcosa di simile al seguente per dare un file a un altro utente:

> give username-to-give-to filename-to-give ...

L'utente ricevente può quindi utilizzare un comando chiamato "take" (parte del programma give) per ricevere il file:

> take filename-to-receive

Le autorizzazioni del file vengono quindi trasferite efficacemente all'utente ricevente.

Questo programma esiste da anni e vorremmo rivisitare le cose da un punto di vista della sicurezza e funzionale.

Il nostro attuale piano d'azione è quello di rimuovere il marcio bit nella nostra attuale implementazione di "dare" e impacchettarlo come app open source prima di ridistribuirlo in produzione.

Qualcuno ha un altro metodo che usano per trasferire file estremamente grandi tra utenti quando sono disponibili solo le autorizzazioni unix tradizionali?

Se l'emettitore è davvero disposto a distribuire il file, puoi usare un binario SUID che sposta il file in una directory che è scrivibile da tutti e ha il bit appiccicoso (come /tmp), quindi cambia la proprietà con il nuovo proprietario. chown(3)si occupa già di rimuovere i bit set-user-IDe set-group-IDper te. In questo modo il nuovo proprietario può fare ciò che vuole con il file, incluso lo spostamento.

Questa directory scrivibile da tutti può appartenere alla home directory dell'utente, nel caso in cui si desideri utilizzare più filesystem per le home directory e assicurarsi di non oltrepassare i confini del filesystem poiché le prestazioni sarebbero immediatamente terribili. In questo caso probabilmente vorrai assicurarti che il destinatario sappia quando viene offerto un nuovo file.

Le e-mail farebbero il trucco. Una soluzione più Unixy sarebbe quella /etc/profileche elenca i file appena consegnati. Aggiunto bonus se offri questa funzione con pam_echo( es. Con file=/tmp/deliveries/%u, vedi pam_echo(8)). Come per qualsiasi cosa relativa a PAM, dovresti verificare prima che tutte le tue implementazioni offrano tale modulo.

È possibile utilizzare un sistema con una directory condivisa, (possibilmente senza eseguire permanenti), in cui le cose per un determinato utente sono archiviate con una struttura di nomi di file specifica ( to-$username_from-$username.tarad esempio). Give crea il file e chownsl'utente all'utente di destinazione; take estrae il file e lo rimuove.

Se vuoi farlo come un vero spostamento (IE, modifica la posizione del file e le autorizzazioni; nessuna copia a causa della dimensione del file gigante), potresti essere in grado di cavartela con una directory condivisa con -x permanenti (quindi nessuno può elenca i file lì) e lo stesso chownmetodo. mv, chown/ mv.

Come dice xryl669, è possibile utilizzare una directory per condividere effettivamente i file. Dovrebbe sembrare come questo:

$ ls -ld shared
drwxrws--- 2 root usergroup 4096 somedate shared
$ ls -l shared
drwx-wx--- 2 user1 usergroup 4096 somedate user1
drwx-wx--- 2 user2 usergroup 4096 somedate user2
drwx-wx--- 2 user3 usergroup 4096 somedate user3
drwx-wx--- 2 user4 usergroup 4096 somedate user4

Il comando give diventa

#!/bin/sh
#Use a random suffix to prevent guessing
RANDOM=$(dd if=/dev/urandom count=4 2> /dev/null | sha512sum | cut -d' ' -f1)
NEWNAME=/path/to/shared/$2/$1$RANDOM
#Move the file
mv $1 $NEWNAME
#Make it readable
chmod 440 $NEWNAME

Il comando take assomiglia a questo:

$ cd /path/to/shared/user
$ ls
...
$ mv somefile ~

Suggerirei di riscrivere l'app per imitare davvero un "dare" e un "prendere", ma piuttosto "spingere" e "estrarre" da una directory protetta. La tua directory può essere accessibile solo per l'app push / pull, che gestisce gli spostamenti dei file. In alternativa, la tua app / script può creare una directory temporanea casuale con autorizzazioni impostate solo per il mittente e il destinatario.

Desideri avere più sicurezza? È possibile PGP crittografare / firmare il file (utilizzando la chiave pubblica del destinatario).

In termini di rifare da un "punto di vista della sicurezza e funzionale", consiglio vivamente di non creare programmi SUID. Se non elimini i privilegi in modo corretto, puoi virtualmente accedere a qualsiasi file sul sistema. Se il tuo programma è difettoso (buffer overflow, ecc ...), puoi sfruttarlo per ottenere l'accesso root sul tuo sistema.

Questo probabilmente non ti sarà utile, ma per riferimento cp - target sorgente sorgente flash esegue sottili copie di file usando copy-on-write.

Ciò significa che è possibile copiare il file in modo definitivo e che verranno effettivamente copiati solo i blocchi modificati. A differenza di un hard link, il nuovo file ha i suoi inode e metadati, il che significa che puoi quindi fornire la copia del file al nuovo utente usando robe standard.

Per quanto ne so, questa è una funzione che è attualmente disponibile solo su OCFS2 e btrfs. Immagino che risolva il tuo problema, ma poiché la sua disponibilità non è diffusa probabilmente non sarà utile.