Michele Liberi software

versione 1.04, giugno 2026

Michele Liberi
mail: mliberi@gmail.com
cell: +393485211456
telegram: @MicheleLiberi

rxc, esecuzione remota di comandi

Il comando rxc permette di lanciare un comando su un computer remoto raggiungibile via TCP/IP.

La comunicazione tra rxc ed rxs può anche avvenire attraverso un tunnel ssh/sshd, in base al seguente schema.

Al costo di un leggero degrado di prestazioni abbiamo il vantaggio che la comunicazione avviene su una porta standard ed utilizzando un servizio standard, il che permette di superare eventuali problemi introdotti dai firewall.

Un unico tunnel ssh/sshd può essere utilizzato per multiple istanze di rxc/rxs, è può funzionare con un utente non provilegiato.

Il file /etc/rxc.conf può essere usato per definire degli hostname virtuali. Ogni riga deve contenere almeno tre token:

parola chiave alias
hostname virtuale
hostname o indirizzo IP fisico
(opzionale) porta di connessione

Il comando rxc funziona in modo analogo ai comandi rsh e ssh, ma con importanti differenze:

La prima, importantissima, differenza è che il comando remoto viene lanciato direttamente e non all'interno di una shell, il che semplifica notevolmente la vita perché il comando non viene valutato prima di essere eseguito con importanti semplificazioni in termini di quoting. Nulla impedisce, ovviamente, che il comando eseguito remotamente sia proprio una shell.
Esempio 1: esecuzione diretta di un comando
```
rxc -Hserver ls /tmp
```
Esempio 2: esecuzione di un comando all'interno di una shell
```
rxc -Hserver sh -c 'ls /tmp/*'
```
La seconda, altrettanto fondamentale, differenza sta nel fatto che il return code del comando remoto viene reso disponibile in locale come return code del comando rxc stesso. Questa caratteristica rende molto semplice e naturale utilizzare rxc nelle shell scripts.
Esempio 3: termina la script se un file su sistema remoto non esiste
```
rxc -Hserver test -f /tmp/filename ||exit
```
La terza differenza sta nel meccanismo di autenticazione che è molto più fine e granulare. I comandi standard rsh e ssh sono on/off, nel senso che un'utente, una volta autorizzato a lanciare una shell, è in grado di lanciare qualunque comando all'interno della shell stessa. Il comando rxc invece ha un sistema di autorizzazione basato su una serie di filtri in cascata, il comando remoto verrà eseguito se e solo se tutti gli strati di sicurezza vengono superati. Le regole che contengono i filtri sono contenuti nel file /etc/rxs.conf, lato server. Ogni regola inizia con la parola:
- allow: consenti l'esecuzione del comando se tutti i filtri sono soddisfatti
- pwdck: consenti l'esecuzione del comando se tutti i filtri sono soddisfatti e se la password fornita per l'utente è valida
- deny: impedisci l'esecuzione del comando se tutti i filtri sono soddisfatti
Vediamo, uno ad uno, quali sono questi filtri configurabili:
- sistema operativo del client
- IP address del client
- nome del client (vengono presi in considerazione anche eventuali aliases)
- username lato client
- username lato server
- comando da eseguire con eventuali argomenti
Esempio 1: consenti all'utente 'root' di una macchina AIX di lanciare qualunque comando:
```
allow A * * root
```
Esempio 2: consenti a qualunque utente di una macchina windows in rete locale di lanciare il comando grep
```
allow W 192.168.1.* * * * grep
```
Esempio 3: consenti l'esecuzione di qualunque comando solo se viene fornita una password valida:
```
pwdck
```
La password può essere messa direttamente nella linea di comando (opzione -p), nella variabile d'ambiente RXC_P, oppure nel file di configurazione $HOME/.rxclogin (opzione -G)
Le variabili d'ambiente che il comando remoto troverà popolate possono essere passate dal client, e/o lette dal file /etc/rxs.env lato server.

Affinché il comando rxc possa funzionare è necessario che sul server sia installato, e configurato, il comando rxs, il quale viene lanciato da un listener standard (inetd o xinetd).

La porta di default è la 40, ma inserendo il servizio rxx nel file /etc/services è possibile utilizzare un'altra porta.

Il traffico tra rxc e rxs è criptato, nessuna macchina in rete è in grado di leggere in chiaro il contenuto della conversazione.

Infine, ma non meno importante, rxc è veloce, molto più veloce degli analoghi comandi standard. Provare per credere...

Esempio di configurazione, con esecuzione diretta

In questo esempio andremo a configurare l'esecuzione di un comando che, lanciato sul client viene eseguito sul server.

su server
1. aggiungere la seguente riga al file di configurazione /etc/rxs.conf:
```
allow * * client * =
```
2. far partire il listener
```
plisten rxs
```
su client
1. testare la connessione con:
```
rxc -Hserver -q
```
2. lanciare su server il comando hostname:
```
rxc -Hserver hostname
  
```

Esempio di configurazione, attraverso un tunnel ssh/sshd

su server
1. aggiungere la seguente riga al file di configurazione /etc/rxs.conf:
```
allow * * client * =
```
2. far partire il listener
```
plisten rxs
```
su client
1. far partire il tunnel ssh sulla porta locale 4040
```
ssh -L 127.0.0.1:4040:127.0.0.1:40
```
2. aggiungere un alias nel file /etc/rxc.conf
```
alias server 127.0.0.1 4040
```
3. testare la connessione con:
```
rxc -Hserver -q
```
4. lanciare su server il comando hostname:
```
rxc -Hserver hostname
  
```

Per ulteriori informazioni sulla sintassi di attivazione e sulle opzioni disponibili lanciare il comando con l'opzione -h.