Se capisco bene la tua domanda, il tuo problema inizia con la struttura del framework permessi/utente di Linux. Pertanto, l'utente proprietario del processo Apache è quello che crea directory e file quando esegue il tuo script.
Se hai bisogno della separazione degli utenti per gli script, ad esempio:hai directory diverse per host (virtuali) diversi sul tuo server e non vuoi che lo script di un host agisca sui dati di un host diverso sullo stesso server (apache), allora dovresti usare 'mpm_itk_module' invece del più comune apache 'mpm-prefork'.
Usando questo puoi andare e definire l'utente/gruppo che apache sta usando quando esegue qualsiasi script e ad es. crea directory solo con questo comando per ogni voce di host virtuale in httpd.conf:
<IfModule mpm_itk_module>
AssignUserId USER GROUP
</IfModule>
Se vuoi davvero creare directory diverse dall'esecuzione di UN SOLO script, hai bisogno che il processo apache sia di proprietà di root.root e quindi lo script deve impostare i permessi e i proprietari per ogni directory nel modo desiderato.
Ma non è mai una buona idea eseguire anche i migliori script su un server web come root, perché potresti non pensare a nessun rischio.
La separazione utente/diritto da parte dei vhost sembra essere un modo molto più economico a mio avviso.
Un altro punto - solo PHP - è suPHP -> http://www.suphp.org
MODIFICA:
Ok, ho dato un'occhiata al tuo sito e anche se non parlo spagnolo, sembra che tu abbia un solo sito web, che agisce per diversi utenti che passano sempre attraverso questa pagina web. Allora dov'è la necessità della separazione degli utenti sui permessi del filesystem Linux? Puoi limitare tutto dalla tua applicazione senza bisogno di utenti del filesystem. Anche se dai ad es. accesso ftp aggiuntivo - limitalo ad es. con proftpd ha il suo chroot mech per diversi utenti.
Dovresti preoccuparti dei diritti del filesystem solo se non puoi controllare chi sta eseguendo cosa. Questo è un problema comune su un host multidominio che potresti risolvere con il mpm_itk_module che ho citato.
Forse dovresti descrivere un po' di più la tua situazione?
MODIFICA 2:
Come suggerito nel commento, se usi SOLO apache per dare agli utenti l'accesso ai file per il caricamento/manipolazione, allora basta mettere i file fuori (!) dall'albero documentroot di apache e creare un semplice database per sapere quale file è di proprietà di quale utente:
user a | file parentdir/filename
Questa potrebbe essere una semplice tabella e il tuo codice php fornisce all'utente un elenco dal database di quale file è in grado di vedere/manipolare e il tuo codice fa il lavoro come previsto dall'azione dell'utente.
Finché non si concede all'utente l'accesso ai file tramite altri servizi (ftp, ssh, ecc.) NON è necessario lavorare con i diritti utente di Linux. Fai solo attenzione a posizionare i file al di fuori della documentroot del server in modo che solo il tuo codice php abbia accesso ai file tramite i diritti dell'utente apache del tuo server.
MODIFICA 3:
Haha, ora finalmente ho riscontrato il tuo problema dopo aver letto un tuo post simile:(Come può un utente Apache scrivere file quando ha i permessi per farlo?) In questo caso (con utenti DAVVERO anonimi sulla tua pagina web) NON hai alcuna possibilità di farlo risolverlo affatto. Ogni visitatore viene gestito come lo stesso senza autenticazione. E come ho ipotizzato nel mio ultimo EDIT e commentato in un post simile:non c'è bisogno di gestire i permessi dei file Linux.
LA TUA SOLUZIONE;) :Devi eseguire la manipolazione del file in una sessione con gli ID di sessione mentre l'utente sta visitando la tua pagina. Quindi il tuo codice deve gestire la relazione tra il visitatore (il session-id) e il file che ha caricato con questo session-id. Utilizzare un ID di sessione valido finché il visitatore è online è il modo migliore per farlo. E ancora - non c'è bisogno di permessi per il filesystem....;)
Il secondo modo è con utenti autenticati come suggerito in precedenza:creare una tabella db con utenti/password per accedere alla pagina Web (non al server) e un'altra tabella che contenga le relazioni utente/file. Quindi, dopo aver effettuato l'accesso alla pagina web, lavora di nuovo con le sessioni per consentire all'utente di accedere/manipolare i file già caricati.
Posso che tu esegua apache con mod_php. Quindi significa che la tua istanza PHP funziona sotto l'istanza apache e ha apache USER e GROUP. Puoi creare una cartella e cambiare il proprietario di questa cartella, ma il proprietario deve essere un utente nel tuo sistema (non apache o lo stesso utente virtuale).
Ma puoi archiviare in ogni file di directory, ad esempio ".permitions" e inserire quel file proprietario virtuale. Successivamente è necessario filtrare ogni tentativo di scrittura (eliminazione, ridenominazione, ecc...) in questa directory e confrontare l'utente virtuale e l'utente memorizzato nel file .permitions.
Classe di esempio (non completa ma è più che sufficiente per capire l'idea):
class UserDirs {
private $path='/home/vusers';
public function mkdir($user){
$d = $this->path.'/'.md5($user);
mkdir($d);
file_put_contents($d."/.owner",$user);
}
public function checkOwner($user, $dirname){
$f = $dirname."/.owner";
$virtual_owner = file_get_contents($f);
return $user === $virtual_owner;
}
}
$d = new UserDirs()
$d->mkdir("foo","bar");
echo $d->checkOwner("foo1","bar") === true ? "OK":"FAIL";
echo $d->checkOwner("foo","bar") === true ? "OK":"FAIL";
Puoi incapsulare tutto ciò di cui hai bisogno in questa classe per lavorare con UserDirs ed estendere la classe in base alle tue esigenze.
I tuoi utenti non hanno account di sistema. Probabilmente non è nemmeno possibile creare quegli account. Pertanto, consiglierei di gestire tutto questo tramite l'interfaccia utente Web.
Continua a creare le tue directory così come sei. I permessi vanno bene. Tuttavia, la tua interfaccia utente deve cambiare, per mostrare solo la directory o i file di quell'utente. Presumo tu abbia un database associato a questa pagina. Associa i nomi utente e il nome della directory generato casualmente con l'utente. Se qualcuno tenta di accedere al percorso diretto e NON è l'utente associato a quella directory, riportalo alla schermata di accesso.
Per illustrare, ho creato un account chiamato test e presumibilmente gli è stata assegnata una directory univoca. Se mi disconnetto, non dovrei essere in grado di visitare quella directory perché il tuo codice lo vedrebbe
- Non sono loggato e quindi non ho accesso a quella directory
Se dovessi accedere come test2 e visita la directory di test , il tuo codice dovrebbe vederlo
- Non sono il proprietario della directory visitata e quindi dovrei essere reindirizzato come appropriato.
È necessario aggiungere una funzione che controlli la directory visitata dall'utente e la confronti con la directory associata all'utente. Se i due corrispondono, consenti loro di procedere. Se non corrispondono, reindirizza l'utente.