Come faccio a scrivere un test per l'accesso al sistema?

Ho scritto uno script Python CGI che richiama i bashcomandi e deve testare un accesso riuscito sull'host.

Come posso scrivere un test per questo?

Ad esempio, posso creare uno bashscript che testa una determinata combinazione di nome utente e password rispetto all'utente registrato sull'host?

L'uso di PAM è la soluzione migliore. È possibile scrivere un piccolo codice C o installare il pacchetto python-pam e utilizzare uno script python fornito con il pacchetto python-pam. Vedere/usr/share/doc/python-pam/examples/pamtest.py

L'approccio corretto per verificare se un utente può accedere è effettivamente accedere come tale utente.

Quindi ciò che consiglio è di utilizzare lo script CGI expectper eseguire su, passare una password ed eseguire il comando che deve essere eseguito. Ecco una bozza di uno script wait che fa proprio questo (avvertimento: assolutamente non testato, e non sono fluente nell'aspettarmi). Sostituire il nome utente, la password e il comando (dove ho scritto bob, swordfishe somecommand); assicurati di citare correttamente.

spawn "/bin/su" "bob"
expect "Password:"
send "swordfish\r"
expect "^\\$"
send "somecommand"
expect -re "^\\$"
send "exit\r"
expect eof

Se davvero non vuoi eseguire il comando attraverso un livello di su(ad esempio perché quello che fai deve essere eseguito dal processo CGI stesso), allora usa prevede di eseguire il comando truee controlla che lo stato di ritorno sia 0.

Un altro approccio sarebbe quello di utilizzare PAM direttamente nella tua applicazione, attraverso l'associazione PAM di Python .

Per rispondere in modo più specifico: "È possibile creare uno script bash che testerà una data combinazione di nome utente e password rispetto all'utente registrato sull'host?"

Sì.

#!/bin/bash
uid=`id -u`

if [ $uid -ne 0 ]; then 
    echo "You must be root to run this"
    exit 1
fi

if [ $# -lt 1 ]; then
    echo "You must supply a username to check - ($# supplied)"
    exit 1
fi

username=$1
salt=`grep $username /etc/shadow | awk -F: ' {print substr($2,4,8)}'`

if [ "$salt" != "" ]; then

        newpass=`openssl passwd -1 -salt $salt`
        grep $username  /etc/shadow | grep -q  $newpass && echo "Success" || echo "Failure"

fi

C'è una soluzione PAM 'C', 'Python' citata qui, lasciami mettere anche quella perl :-)

Fonte: http://search.cpan.org/~nikip/Authen-PAM-0.16/PAM/FAQ.pod#1._Can_I_authenticate_a_user_non_interactively ?

#!/usr/bin/perl

  use Authen::PAM;
  use POSIX qw(ttyname);

  $service = "login";
  $username = "foo";
  $password = "bar";
  $tty_name = ttyname(fileno(STDIN));

  sub my_conv_func {
    my @res;
    while ( @_ ) {
        my $code = shift;
        my $msg = shift;
        my $ans = "";

        $ans = $username if ($code == PAM_PROMPT_ECHO_ON() );
        $ans = $password if ($code == PAM_PROMPT_ECHO_OFF() );

        push @res, (PAM_SUCCESS(),$ans);
    }
    push @res, PAM_SUCCESS();
    return @res;
  }

  ref($pamh = new Authen::PAM($service, $username, \&my_conv_func)) ||
         die "Error code $pamh during PAM init!";

  $res = $pamh->pam_set_item(PAM_TTY(), $tty_name);
  $res = $pamh->pam_authenticate;
  print $pamh->pam_strerror($res),"\n" unless $res == PAM_SUCCESS();

Se hai accesso come root e stai usando password md5 e devi solo confrontare le password, puoi usare il modulo perl Crypt :: PasswdMD5 . Prendi l'Hash MD5 da / etc / shadow, togli $ 1 $ e poi dividi i $ rimanenti. Campo 1 = Sale, Campo 2 = testo crittografato. Quindi hash l'immissione di testo nel tuo CGI, confrontalo con il testo crittografato e Bob è tuo zio.

#!/usr/bin/env perl

use Crypt::PasswdMD5;

my $user                = $ARGV[0];
my $plain               = $ARGV[1];
my $check               = qx{ grep $user /etc/shadow | cut -d: -f2 };
chomp($check);
my($salt,$md5txt)       = $check =~ m/\$1\$([^\$].+)\$(.*)$/;
my $pass                = unix_md5_crypt($plain, $salt);

if ( "$check" eq "$pass" ) {
        print "OK","\n";
} else {
        print "ERR","\n";
}

Dopo alcune ricerche ho scritto questo programma C che può essere usato dallo script

#include <stdlib.h>
#include <stdio.h>
#include <pwd.h>
#include <shadow.h>
#include <string.h>
#include <crypt.h>
#include <unistd.h>
#include <libgen.h>

int main(int argc, char **argv) {
    struct spwd *pwd;
    if (argc != 3) {
        printf("usage:\n\t%s [username] [password]\n", basename(argv[0]));
        return 1;
    } else if (getuid() == 0) {
        pwd = getspnam(argv[1]);
        return strcmp(crypt(argv[2], pwd->sp_pwdp), pwd->sp_pwdp);
    } else {
        printf("You need to be root\n");
        return 1;
    }
}

Lo compili con:

gcc -Wall password_check.c /usr/lib/libcrypt.a -o check_passwd

Puoi usarlo come

sudo ./check_passwd <user> <password> && echo "success" || echo "failure"

Dal momento che hai detto che stai usando CGI in Python, è probabilmente appropriato supporre che stai usando Apache come server httpd. In tal caso, lascia il processo di autenticazione del tuo programma su Apache e lascia che le persone autenticate eseguano i tuoi script / programmi cgi.

Ci sono molti moduli che possono fare l'autenticazione su Apache, dipende davvero dal tipo di meccanismo di autenticazione che stai cercando. Il modo in cui hai citato la domanda sembra essere correlato all'autenticazione dell'account host locale basata su / etc / passwd, file shadow. Il modulo che arriva alla mia rapida ricerca in merito è mod_auth_shadow. Il vantaggio è che si sta consentendo a qualcuno autorevole (in esecuzione sulla porta di privilegio 80) di autenticare l'utente / password per l'utente e si può fare affidamento su informazioni autenticate dell'utente per eseguire i comandi per conto dell'utente, se necessario.

Buoni collegamenti per iniziare:

http://adam.shand.net/archives/2008/apache_tips_and_tricks/#index5h2

http://mod-auth-shadow.sourceforge.net/

http://www.howtoforge.com/apache_mod_auth_shadow_debian_ubuntu

Un altro approccio consiste nell'utilizzare il modulo SuEXEc di Apache, che esegue i processi (programmi cgi) per conto dell'utente autenticato.

Questo codice usando PAM ha funzionato per me:

#include <security/pam_appl.h>
#include <security/pam_misc.h>
#include <stdio.h>
#include <string.h>

// Define custom PAM conversation function
int custom_converation(int num_msg, const struct pam_message** msg, struct pam_response** resp, void* appdata_ptr)
{
    // Provide password for the PAM conversation response that was passed into appdata_ptr
    struct pam_response* reply = (struct pam_response* )malloc(sizeof(struct pam_response));
    reply[0].resp = (char*)appdata_ptr;
    reply[0].resp_retcode = 0;

    *resp = reply;

    return PAM_SUCCESS;
}

int main (int argc, char* argv[]) 
{
    if (argc > 2)
    {
        // Set up a custom PAM conversation passing in authentication password
        char* password = (char*)malloc(strlen(argv[2]) + 1);
        strcpy(password, argv[2]);        
        struct pam_conv pamc = { custom_converation, password };
        pam_handle_t* pamh; 
        int retval;

        // Start PAM - just associate with something simple like the "whoami" command
        if ((retval = pam_start("whoami", argv[1], &pamc, &pamh)) == PAM_SUCCESS)
        {
            // Authenticate the user
            if ((retval = pam_authenticate(pamh, 0)) == PAM_SUCCESS) 
                fprintf(stdout, "OK\n"); 
            else 
                fprintf(stderr, "FAIL: pam_authentication failed.\n"); 

            // All done
            pam_end(pamh, 0); 
            return retval; 
        }
        else
        {
            fprintf(stderr, "FAIL: pam_start failed.\n"); 
            return retval;
        }
    }

    fprintf(stderr, "FAIL: expected two arguments for user name and password.\n"); 
    return 1; 
}

La cosa migliore che puoi fare, se hai bisogno di uno script per accedere a un host, è configurare una chiave ssh tra gli host.

Link: http://pkeck.myweb.uga.edu/ssh/

Ho praticamente rimosso questo dalla pagina

Innanzitutto, installa OpenSSH su due macchine UNIX, in modo rapido e corpulento. Funziona meglio usando le chiavi DSA e SSH2 per impostazione predefinita, per quanto ne so. Tutti gli altri HOWTO che ho visto sembrano avere a che fare con chiavi RSA e SSH1 e le istruzioni non sorprendono a non funzionare con SSH2. Su ogni macchina digitare ssh somemachine.example.com e stabilire una connessione con la password normale. Questo creerà una directory .ssh nella directory home con i permessi corretti. Sul tuo computer principale in cui vuoi che vivano le tue chiavi segrete (diciamo in fretta), digita

ssh-keygen -t dsa

Questo ti chiederà una passphrase segreta. Se questa è la chiave di identità primaria, assicurati di utilizzare una buona passphrase. Se funziona correttamente, otterrai due file chiamati id_dsa e id_dsa.pub nella tua directory .ssh. Nota: è possibile premere semplicemente il tasto Invio quando viene richiesto un passphrase, che creerà un tasto senza passphrase. Questa è una Bad Idea ™ per una chiave di identità, quindi non farlo! Vedi sotto per l'uso di chiavi senza passphrase.

scp ~/.ssh/id_dsa.pub burly:.ssh/authorized_keys2

Copia il file id_dsa.pub nella directory .ssh dell'altro host con il nome autorizzato_keys2. Ora burly è pronto per accettare la tua chiave ssh. Come dirgli quali chiavi usare? Il comando ssh-add lo farà. Per un test, digitare

ssh-agent sh -c 'ssh-add < /dev/null && bash'

Questo avvierà l'agente ssh, aggiungerà la tua identità predefinita (chiedendoti la tua passphrase) e genererà una shell bash. Da questa nuova shell dovresti essere in grado di:

ssh burly

Dovresti essere in grado di accedere