Wie überprüfe ich das Passwort mit Linux?

Sie können das verschlüsselte Passwort einfach mit awk extrahieren. Sie müssen dann das Präfix $algorithm$salt$ extrahieren (vorausgesetzt, dieses System verwendet nicht den traditionellen DES, der stark missbilligt wird, da er heutzutage brutal erzwungen werden kann).

correct=$(</etc/shadow awk -v user=bob -F : 'user == $1 {print $2}')
prefix=${correct%"${correct#\$*\$*\$}"}

Für die Passwortprüfung ist die zugrunde liegende C-Funktion crypt , aber es gibt keinen Standard-Shell-Befehl, um darauf zuzugreifen.

Auf der Befehlszeile können Sie einen Perl-Einzeiler verwenden, um crypt aufzurufen auf das Passwort.

supplied=$(echo "$password" |
           perl -e '$_ = <STDIN>; chomp; print crypt($_, $ARGV[0])' "$prefix")
if [ "$supplied" = "$correct" ]; then …

Da dies in reinen Shell-Tools nicht möglich ist, können Sie, wenn Sie Perl zur Verfügung haben, alles genauso gut in Perl erledigen. (Oder Python, Ruby, … was auch immer Sie zur Verfügung haben, das den crypt aufrufen kann Funktion.) Warnung, ungetesteter Code.

#!/usr/bin/env perl
use warnings;
use strict;
my @pwent = getpwnam($ARGV[0]);
if ([email protected]) {die "Invalid username: $ARGV[0]\n";}
my $supplied = <STDIN>;
chomp($supplied);
if (crypt($supplied, $pwent[1]) eq $pwent[1]) {
    exit(0);
} else {
    print STDERR "Invalid password for $ARGV[0]\n";
    exit(1);
}

Auf einem eingebetteten System ohne Perl würde ich ein kleines, dediziertes C-Programm verwenden. Achtung, direkt in den Browser eingetippt, ich habe noch nicht einmal versucht zu kompilieren. Dies soll die notwendigen Schritte veranschaulichen, nicht als robuste Implementierung!

/* Usage: echo password | check_password username */
#include <stdio.h>
#include <stdlib.h>
#include <pwd.h>
#include <shadow.h>
#include <sys/types.h>
#include <unistd.h>
int main(int argc, char *argv[]) {
    char password[100];
    struct spwd shadow_entry;
    char *p, *correct, *supplied, *salt;
    if (argc < 2) return 2;
    /* Read the password from stdin */
    p = fgets(password, sizeof(password), stdin);
    if (p == NULL) return 2;
    *p = 0;
    /* Read the correct hash from the shadow entry */
    shadow_entry = getspnam(username);
    if (shadow_entry == NULL) return 1;
    correct = shadow_entry->sp_pwdp;
    /* Extract the salt. Remember to free the memory. */
    salt = strdup(correct);
    if (salt == NULL) return 2;
    p = strchr(salt + 1, '$');
    if (p == NULL) return 2;
    p = strchr(p + 1, '$');
    if (p == NULL) return 2;
    p[1] = 0;
    /*Encrypt the supplied password with the salt and compare the results*/
    supplied = crypt(password, salt);
    if (supplied == NULL) return 2;
    return !!strcmp(supplied, correct);
}

Ein anderer Ansatz besteht darin, ein vorhandenes Programm wie su zu verwenden oder login . Wenn Sie können, wäre es sogar ideal, wenn Sie dafür sorgen würden, dass die Webanwendung über su -c somecommand username alles ausführt, was sie benötigt . Die Schwierigkeit besteht hier darin, das Passwort an su zu füttern; dies erfordert ein Terminal. Das übliche Werkzeug zum Emulieren eines Terminals ist zu erwarten, aber es ist eine große Abhängigkeit für ein eingebettetes System. Auch während su in BusyBox ist, wird es oft weggelassen, weil viele seiner Verwendungen erfordern, dass die BusyBox-Binärdatei setuid root ist. Wenn Sie es tun können, ist dies jedoch aus Sicherheitsgesichtspunkten der robusteste Ansatz.

Schauen Sie sich man 5 shadow an und man 3 crypt . Aus letzterem können Sie erfahren, dass Passwort-Hashes in /etc/shadow sind haben folgende Form:

 $id$salt$encrypted

wobei id definiert die Art der Verschlüsselung und kann, wenn man weiter liest, eine von

sein

          ID  | Method
          ---------------------------------------------------------
          1   | MD5
          2a  | Blowfish (not in mainline glibc; added in some
              | Linux distributions)
          5   | SHA-256 (since glibc 2.7)
          6   | SHA-512 (since glibc 2.7)

Je nach Art des Hashs müssen Sie die entsprechende Funktion/das entsprechende Tool verwenden, um das Passwort „von Hand“ zu generieren und zu überprüfen. Wenn das System mkpasswd enthält Programm, können Sie es wie hier vorgeschlagen verwenden. (Du nimmst das Salz aus der Schattendatei, falls das nicht offensichtlich war.) Zum Beispiel mit md5 Passwörter :

 mkpasswd -5 <the_salt> <the_password>

generiert die Zeichenfolge, die mit /etc/shadow übereinstimmen sollte Eintrag.

Bei Stack Overflow wurde eine ähnliche Frage gestellt. cluelessCoder hat ein Skript bereitgestellt, das Expect verwendet, das Sie möglicherweise auf Ihrem eingebetteten System haben oder nicht.

#!/bin/bash
#
# login.sh $USERNAME $PASSWORD

#this script doesn't work if it is run as root, since then we don't have to specify a pw for 'su'
if [ $(id -u) -eq 0 ]; then
        echo "This script can't be run as root." 1>&2
        exit 1
fi

if [ ! $# -eq 2 ]; then
        echo "Wrong Number of Arguments (expected 2, got $#)" 1>&2
        exit 1
fi

USERNAME=$1
PASSWORD=$2

#since we use expect inside a bash-script, we have to escape tcl-$.
expect << EOF
spawn su $USERNAME -c "exit" 
expect "Password:"
send "$PASSWORD\r"
#expect eof

set wait_result  [wait]

# check if it is an OS error or a return code from our command
#   index 2 should be -1 for OS erro, 0 for command return code
if {[lindex \$wait_result 2] == 0} {
        exit [lindex \$wait_result 3]
} 
else {
        exit 1 
}
EOF