Passworteingabe am Terminal ausblenden

Ich möchte mein Passwort maskieren, während ich es schreibe *. Ich verwende Linux GCC für diesen Code. Ich weiß, dass eine Lösung zu verwenden ist getch() funktionieren so

#include <conio.h>   
int main()
{
    char c,password[10];
    int i;
    while( (c=getch())!= '\n');{
        password[i] = c;
        printf("*");
        i++;
    }
    return 1;
}

aber das problem ist das GCC beinhaltet nicht conio.h Datei so, getch() ist für mich nutzlos. Hat jemand eine Lösung?

In der Linux-Welt erfolgt die Maskierung normalerweise nicht mit Sternchen, normalerweise ist das Echo einfach ausgeschaltet und das Terminal zeigt Leerzeichen an, z. B. wenn Sie verwenden su oder sich in ein virtuelles Terminal einloggen etc.

Es gibt eine Bibliotheksfunktion zum Abrufen von Passwörtern, die das Passwort nicht mit Sternchen maskiert, sondern das Echo des Passworts an das Terminal deaktiviert. Ich zog dies aus einem Linux-Buch, das ich habe. Ich glaube, es ist Teil des Posix-Standards

#include <unistd.h>
char *getpass(const char *prompt);

/*Returns pointer to statically allocated input password string
on success, or NULL on error*/

Die getpass()-Funktion deaktiviert zuerst das Echoing und die gesamte Verarbeitung von Terminal-Sonderzeichen (wie das Interrupt-Zeichen, normalerweise Strg-C).

Dann gibt es den String aus, auf den die Eingabeaufforderung zeigt, und liest eine Eingabezeile, wobei es den nullterminierten Eingabestring mit entferntem Zeilenumbruch als Funktionsergebnis zurückgibt.

Eine Google-Suche nach getpass() enthält einen Verweis auf die GNU-Implementierung (sollte in den meisten Linux-Distributionen vorhanden sein) und einige Beispielcodes zur Implementierung Ihrer eigenen, falls erforderlich

http://www.gnu.org/s/hello/manual/libc/getpass.html

Ihr Beispiel zum Selberrollen:

#include <termios.h>
#include <stdio.h>

ssize_t
my_getpass (char **lineptr, size_t *n, FILE *stream)
{
    struct termios old, new;
    int nread;

    /* Turn echoing off and fail if we can't. */
    if (tcgetattr (fileno (stream), &old) != 0)
        return -1;
    new = old;
    new.c_lflag &= ~ECHO;
    if (tcsetattr (fileno (stream), TCSAFLUSH, &new) != 0)
        return -1;

    /* Read the password. */
    nread = getline (lineptr, n, stream);

    /* Restore terminal. */
    (void) tcsetattr (fileno (stream), TCSAFLUSH, &old);

    return nread;
}

Bei Bedarf können Sie dies als Grundlage verwenden, um es so zu ändern, dass Sternchen angezeigt werden.

Ohne getch sich auf Veraltetes zu verlassen und es zu vermeiden getpassist der empfohlene Ansatz, das Terminal ECHO durch zu deaktivieren termios verwenden. Nach ein paar Recherchen, um eine vorgefertigte flexible Passwortroutine zu finden, war ich überrascht, dass nur sehr wenige für die eigenständige Verwendung mit C geeignet waren. Anstatt einfach neu zu codieren getch mit Terminus c_lflag Optionen, etwas allgemeinerer Ansatz erfordert nur ein paar Ergänzungen. Jenseits des Ersetzens getch Jede Routine sollte eine angegebene maximale Länge erzwingen, um einen Überlauf zu verhindern, abschneiden, wenn der Benutzer versucht, über das Maximum hinaus einzugeben, und warnen, wenn auf irgendeine Weise abgeschnitten wird.

Unten werden die Ergänzungen das Lesen von beliebigen ermöglichen FILE * Eingabestrom, begrenzt die Länge auf eine bestimmte Länge, bietet minimale Bearbeitungsmöglichkeiten (Rücktaste) bei der Eingabe, ermöglicht die Angabe oder vollständige Deaktivierung der Zeichenmaske und gibt schließlich die Länge des eingegebenen Passworts zurück. Eine Warnung wurde hinzugefügt, wenn das eingegebene Passwort auf die maximale oder angegebene Länge gekürzt wurde.

Hoffentlich wird es sich für andere mit dieser Frage als nützlich erweisen, die nach einer ähnlichen Lösung suchen:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>

#define MAXPW 32

/* read a string from fp into pw masking keypress with mask char.
getpasswd will read upto sz - 1 chars into pw, null-terminating
the resulting string. On success, the number of characters in
pw are returned, -1 otherwise.
*/
ssize_t getpasswd (char **pw, size_t sz, int mask, FILE *fp)
{
    if (!pw || !sz || !fp) return -1;       /* validate input   */
#ifdef MAXPW
    if (sz > MAXPW) sz = MAXPW;
#endif

    if (*pw == NULL) {              /* reallocate if no address */
        void *tmp = realloc (*pw, sz * sizeof **pw);
        if (!tmp)
            return -1;
        memset (tmp, 0, sz);    /* initialize memory to 0   */
        *pw =  (char*) tmp;
    }

    size_t idx = 0;         /* index, number of chars in read   */
    int c = 0;

    struct termios old_kbd_mode;    /* orig keyboard settings   */
    struct termios new_kbd_mode;

    if (tcgetattr (0, &old_kbd_mode)) { /* save orig settings   */
        fprintf (stderr, "%s() error: tcgetattr failed.\n", __func__);
        return -1;
    }   /* copy old to new */
    memcpy (&new_kbd_mode, &old_kbd_mode, sizeof(struct termios));

    new_kbd_mode.c_lflag &= ~(ICANON | ECHO);  /* new kbd flags */
    new_kbd_mode.c_cc[VTIME] = 0;
    new_kbd_mode.c_cc[VMIN] = 1;
    if (tcsetattr (0, TCSANOW, &new_kbd_mode)) {
        fprintf (stderr, "%s() error: tcsetattr failed.\n", __func__);
        return -1;
    }

    /* read chars from fp, mask if valid char specified */
    while (((c = fgetc (fp)) != '\n' && c != EOF && idx < sz - 1) ||
            (idx == sz - 1 && c == 127))
    {
        if (c != 127) {
            if (31 < mask && mask < 127)    /* valid ascii char */
                fputc (mask, stdout);
            (*pw)[idx++] = c;
        }
        else if (idx > 0) {         /* handle backspace (del)   */
            if (31 < mask && mask < 127) {
                fputc (0x8, stdout);
                fputc (' ', stdout);
                fputc (0x8, stdout);
            }
            (*pw)[--idx] = 0;
        }
    }
    (*pw)[idx] = 0; /* null-terminate   */

    /* reset original keyboard  */
    if (tcsetattr (0, TCSANOW, &old_kbd_mode)) {
        fprintf (stderr, "%s() error: tcsetattr failed.\n", __func__);
        return -1;
    }

    if (idx == sz - 1 && c != '\n') /* warn if pw truncated */
        fprintf (stderr, " (%s() warning: truncated at %zu chars.)\n",
                __func__, sz - 1);

    return idx; /* number of chars in passwd    */
}

Ein einfaches Programm, das die Verwendung zeigt, wäre wie folgt. Wenn Sie ein statisches Array von Zeichen zum Speichern des Passworts verwenden, stellen Sie einfach sicher, dass ein Zeiger an die Funktion übergeben wird.

int main (void ) {

    char pw[MAXPW] = {0};
    char *p = pw;
    FILE *fp = stdin;
    ssize_t nchr = 0;

    printf ( "\n Enter password: ");
    nchr = getpasswd (&p, MAXPW, '*', fp);
    printf ("\n you entered   : %s  (%zu chars)\n", p, nchr);

    printf ( "\n Enter password: ");
    nchr = getpasswd (&p, MAXPW, 0, fp);
    printf ("\n you entered   : %s  (%zu chars)\n\n", p, nchr);

    return 0;
}

Beispielausgabe

$ ./bin/getpasswd2

 Enter password: ******
 you entered   : 123456  (6 chars)

 Enter password:
 you entered   : abcdef  (6 chars)

Die Funktionalität von getch (was eine nicht standardmäßige Windows-Funktion ist) kann mit diesem Code emuliert werden:

#include <termios.h>
#include <unistd.h>
int getch() {
    struct termios oldt, newt;
    int ch;
    tcgetattr(STDIN_FILENO, &oldt);
    newt = oldt;
    newt.c_lflag &= ~(ICANON | ECHO);
    tcsetattr(STDIN_FILENO, TCSANOW, &newt);
    ch = getchar();
    tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
    return ch;
}

Beachten Sie, dass Ihr Ansatz nicht perfekt ist – es ist besser, etwas wie zu verwenden ncurses oder eine andere Terminalbibliothek, um diese Dinge zu handhaben.

Sie können Ihre eigenen erstellen getch() funktionieren unter Linux auf diese Weise.

int getch() {
    struct termios oldtc, newtc;
    int ch;
    tcgetattr(STDIN_FILENO, &oldtc);
    newtc = oldtc;
    newtc.c_lflag &= ~(ICANON | ECHO);
    tcsetattr(STDIN_FILENO, TCSANOW, &newtc);
    ch=getchar();
    tcsetattr(STDIN_FILENO, TCSANOW, &oldtc);
    return ch;
}

Demo-Code:

int main(int argc, char **argv) {
    int ch;
    printf("Press x to exit.\n\n");
    for (;;) {
        ch = getch();
        printf("ch = %c (%d)\n", ch, ch);
        if(ch == 'x')
              break;
    }
    return 0;
}

Ihre Methode ist korrekt, Sie müssen jedoch das Terminal-Echo ausschalten, während das Passwort eingegeben wird:

#include <sgtty.h>

void echo_off()
{
    struct sgttyb state;
    (void)ioctl(0, (int)TIOCGETP, (char *)&state);
    state.sg_flags &= ~ECHO;
    (void)ioctl(0, (int)TIOCSETP, (char *)&state);
}

void echo_on()
{
    struct sgttyb state;
    (void)ioctl(0, (int)TIOCGETP, (char *)&state);
    state.sg_flags |= ECHO;
    (void)ioctl(0, (int)TIOCSETP, (char *)&state);
}

Anstatt von getch()warum nicht einfach verwenden getc() stattdessen?

Vielen Dank an alle, deren Hilfe und Unterstützung mein Problem gelöst haben. Ich finde einen besten Weg, mein Passwort in Linux zu verbergen, der am besten zu mir passt. So verwenden Sie die Funktion getpass(). Es muss nur die Datei “unistd.h” enthalten sein.

Syntax der getpass-Funktion:

char * getpass (const char *prompt)

Parameter: prompt: Zeichenfolgenzeiger, der gedruckt werden soll, während nach dem Passwort gefragt wird

Rückgabewert: String-Zeiger des Passworts

Beispiel:

#include <stdio.h>
#include <unistd.h>   
int main()
{
    char *password; // password string pointer
    password = getpass("Enter Password: "); // get a password
    printf("%s\n",password); // this is just for conformation
                             // that password stored successfully
    return 1;
}

Ausgang:

Passwort eingeben:

hehe

Sie können ncurses.h verwenden, wenn es dafür nicht auf Windows portierbar sein muss, aber hier ist eine Art “portablerer” Version:

Wenn es nicht notwendig ist, tragbar zu sein, verweise ich Sie auf eine ncurses-Lösung

portablegetch.h

/*portablegetch.h*/
#ifndef PGETCH
#define PGETCH
#ifdef __unix__
#include <termios.h>
#include <unistd.h>

static struct termios n_term;
static struct termios o_term;

static int
cbreak(int fd) 
{
   if((tcgetattr(fd, &o_term)) == -1)
      return -1;
   n_term = o_term;
   n_term.c_lflag = n_term.c_lflag & ~(ECHO|ICANON);
   n_term.c_cc[VMIN] = 1;
   n_term.c_cc[VTIME]= 0;
   if((tcsetattr(fd, TCSAFLUSH, &n_term)) == -1)
      return -1;
   return 1;
}

int 
getch() 
{
   int cinput;

   if(cbreak(STDIN_FILENO) == -1) {
      fprintf(stderr, "cbreak failure, exiting \n");
      exit(EXIT_FAILURE);
   }
   cinput = getchar();
   tcsetattr(STDIN_FILENO, TCSANOW, &o_term);

   return cinput;
}

#elif _MSC_VER  || __WIN32__ || __MS_DOS__
  #include <conio.h>
#endif
#endif

Und die c-Datei

was auch immer.c

#include <stdio.h>
#include <stdlib.h>
#include "portablegetch.h"

int 
main(int argc, char **argv) 
{
  int input;

  printf("Please Enter your Password:\t");

  while(( input=getch() ) != '\n')
        printf("*");
  printf("\n");

  return EXIT_SUCCESS;
}

Das sollte zu deinem Problem passen.

Ich hoffe, das hilft.