Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Gültigkeit eines Passwortes (Zeichenketten)

Prüfen Sie die Gültigkeit eines Passwortes.

Dabei müssen die folgenden Kriterien erfüllt sein:

  • Das Passwort muss aus mindestens neun Zeichen bestehen.
  • Das Passwort muss Großbuchstaben aufweisen.
  • Das Passwort muss Kleinbuchstaben aufweisen.
  • Im Passwort müssen Ziffern vorkommen.
  • Im Passwort müssen Sonderzeichen vorkommen.
  • Aus jedem der vier oben genannten Zeichentypen müssen mindestens zwei Zeichen vorkommen. Also zwei Großbuchstaben, zwei Kleinbuchstaben usw.

1 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

Kommentare (1)

ValentinMarolf 2. Oktober 2013 10:18   reply report
Hab grad ne Lösung für PL/1 eingegeben. Die wird etwas lustig eingefärbt. Und die KleinerGrösser-Zeichen werden in HTML-Code umgewandelt, was natürlich nicht sein sollte (< und >)

20 Lösung(en)

package ch.programmieraufgaben.strings;

// wird verwendet für "einlesenString()":
import static eu.gressly.io.utility.Einlesen.*;

/**
 * Programmieraufgaben.ch "Güte eines Passworts" Web-Code xy54-zafk
 * 
 * @author Philipp Gressly (phi AT gressly DOT ch)
 */
public class Passwortcheck {
    public static void main(String[] args) {
        new Passwortcheck().top();
    }

    void top() {
        String passwort = einlesenString("Passwort");
        if (isOK(passwort)) {
            System.out.println("Passwort ist OK.");
        } else {
            System.out.println("Passwort genügt den Anforderungen nicht.");
        }
    }

    boolean isOK(String passwort) {
        if (passwort.length() < 9) {
            return false;
        }
        if (anzGrossbuchstaben(passwort) < 2) {
            return false;
        }
        if (anzKleinbuchstaben(passwort) < 2) {
            return false;
        }
        if (anzZiffern(passwort) < 2) {
            return false;
        }
        if (anzSonderzeichen(passwort) < 2) {
            return false;
        }
        return true;
    }

    int anzGrossbuchstaben(String pass) {
        return anzBuchstabenInIntervall(pass, 'A', 'Z');
    }

    int anzKleinbuchstaben(String pass) {
        return anzBuchstabenInIntervall(pass, 'a', 'z');
    }

    int anzZiffern(String pass) {
        return anzBuchstabenInIntervall(pass, '0', '9');
    }

    int anzSonderzeichen(String pass) {
        return pass.length() -
               anzGrossbuchstaben(pass) -
               anzKleinbuchstaben(pass) -
               anzZiffern        (pass);
    }

    int anzBuchstabenInIntervall(String pass, char min, char max) {
        int anz = 0;
        for (char c : pass.toCharArray()) {
            if (c >= min && c <= max) {
                anz = anz + 1;
            }
        }
        return anz;
    }

} // end of class Passwortcheck

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

# -*- coding: utf-8 -*-


class PasswordCheck(object):

    def __init__(self):
        self.enter_pw()

    def enter_pw(self):
        pw = raw_input('Enter Password:')
        good_pw = self._check_password(pw)
        while not good_pw:
            print '{0} is invalid'.format(pw)
            pw = raw_input('Enter Password:')
            good_pw = self._check_password(pw)
        print '{0} is good'.format(pw)

    def _check_password(self, pw):
        if len(pw) < 9:
            return False   
        checks = []
        checks.append(self._case(pw))
        checks.append(self._case(pw, upper=True))
        checks.append(self._case(pw, integer=True))
        checks.append(self._case(pw, special=True))
        if all(checks):
            return True
        return False

    def _case(self, pw, upper=False, integer=False, special=False):
        count = 0
        abc = 'abcdefghijklmnopqrstuvwxyz'
        ints = '0123456789'
        if upper:
            abc = abc.upper()
        if integer:
            abc = ints
        if special:
            abc = abc + abc.upper() + ints
            print abc
            for i in pw:
                if not i in abc:
                    count += 1
                if count > 1:
                    return True
            return False
        for i in pw:
            if i in abc:
                count += 1
            if count > 1:
                return True
        return False

if __name__ == '__main__':
    g = PasswordCheck()

Lösung von: Name nicht veröffentlicht

  /* Deklarationen der Wertebereiche */
  DCL KOBIG     CHAR(26)     VALUE('ABCDEFGHIJKLMNOPQRSTUVWXYZ');
  DCL KOSMA     CHAR(26)     VALUE('abcdefghijklmnopqrstuvwxyz');
  DCL KONUM     CHAR(10)     VALUE('0123456789');
    /* EBCDIC-Sonderzeichen gemäss            */
    /* http://unicode.e-workers.de/ebcdic.php */
    /* Anmerkung: Enthält keine Umlaute...    */
  DCL KOSPEC    CHAR(66)     VALUE(
                             ('4A4B4C4D4E4F505A5B5C5D5E5F60616A6B'X !!
                              '6C6D6E6F797A7B7C7D7E7FA1C0D0E0'X));
  DCL KOPWMIN   BIN FIXED(31) VALUE(9);
  DCL KOPWMAX   BIN FIXED(31) VALUE(100);

  /* Deklarationen der Test-Fälle */
  DCL ZWTEST_01    CHAR(08)  INIT((8)'-');
  DCL ZWTEST_02    CHAR(101) INIT((101)'-');
  DCL ZWTEST_03    CHAR(50)  INIT((9)'00'X);
  DCL ZWTEST_04_1  CHAR(50)  INIT(('abcd1234' !! '6C6D'X));
  DCL ZWTEST_04_2  CHAR(50)  INIT(('abcX1234' !! '6C6D'X));
  DCL ZWTEST_05_1  CHAR(50)  INIT(('ABCD1234' !! '6C6D'X));
  DCL ZWTEST_05_2  CHAR(50)  INIT(('ABCx1234' !! '6C6D'X));
  DCL ZWTEST_06_1  CHAR(50)  INIT(('abcdEFGH' !! '6C6D'X));
  DCL ZWTEST_06_2  CHAR(50)  INIT(('abcdEFG1' !! '6C6D'X));
  DCL ZWTEST_07_1  CHAR(50)  INIT('abcdEFGH1234');
  DCL ZWTEST_07_2  CHAR(50)  INIT(('abcDEF123' !! '6C'X));
  DCL ZWTEST_HAPPY CHAR(12)  INIT(('123abcDEF' !! '6C6D6E'X));

  /*===================================*/
  /*    HAUPTPROGRAMM                  */
  /*===================================*/
  /* 1. Führende Blanks müssen bereits getrimmt sein */
  /* 2. Blanks am Ende werden ignoriert              */
  PUT SKIP LIST('Test ZWTEST_01');
  CALL P10_TEST(ADDR(ZWTEST_01),LENGTH(TRIM(ZWTEST_01)));
  PUT SKIP LIST('Test ZWTEST_02');
  CALL P10_TEST(ADDR(ZWTEST_02),LENGTH(TRIM(ZWTEST_02)));
  PUT SKIP LIST('Test ZWTEST_03');
  CALL P10_TEST(ADDR(ZWTEST_03),LENGTH(TRIM(ZWTEST_03)));
  PUT SKIP LIST('Test ZWTEST_04_1');
  CALL P10_TEST(ADDR(ZWTEST_04_1),LENGTH(TRIM(ZWTEST_04_1)));
  PUT SKIP LIST('Test ZWTEST_04_2');
  CALL P10_TEST(ADDR(ZWTEST_04_2),LENGTH(TRIM(ZWTEST_04_2)));
  PUT SKIP LIST('Test ZWTEST_05_1');
  CALL P10_TEST(ADDR(ZWTEST_05_1),LENGTH(TRIM(ZWTEST_05_1)));
  PUT SKIP LIST('Test ZWTEST_05_2');
  CALL P10_TEST(ADDR(ZWTEST_05_2),LENGTH(TRIM(ZWTEST_05_2)));
  PUT SKIP LIST('Test ZWTEST_06_1');
  CALL P10_TEST(ADDR(ZWTEST_06_1),LENGTH(TRIM(ZWTEST_06_1)));
  PUT SKIP LIST('Test ZWTEST_06_2');
  CALL P10_TEST(ADDR(ZWTEST_06_2),LENGTH(TRIM(ZWTEST_06_2)));
  PUT SKIP LIST('Test ZWTEST_07_1');
  CALL P10_TEST(ADDR(ZWTEST_07_1),LENGTH(TRIM(ZWTEST_07_1)));
  PUT SKIP LIST('Test ZWTEST_07_2');
  CALL P10_TEST(ADDR(ZWTEST_07_2),LENGTH(TRIM(ZWTEST_07_2)));
  PUT SKIP LIST('Test ZWTEST_HAPPY');
  CALL P10_TEST(ADDR(ZWTEST_HAPPY),LENGTH(TRIM(ZWTEST_HAPPY)));
  RETURN;

  /*===================================*/
  /*    PROZEDUREN                     */
  /*===================================*/
  P10_TEST: PROC(ZWP10_PTR, ZWP10_LEN);
    DCL ZWP10_PTR        PTR;
    DCL ZWP10_LEN        BIN FIXED(31);
    DCL ZWP10_TESTSTR(KOPWMAX) CHAR(01) BASED(ZWP10_PTR);
    DCL ZWP10_TESTCH     CHAR(01) BASED(ADDR(ZWP10_TESTSTR(ZWP10_POS)));
    DCL ZWP10_POS        BIN FIXED(31) INIT(0);
    DCL IND_BIG          BIN FIXED(31) INIT(0);
    DCL IND_SMA          BIN FIXED(31) INIT(0);
    DCL IND_NUM          BIN FIXED(31) INIT(0);
    DCL IND_SPEC         BIN FIXED(31) INIT(0);

    /* Länge prüfen */
    IF ZWP10_LEN < KOPWMIN THEN DO;
      CALL P90_ERROR(01);
      RETURN;
    END;
    IF ZWP10_LEN > KOPWMAX THEN DO;
      CALL P90_ERROR(02);
      RETURN;
    END;

    /* Zeichen prüfen und zählen */
    IND_BIG  = 0;
    IND_SMA  = 0;
    IND_NUM  = 0;
    IND_SPEC = 0;
    DO ZWP10_POS = 1 TO ZWP10_LEN WHILE(ZWP10_LEN <= KOPWMAX);
      IF VERIFY(ZWP10_TESTCH,KOBIG) = 0 THEN IND_BIG  += 1;
      ELSE DO;
        IF VERIFY(ZWP10_TESTCH,KOSMA) = 0 THEN IND_SMA  += 1;
        ELSE DO;
          IF VERIFY(ZWP10_TESTCH,KONUM) = 0 THEN IND_NUM  += 1;
          ELSE DO;
            IF VERIFY(ZWP10_TESTCH,KOSPEC) = 0 THEN IND_SPEC += 1;
            ELSE DO;
              CALL P90_ERROR(03);
              RETURN;
            END; /* ELSE SPEC */
          END; /* ELSE NUM */
        END; /* ELSE SMA */
      END; /* ELSE BIG */
    END;

    /* Mengen prüfen */
    IF IND_BIG < 2 THEN DO;
      CALL P90_ERROR(04);
      RETURN;
    END;
    IF IND_SMA < 2 THEN DO;
      CALL P90_ERROR(05);
      RETURN;
    END;
    IF IND_NUM < 2 THEN DO;
      CALL P90_ERROR(06);
      RETURN;
    END;
    IF IND_SPEC < 2 THEN DO;
      CALL P90_ERROR(07);
      RETURN;
    END;
    PUT SKIP LIST('Passwort ist in Ordnung');
  END P10_TEST;

  P90_ERROR: PROC(ZWP90_ID);
    DCL ZWP90_ID BIN FIXED(31);
    SELECT(ZWP90_ID);
      WHEN(01) PUT SKIP LIST('Passwort ist zu kurz');
      WHEN(02) PUT SKIP LIST('Passwort ist zu lang');
      WHEN(03) PUT SKIP LIST('Passwort enthält unerlaubte Zeichen');
      WHEN(04) PUT SKIP LIST(
                 'Passwort enthält zuwenig Grossbuchstaben');
      WHEN(05) PUT SKIP LIST(
                 'Passwort enthält zuwenig Kleinbuchstaben');
      WHEN(06) PUT SKIP LIST('Passwort enthält zuwenig Zahlen');
      WHEN(07) PUT SKIP LIST('Passwort enthält zuwenig Sonderzeichen');
      OTHER    PUT SKIP LIST('Unbekannter Fehler (' !!
                             TRIM(CHAR(ZWP90_ID)) !!
                             '). Bitte Programm prüfen');
    END; /* SELECT(ZWP90_ID) */
  END P90_ERROR;

Lösung von: Valentin Marolf (AXA)

def isGoodPassword(password):
    z = [0,0,0,0] # Anzahl der verschiedenen Zeichentypen 
    for c in password:
        a = ord(c) # Zeichen in ASCII-Nummer umwandeln
        if a > 64 and a < 91: # Grossbuchstaben zählen
            z[0] = z[0]+ 1
        else:
            if a > 96 and a < 123: # Kleinbuchstaben zählen
                z[1] += 1
            else:
                if a > 47 and a < 58: # Ziffern zählen
                    z[2] += 1
                else:
                    z[3] += 1 # Sonderzeichen zählen
    return ((z[0] > 1) and (z[1] > 1) and (z[2] > 1) and (z[3] > 1) and (sum(z) > 8))

Lösung von: dietmar berger ()

import java.util.Scanner;

public class passwortguete {

    // Wird zum Überprüfen von Klein- und Großbuchstaben verwendet
    private String alphabet = "abcdefghijklmnopqrstuvwxyz";

    // Testet das Passwort auf seine Mindestlänge
    private boolean zeichenanzahl(String passwort) {
	boolean stimmt = false; // boolean der true wiedergibt wenn die
				// Eigenschaft zutrifft

	if (passwort.length() > 8) {
	    stimmt = true;
	}

	return stimmt;
    }

    // Testet das Passwort auf Großbuchstaben
    private boolean großbuchstaben(char[] passarray) {
	boolean stimmt = false; // boolean der true wiedergibt wenn die
				// Eigenschaft zutrifft

	int zaehler = 0; // zählt wie oft das Zeichen im PW vorkommt

	// testet auf Großbuchstabenanzahl
	for (int i = 0; i < passarray.length; i++) {

	    if (alphabet.toUpperCase().contains(String.valueOf(passarray[i]))) {
		zaehler++;
	    }

	    if (zaehler > 1) {
		stimmt = true;
	    }
	}

	return stimmt;
    }

    // Testet das Passwort auf Kleinbuchstaben
    private boolean kleinbuchstaben(char[] passarray) {
	boolean stimmt = false; // boolean der true wiedergibt wenn die
				// Eigenschaft zutrifft

	int zaehler = 0; // zählt wie oft das Zeichen im PW vorkommt

	for (int i = 0; i < passarray.length; i++) {

	    // testet auf Kleinbuchstabenanzahl
	    if (alphabet.contains(String.valueOf(passarray[i]))) {
		zaehler++;
	    }

	    if (zaehler > 1) {
		stimmt = true;
	    }
	}

	return stimmt;
    }

    // Testet das Passwort auf Ziffern
    private boolean ziffern(char[] passarray) {
	boolean stimmt = false; // boolean der true wiedergibt wenn die
				// Eigenschaft zutrifft

	String zahlen = "0123456789"; // zu überprüfende Zahlen

	int zaehler = 0; // zählt wie oft das Zeichen im PW vorkommt

	// testet auf Ziffernanzahl
	for (int i = 0; i < passarray.length; i++)
	    if (zahlen.contains(String.valueOf(passarray[i]))) {
		zaehler++;
	    }

	if (zaehler > 1) {
	    stimmt = true;
	}

	return stimmt;
    }

    // Testet das Passwort auf Sonderzeichen
    private boolean sonderzeichen(char[] passarray) {
	boolean stimmt = false; // boolean der true wiedergibt wenn die
				// Eigenschaft zutrifft

	// zu überprüfende Zeichen
	String zeichen = "!#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";

	int zaehler = 0; // zählt wie oft das Zeichen im PW vorkommt

	// testet auf Zeichenanzahl
	for (int i = 0; i < passarray.length; i++) {

	    if (zeichen.contains(String.valueOf(passarray[i]))) {
		zaehler++;
	    }
	}

	if (zaehler > 1) {
	    stimmt = true;
	}

	return stimmt;
    }

    // Testet das Passwort auf alle Eigenschaften
    private boolean testePasswort(String passwort) {
	boolean passwortok = false;// boolean der true wiedergibt wenn alle
				   // Eigenschaften zutreffen

	// chararray das das Passwort darstellt
	char[] passarray = passwort.toCharArray();

	// testet auf alle Eigenschaften
	if (zeichenanzahl(passwort) && großbuchstaben(passarray)
		&& kleinbuchstaben(passarray) && ziffern(passarray)
		&& sonderzeichen(passarray)) {
	    passwortok = true;
	    System.out.println("Passwort entspricht den Anforderungen");
	} else {
	    System.out.println("Passwortanforderungen nicht erfüllt!");
	}
	return passwortok;
    }

    // Hauptmethode
    public static void main(String[] args) {
	// Scanner zum Einlesen des Passworts des Benutzers
	Scanner scan = new Scanner(System.in);
	// Klassenvariable um auf die Methoden zugreifen zu können
	passwortguete tue = new passwortguete();
	// Eingabeaufforderung und Prüfung des Passworts
	System.out.println("Geben Sie ihr Passwort an:");
	tue.testePasswort(scan.nextLine());
	scan.close();
    }
}

Lösung von: Sebastian Littel ()

 TEST: proc options (main);

 /*-----------------------------------------------*/
 /* Hauptprogramm mit Function PasswortIstGueltig */
 /* --------------------------------------------- */
 /* Passwort auf Gültigkeit prüfen                */
 /* Bruno Keller, SANTIS Training AG, 4.12.2013   */
 /*-----------------------------------------------*/

 dcl SYSPRINT file print;
 dcl Passwort char(10) var init('AA@3bbbB$_'); 

 if PasswortIstGueltig(Passwort) then
    put skip list(Passwort,'ist gültig');
 else
    put skip list(Passwort,'ist ungültig');

 /*------------------------------------------------*/
 PasswortIstGueltig: proc($Passwort) returns(bit(1));
 /*------------------------------------------------*/

 dcl $Passwort       char(10) var parm;
 dcl Grossbuchstaben char(26) value('ABCDEFGHIJKLMNOPQRSTUVWXYZ');
 dcl Kleinbuchstaben char(26) value('abcdefghijklmnopqrstuvwxyz');
 dcl Ziffern         char(10) value('0123456789');
 dcl Sonderzeichen   char(04) value('$@#_');   /* diese seien erlaubt */
 dcl length          builtin;

 if (length($Passwort)                      < 9) then return('0'b);
 if (getAnzahlOf($Passwort,Grossbuchstaben) < 2) then return('0'b);
 if (getAnzahlOf($Passwort,Kleinbuchstaben) < 2) then return('0'b);
 if (getAnzahlOf($Passwort,Ziffern        ) < 2) then return('0'b);
 if (getAnzahlOf($Passwort,Sonderzeichen  ) < 2) then return('0'b);

 return('1'b);

 getAnzahlOf: proc(@Passwort,@VerglString) returns(bin fixed(31));
 /*-------------------------------------------------------------*/
 dcl @Passwort    char(10) var parm;
 dcl @VerglString char(*) parm;
 dcl Posi         bin fixed(31);
 dcl Anzahl       bin fixed(31) init(0);
 dcl i_Anzahl     bin fixed(31);
 dcl search       builtin;
 Posi = search(@Passwort,@VerglString);
 do while(Posi > 0);
    Anzahl = Anzahl + 1;
    Posi = search(@Passwort,@VerglString,Posi+1);
 end;
 return(Anzahl);
 end getAnzahlOf;

 end PasswortIstGueltig;

 end TEST;

Lösung von: Bruno Keller (Santis Training AG)

#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>

bool is_valid(char pw[]);

int main(){

	if( is_valid( "DAsiSTeiNp455wort^^" ) )
		printf( "gültiges Passwort" );
	else
		printf( "ungültiges Passwort" );
	printf( "\n" );

	return 0;

}

bool is_valid(char pw[]){
	//Definition der Grenzen im ASCII - Zeichensatz
	const int8_t UC_LOWER_BORDER = 65;	//Großbuchstaben
	const int8_t UC_HIGHER_BORDER = 90;
	const int8_t LC_LOWER_BORDER = 97;	//Kleinbuchstaben
	const int8_t LC_HIGHER_BORDER = 122;
	const int8_t N_LOWER_BORDER = 48;		// Nummern
	const int8_t N_HIGHER_BORDER = 57;	

//alles andere wird als Sonderzeichen erkannt

	int32_t i;					//Passwortzeichenindex

	int32_t size;				//Länge des Strings
	int32_t upper_case;	//Anzahl der Großbuchstaben
	int32_t lower_case;	//Anzahl der Kleinbuchstaben
	int32_t number;			//Anzahl der Ziffern
	int32_t special;		//Anzahl der Sonderzeichen

	int8_t c;						//Zwischenspeicher für die einzelnen Zeichen

	i = 0;
	size = 0;
	upper_case = 0;
	lower_case = 0;
	number = 0;
	special = 0;

/*
Es wird für jedes Zeichen überprüft, ob es sich innerhalb der Grenzen von einer der
Zeichenarten befindet. Tritt so ein Fall ein, wird der Zähler für die jeweilige Art
hochgezählt. Die Schleife läuft bis das Stringterminationszeichen \0 erreicht wird
*/

	while( (c = pw[ i ]) != '\0' ){
		if( c >= UC_LOWER_BORDER && c <= UC_HIGHER_BORDER )
			++upper_case;
		else 
			if( c >= LC_LOWER_BORDER && c <= LC_HIGHER_BORDER )
				++lower_case;
		  else
				if( c >= N_LOWER_BORDER && c <= N_HIGHER_BORDER )
					++number;
				else
					++special;
		++size;	
		++i;
	}
	return upper_case >= 2 &&
         lower_case >= 2 &&	
         number >= 2 &&
         special >= 2 &&
         size >= 9;
}

Lösung von: reeman :3 (TU Ilmenau)

import string

class IntersectionList(list):

    def elements_of(self, l):
        '''Return all elements of self which are elements of l'''
        return [e for e in self if e in l]

    def __and__(self, other):
        return self.elements_of(other)


ll = IntersectionList(string.ascii_lowercase)
ul = IntersectionList(string.ascii_uppercase)
di = IntersectionList(string.digits)
ss = IntersectionList(string.punctuation) #If you want to add more special symbols you have to add these here.

def validate(password):
    pw = IntersectionList(password)
    checks = [len(password) >= 9,
             len(pw & ll) >= 2,
             len(pw & ul) >= 2,
             len(pw & di) >= 2,
             len(pw & ss) >= 2]
    if all(checks):
        return True, []
    else:
        return False, [i for i, c in enumerate(checks) if not c]

while True:
    password = input("Gib ein Passwort ein: ").strip()
    valid, reasons = validate(password)
    if valid:
        print("gueltiges Passwort")
        break
    else:
        reasonsdict = {0:"zu kurz",
                     1:"zu wenig oder keine Kleinbuchstaben",
                     2:"zu wenig oder keine Grossbuchstaben",
                     3:"zu wenig oder keine Zahlen",
                     4:"zu wenig oder keine Sonderzeichen"}
        reasons = [reasonsdict[e] for e in reasons if e in reasonsdict]
        if len(reasons) > 2:
            reasons = " und ".join([", ".join(reasons[:-1]), reasons[-1]])
        else:
            reasons = " und ".join(reasons)
        print("Ungueltiges Passwort ({})".format(reasons) if reasons else "Ungueltiges Passwort")

Lösung von: Karl Welzel ()


/**
 * Prüfen Sie die Gültigkeit eines Passwortes. Dabei müssen die folgenden
 * Kriterien erfüllt sein: Das Passwort muss aus mindestens neun Zeichen
 * bestehen. Das Passwort muss Großbuchstaben aufweisen. Das Passwort muss
 * Kleinbuchstaben aufweisen. Im Passwort müssen Ziffern vorkommen. Im Passwort
 * müssen Sonderzeichen vorkommen. Aus jedem der vier oben genannten
 * Zeichentypen müssen mindestens zwei Zeichen vorkommen. Also zwei
 * Großbuchstaben, zwei Kleinbuchstaben usw.
 *
 * @author RagingRobert
 */
public class Password_Checker {

    private int[] checkedCases = new int[4];

    public void print() {
        for (int i = 0; i < this.checkedCases.length; i++) {
            System.out.println(checkedCases[i]);
        }

    }

    public static void main(String[] args) {
        Password_Checker instance = new Password_Checker();
        instance.checkPassword("ABab12?!c");
        instance.print();
    }

    private void checkPassword(String str) {

        if (str.length() != 9) {
            System.out.println("Passwort zu kurz");
        }

        if (!checkCapital(str)) {
            System.err.println("Passwort enthaelt keinen Grossbuchstaben");
        }

        if (!checkLowerCase(str)) {
            System.err.println("Passwort enthaelt keinen Kleinbuchstaben.");
        }

        if (!checkNumbers(str)) {
            System.err.println("Passwort enthaelt keine Ziffern.");
        }

        if (!checkSpecialChar(str)) {
            System.err.println("Passwort enthaelt kein Sonderzeichen.");
        }

        if (!checkedCases()) {
            System.err.println("Passwort ungleich der vorgegebenen Regeln");
        }

    }

    private boolean checkSpecialChar(String str) {
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) > -1 && str.charAt(i) <= 47
                    || str.charAt(i) >= 58 && str.charAt(i) <= 64
                    || str.charAt(i) >= 91 && str.charAt(i) <= 96 || str.charAt(i) >= 123) {
                checkedCases[0]++;
                
            }
        }
           if (checkedCases[0] == 0) {
            return false;
        } else {
            return true;
        }
    }

    private boolean checkNumbers(String str) {
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) > 47 && str.charAt(i) < 58) {
                checkedCases[1]++;

            }
        }
        if (checkedCases[1] == 0) {
            return false;
        } else {
            return true;
        }
    }

    private boolean checkCapital(String str) {
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) > 64 && str.charAt(i) < 91) {
                checkedCases[2]++;
                
            }
        }
         if (checkedCases[2] == 0) {
            return false;
        } else {
            return true;
        }
    }

    private boolean checkLowerCase(String str) {
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) > 96 && str.charAt(i) < 123) {
                checkedCases[3]++;
            
            }
        }
           if (checkedCases[3] == 0) {
            return false;
        } else {
            return true;
        }
    }

    private boolean checkedCases() {
        for (int i = 0; i < this.checkedCases.length; i++) {
            if (this.checkedCases[i] < 2) {
                return false;
            }
        }
        return true;
    }

}

Lösung von: Robert König (Universität Passau)

use strict;

print checkPW("password").$/;
print checkPW("passwordt").$/;
print checkPW("PaSswordt").$/;
print checkPW("2PaSsword5").$/;
print checkPW("2PaSs/word5@").$/;

sub checkPW {
return("length must longer than 9!") unless(length $_[0] >= 9);
return("no upper-case!") unless($_[0] =~ /^.*[A-Z].*[A-Z].*$/o);
return("no lower-case!") unless($_[0] =~ /^.*[a-z].*[a-z].*$/o);
return("no numbers!") unless($_[0] =~ /^.*[0-9].*[0-9].*$/o);
return("no special chars!") unless($_[0] =~ /.*[^A-Za-z0-9\n].*[^A-Za-z0-9\n].*/o);
return("OK");
}

Lösung von: Paul Scheinast (http://scheinast.eu)

function isValidPW(str) {
   if (
      str.length < 9 ||                      // kürzer als 9 zeichen
      str.match(/[A-Z]/g).length < 2 ||      // keine 2 großbuchstaben
      str.match(/[a-z]/g).length < 2 ||      // keine 2 kleinbuchstaben
      str.match(/\d/g).length < 2 ||         // keine 2 ziffern
      str.match(/[^a-zA-Z\d]/g).length < 2   // keine 2 sonderzeichen
      ) return false;
   return true;
}

console.log(isValidPW(prompt("Passwort:")));

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

#include <stdio.h>

int isValid(char *pw) 
{
	int i = 0;
	int countBig = 0;
	int countsmall = 0;
	int iNumber = 0;
	int iSpecial = 0;
	int ascii = 0;

	while (1)
	{
		if (*pw == '\n')
			break;
		else
		{
			ascii = (int)*pw;

			if (ascii >= 65 && ascii <= 90)
				countBig++;
			else if (ascii >= 97 && ascii <= 122)
				countsmall++;
			else if (ascii >= 48 && ascii <= 57)
				iNumber++;
			else
				iSpecial++;
			i++;
			pw++;
		}
	}

	if (countBig >= 2 && countsmall >= 2 && iNumber >= 2 && iSpecial >= 2 && i >= 9)
		return 1;
	else
		return 0;
}

int main() 
{
	char input[100] = {""};
	fgets(input, 100, stdin);

	if(isValid(&input))
	{
		printf("Good Password\n");
	}
	else
	{
		printf("Bad Password\n");
	}

	fgets(input, 100, stdin);

	return 0;
}

Lösung von: Name nicht veröffentlicht

HTML-Code:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="strongPassword.php" method="post">
    <input type="text" name="pwd">Tragen Sie hier Ihr Passwort ein<br></input>
    <input type="submit" value="Abschicken" /><input type="reset" />
</form>


</body>
</html>


PHP-Code:

<?php
$pwd = $_POST['pwd'];

if (preg_match("#.*^(?=.{8,20})(?=.*[a-z]{2})(?=.*[A-Z]{2})(?=.*[0-9]{2})(?=.*\W{2}).*$#", $pwd)){
    echo "Ein starkes Passwort, du hast.";
} else {
    echo "Ein schwaches Passwort, du hast.";
}
?>

Lösung von: Maik Scheiermann (Powercloud GmbH)


def testPW(password):
    b = []
    s = []
    n = []
    sp = []
    if(len(password) >= 9):
        for i in password:
            if(i.islower()):
                s.append(i)
            elif(i.isupper()):
                b.append(i)
            elif(i.isdigit()):
                n.append(i)
            else:
                sp.append(i)

        if(len(s) >= 2 and len(b) >= 2 and len(n) >=2 and len(sp) >=2):
            return True
        else:
            return False
        
    else:
        return False

passwords = ["aAbB77%_4b","aAbB73%_","aabb73%_sicher","AbC73%_38"]
for i in passwords:
    print testPW(i)

Lösung von: Name nicht veröffentlicht

// NET Core 3.x; C# 8.x

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace CS_Aufgabe_Gueltigkeit_Passwort
{
    class Program
    {
        static void Main(string[] args)
        {
            const string p = "'dAbB54?4_f";
            var l = new List<string>() { @"\d", @"[a-z]", @"[A-Z]", @"[^ ^A-Za-z0-9]" };
            var r = p.Length >= 9 && l.Where(x => new Regex(x).Matches(p).Count >= 2).Count() == 4 ? "valid" : "invalid";
            Console.WriteLine($"Password { p } is { r }");
        }
    }
}

Lösung von: Jens Kelm (@JKooP)

// C++ 14 | VS-2022
#include <iostream>

const auto check_password(const std::string& pwd) {
    auto low{ 0 }, upp{ 0 }, dig{ 0 }, spe{ 0 };
    if (pwd.length() < 9) return false;
    for (const auto& c : pwd) {
        if (std::isalpha(c)) std::islower(c) ? low++ : upp++;
        else if (std::isdigit(c)) dig++;
        else spe++;
    }
    return low > 1 && upp > 1 && dig > 1 && spe > 1;
}

int main() {
    const std::string pwd1{ "'dAbB54?4_f" };
    std::cout << (check_password(pwd1) ? "valid" : "invalid") << "\n";
}

Lösung von: Jens Kelm (@JKooP)

// NET 7.x | C# 11.x | VS-2022
static bool CheckPassword(string pwd) {
    uint low = 0, upp = 0, dig = 0, spe = 0;
    if (pwd.Length < 9) return false;
    foreach (var c in pwd) {
        if (char.IsAsciiLetterLower(c)) low++;
        else if (char.IsAsciiLetterUpper(c)) upp++;
        else if (char.IsAsciiDigit(c)) dig++;
        else spe++;
    }
    return low > 1 && upp > 1 && dig > 1 && spe > 1;
}
Console.WriteLine(CheckPassword("'dAbB54?4_f"));

Lösung von: Jens Kelm (@JKooP)

// C++ 14 | VS-2022
#include <iostream>
#include <regex>
#include <vector>

const auto check_password(const std::string& pwd) {
    const auto is_match{ [&pwd](const std::string& pattern) {
    std::vector<std::smatch>v{};
    const std::regex reg(pattern);
    std::sregex_iterator next{ pwd.begin(), pwd.end(), reg }, end;
    while (next != end) {
        const std::smatch match = *next;
        v.push_back(match);
        next++;
    }
    return v.size() > 1;
    } };

    if (pwd.length() < 9) return false;
    return is_match("[a-z]") && is_match("[A-Z]") && is_match("\\d") && is_match("[^ ^A-Za-z0-9]");
}

int main() {
    const std::string pwd1{ "'dAbB54?4_f" };
    std::cout << (check_password(pwd1) ? "valid" : "invalid") << "\n";
}

Lösung von: Jens Kelm (@JKooP)

' VBA
Function IsMatch(ByVal txt$, ByVal pat$, Optional cnt% = 1)
    With CreateObject("VBScript.RegExp")
        .pattern = pat
        Set m = .Execute(txt)
    End With
    IsMatch = m.Count >= cnt
End Function

Function CheckPassword(ByVal txt$)
    CheckPassword = Len(txt) > 8 And _
    IsMatch(txt, "[a-z]") And _
    IsMatch(txt, "[A-Z]") And _
    IsMatch(txt, "\d") And _
    IsMatch(txt, "[^ ^A-Za-z0-9]")
End Function

Sub Main()
    Const txt$ = "'dAbB54?4_f"
    Debug.Print CheckPassword(txt)
End Sub

Lösung von: Jens Kelm (@JKooP)

// C++ 14 | VS-2022
#include <iostream>

struct type {
    bool required{ true };
    unsigned num_of_chars{ 2 };
    friend const std::ostream& operator<<(std::ostream& os_, const type& ty_) {
        os_ << (ty_.required ? "Ja  " : "Nein");
        os_ << " (" << (ty_.required ?  ty_.num_of_chars : 0) << ")";
        return os_;
    }
};

struct type_set {
    std::string password;
    type lower_case, upper_case, digit, special;
    unsigned password_length{ 8 };
};

const auto check_password(const type_set& set_) {
    unsigned low{ 0 }, upp{ 0 }, dig{ 0 }, spe{ 0 };
    if (set_.password.length() < set_.password_length) return false;
    for (const auto& c : set_.password) {
        if (std::isalpha(c)) std::islower(c) ? low++ : upp++;
        else if (std::isdigit(c)) dig++;
        else spe++;
    }
    return  !set_.lower_case.required || low >= set_.lower_case.num_of_chars &&
            !set_.upper_case.required || upp >= set_.upper_case.num_of_chars &&
            !set_.digit.required      || dig >= set_.digit.num_of_chars &&
            !set_.special.required    || spe >= set_.special.num_of_chars;
}

const std::ostream& operator<<(std::ostream& os_, const type_set& ts_) {
    os_ << "Passwort:        "   << ts_.password;
    os_ << "\nPasswortlaenge:  " << ts_.password_length;
    os_ << "\nKleinbuchstaben: " << ts_.lower_case;
    os_ << "\nGrossbuchstaben: " << ts_.upper_case;
    os_ << "\nZiffern:         " << ts_.digit;
    os_ << "\nSonderzeichen:   " << ts_.special;
    os_ << "\nGueltig:         " << (check_password(ts_) ? "Ja" : "Nein") << "\n";
    return os_ << "\n";
}

int main() {
    const std::string pwd{ "'dAbB54?4_f" };
    const type low{ false };                            /* kein Kleinbuchstabe gefordert */
    const type upp{ };                                  /* Standard (true, 2) */
    const type dig{ true, 1 };                          /* nur eine Ziffer gefordert */
    const type spe{ true };                             /* bleibt Standard (true, 2) */
    const type_set ts1{ pwd, low, upp, dig, spe };      /* Standard (8 Zeichen) */
    const type_set ts2{ pwd, low, upp, dig, spe, 10 };  /* Passwortlänge 10 Zeichen */
    std::cout << ts1;
    std::cout << ts2;
}

Lösung von: Jens Kelm (@JKooP)

Verifikation/Checksumme:

Gültig: aAbB77%_4b

Ungültig: aAbB73%_ (zu kurz)

Ungültig: aabb73%_sicher (keine Großbuchstaben)

Ungültig: AbC73%_38 (nur ein Kleinbuchstabe)

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 1
Schwierigkeit: Mittel
Webcode: xy54-zafk
Autor: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen