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
20 Lösung(en)
- java
- python
- pl1
- python
- java
- pl1
- c
- python
- java
- perl
- javascript
- c
- php
- python
- csharp
- cpp
- csharp
- cpp
- vb
- cpp
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
Neue Lösung hinzufügen
Bewertung
Durchschnittliche Bewertung:
Meta
| Zeit: | 1 |
| Schwierigkeit: | Mittel |
| Webcode: | xy54-zafk |
| Autor: | Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch) |
Kommentare (1)