it-swarm-tr.com

Bir şifrenin gücünü kontrol etmenin en iyi yolu nedir?

Kullanıcı tarafından sağlanan bir şifrenin bir kayıt ya da şifre değişikliği şeklinde güçlü bir şifre olmasını sağlamanın en iyi yolu nedir?

Bir fikrim var (python içinde)

def validate_password(passwd):
    conditions_met = 0
    conditions_total = 3
    if len(passwd) >= 6: 
        if passwd.lower() != passwd: conditions_met += 1
        if len([x for x in passwd if x.isdigit()]) > 0: conditions_met += 1
        if len([x for x in passwd if not x.isalnum()]) > 0: conditions_met += 1
    result = False
    print conditions_met
    if conditions_met >= 2: result = True
    return result
42
Ed L

1: Sık kullanılan şifreleri kaldırın
Girilen şifreleri sık kullanılan şifrelerin listesine karşı kontrol edin (örneğin, sızan LinkedIn şifresi listesindeki ilk 100.000 şifreye bakın: http://www.adeptus-mechanicus.com/codex /linkhap/combo_not.Zip ), leetspeek ikamelerini eklediğinizden emin olun: A @, E3, B8, S5, vb.
Aşağıdaki bölüm 2'ye geçmeden önce, bu listeye isabet eden parolanın girilen cümle bölümünden silin.

2: Kullanıcıya herhangi bir kural koymayın

Şifrelerin altın kuralı artık daha iyi.
Büyük harf, sayı ve sembollerin zorla kullanımı hakkında unutun, çünkü (büyük çoğunluğu) kullanıcılar: - İlk harfi büyük harf yap; - 1 sayısını sonuna koyunuz; - Bir sembol gerekiyorsa bundan sonra ! yazın.

Bunun yerine şifre gücünü kontrol et

İyi bir başlangıç ​​noktası için bakınız: http://www.passwordmeter.com/

Asgari olarak aşağıdaki kuralları öneririm:

Additions (better passwords)
-----------------------------
- Number of Characters              Flat       +(n*4)   
- Uppercase Letters                 Cond/Incr  +((len-n)*2)     
- Lowercase Letters                 Cond/Incr  +((len-n)*2)     
- Numbers                           Cond       +(n*4)   
- Symbols                           Flat       +(n*6)
- Middle Numbers or Symbols         Flat       +(n*2)   
- Shannon Entropy                   Complex    *EntropyScore

Deductions (worse passwords)
----------------------------- 
- Letters Only                      Flat       -n   
- Numbers Only                      Flat       -(n*16)  
- Repeat Chars (Case Insensitive)   Complex    -    
- Consecutive Uppercase Letters     Flat       -(n*2)   
- Consecutive Lowercase Letters     Flat       -(n*2)   
- Consecutive Numbers               Flat       -(n*2)   
- Sequential Letters (3+)           Flat       -(n*3)   
- Sequential Numbers (3+)           Flat       -(n*3)   
- Sequential Symbols (3+)           Flat       -(n*3)
- Repeated words                    Complex    -       
- Only 1st char is uppercase        Flat       -n
- Last (non symbol) char is number  Flat       -n
- Only last char is symbol          Flat       -n

Sadece takip etmek şifre ölçer yeterli değil, çünkü kesin algoritmasını görüyor Password1! iyi, oysa son derece zayıf. Sayıların yanı sıra izleyen sayıların ve sembollerin yanı sıra (son 3 kurala göre) puanlama yaparken ilk büyük harfleri göz ardı ettiğinizden emin olun.

Shannon entropisinin hesaplanması
Bakınız: Python'da entropi hesaplamanın en hızlı yolu

3: Çok zayıf olan şifrelere izin verme
Kullanıcıyı kendi kendini yitiren kurallara bükmeye zorlamak yerine, yeterince yüksek puan verecek her şeye izin ver. Kullanım çantanızın ne kadar yüksek olduğuna bağlı olarak değişir.

Ve en önemlisi
Şifreyi kabul edip bir veritabanında sakladığınızda, tuz ve hash olduğundan emin olun! .

4
Johan

Dile bağlı olarak, genellikle olup olmadığını kontrol etmek için normal ifadeler kullanırım:

  • En az bir büyük harf ve bir Küçük harf
  • En az bir numara
  • En az bir özel karakter
  • En az altı karakter uzunluğunda

Yukarıdakilerin tümünü isteyebilirsiniz veya bir güç ölçer tipi komut dosyası kullanabilirsiniz. Güç ölçerime göre, şifre doğru uzunluğa sahipse, aşağıdaki şekilde değerlendirilir:

  • Bir koşul gerçekleşti: zayıf şifre
  • İki koşul karşılandı: orta boy şifre
  • Tüm koşullar karşılandı: güçlü şifre

İhtiyaçlarınızı karşılamak için yukarıdakileri ayarlayabilirsiniz.

18
VirtuosiMedia

Nesneye yönelik yaklaşım bir dizi kural olacaktır. Her kurala bir ağırlık atayın ve içlerinde yineleyin. Psuedo kodunda:

abstract class Rule {

    float weight;

    float calculateScore( string password );

}

Toplam puanın hesaplanması:

float getPasswordStrength( string password ) {     

    float totalWeight = 0.0f;
    float totalScore  = 0.0f;

    foreach ( rule in rules ) {

       totalWeight += weight;
       totalScore  += rule.calculateScore( password ) * rule.weight;

    }

    return (totalScore / totalWeight) / rules.count;

}

Mevcut karakter sınıflarının sayısına göre örnek bir kural algoritması:

float calculateScore( string password ) {

    float score = 0.0f;

    // NUMBER_CLASS is a constant char array { '0', '1', '2', ... }
    if ( password.contains( NUMBER_CLASS ) )
        score += 1.0f;

    if ( password.contains( UPPERCASE_CLASS ) )
        score += 1.0f;

    if ( password.contains( LOWERCASE_CLASS ) )
        score += 1.0f;

    // Sub rule as private method
    if ( containsPunctuation( password ) )
        score += 1.0f;

    return score / 4.0f;

}
9
user9116

Denetlenecek en basit iki ölçüm şunlardır:

  1. Uzunluğu. En az 8 karakter söyleyebilirim.
  2. Şifrenin içerdiği farklı karakter sınıflarının sayısı. Bunlar genellikle küçük harfler, büyük harfler, sayılar, noktalama işaretleri ve diğer sembollerdir. Güçlü bir şifre, bu sınıfların en az üçünden karakterleri içerecektir; Bir sayı veya alfabetik olmayan bir karakter zorlarsanız, sözlük saldırılarının etkinliğini önemli ölçüde azaltırsınız.
3
Dave Webb

Cracklib harika ve yeni paketlerde bunun için bir Python modülü mevcut. Ancak, CentOS 5 gibi henüz sahip olmayan sistemlerde, cryptlib sistemi için bir klişe sarıcı yazdım. Bu aynı zamanda python-libcrypt programını kuramayacağınız bir sistem üzerinde de çalışacaktır. Bu does ctypes kullanılabilir python gerektirdiğinden, CentOS 5 için python26 paketini kurmanız ve kullanmanız gerekir.

Ayrıca "FascistGecos" libcrypt işlevi gibi, ancak/etc/passwd içinde kullanıcının bulunmasını gerektirmeden, kullanıcı adını alıp içeren veya büyük ölçüde benzer olan şifreleri kontrol edebilme avantajına sahiptir.

ctypescracklib kütüphanem github'da mevcuttur

Bazı örnek kullanır:

>>> FascistCheck('jafo1234', 'jafo')
'it is based on your username'
>>> FascistCheck('myofaj123', 'jafo')
'it is based on your username'
>>> FascistCheck('jxayfoxo', 'jafo')
'it is too similar to your username'
>>> FascistCheck('cretse')
'it is based on a dictionary Word'
2

diğer yararlı cevapları okuduktan sonra, gidiyorum budur:

-1 kullanıcı adıyla aynı
+ 0 kullanıcı adı içeriyor
+ 1'den fazla 7 karakter
+ 1, 11 karakterden fazla
+ 1 basamak içeriyor
+ 1 küçük ve büyük harf karışımı
+ 1 noktalama işaretleri içeriyor
+ 1 yazdırılamaz karakter 

pwscore.py:

import re
import string
max_score = 6
def score(username,passwd):
    if passwd == username:
        return -1
    if username in passwd:
        return 0
    score = 0
    if len(passwd) > 7:
        score+=1
    if len(passwd) > 11:
        score+=1
    if re.search('\d+',passwd):
        score+=1
    if re.search('[a-z]',passwd) and re.search('[A-Z]',passwd):
        score+=1
    if len([x for x in passwd if x in string.punctuation]) > 0:
        score+=1
    if len([x for x in passwd if x not in string.printable]) > 0:
        score+=1
    return score

örnek kullanım:

import pwscore
    score = pwscore(username,passwd)
    if score < 3:
        return "weak password (score=" 
             + str(score) + "/"
             + str(pwscore.max_score)
             + "), try again."

muhtemelen en verimli değil, ama makul görünüyor. emin değilim FascistCheck => 'kullanıcı adına çok benzer' buna değer.

'abc123ABC! @ £' = kullanıcı adının bir üst kümesi değilse 6/6 puan

belki bu daha düşük puan almalıdır.

2
siznax

Var olan bir şifre veritabanını kontrol etmenin harika bir yolu olan açık ve ücretsiz Ripper password krakeri var.

1
tante

İşte kullandığım şey:

   var getStrength = function (passwd) {
    intScore = 0;
    intScore = (intScore + passwd.length);
    if (passwd.match(/[a-z]/)) {
        intScore = (intScore + 1);
    }
    if (passwd.match(/[A-Z]/)) {
        intScore = (intScore + 5);
    }
    if (passwd.match(/\d+/)) {
        intScore = (intScore + 5);
    }
    if (passwd.match(/(\d.*\d)/)) {
        intScore = (intScore + 5);
    }
    if (passwd.match(/[!,@#$%^&*?_~]/)) {
        intScore = (intScore + 5);
    }
    if (passwd.match(/([!,@#$%^&*?_~].*[!,@#$%^&*?_~])/)) {
        intScore = (intScore + 5);
    }
    if (passwd.match(/[a-z]/) && passwd.match(/[A-Z]/)) {
        intScore = (intScore + 2);
    }
    if (passwd.match(/\d/) && passwd.match(/\D/)) {
        intScore = (intScore + 2);
    }
    if (passwd.match(/[a-z]/) && passwd.match(/[A-Z]/) && passwd.match(/\d/) && passwd.match(/[!,@#$%^&*?_~]/)) {
        intScore = (intScore + 2);
    }
    return intScore;
} 
1
varun

Küçük bir Javascript uygulaması yazdım. Bir göz atın: Yine Başka Şifre Ölçer . Kaynağı indirebilir ve GPL altında kullanabilir/değiştirebilirsiniz. İyi eğlenceler!

0
ReneS

Bunu faydalı bulabilecek biri var mı bilmiyorum ama phear'ın önerdiği gibi bir kural kümesi fikrini gerçekten sevdim, bu yüzden Python 2.6 sınıfına girip bir kural yazdım (muhtemelen 2.5 ile uyumlu olmasına rağmen):

import re

class SecurityException(Exception):
    pass

class Rule:
    """Creates a rule to evaluate against a string.
    Rules can be regex patterns or a boolean returning function.
    Whether a rule is inclusive or exclusive is decided by the sign
    of the weight. Positive weights are inclusive, negative weights are
    exclusive. 


    Call score() to return either 0 or the weight if the rule 
    is fufilled. 

    Raises a SecurityException if a required rule is violated.
    """

    def __init__(self,rule,weight=1,required=False,name=u"The Unnamed Rule"):
        try:
            getattr(rule,"__call__")
        except AttributeError:
            self.rule = re.compile(rule) # If a regex, compile
        else:
            self.rule = rule  # Otherwise it's a function and it should be scored using it

        if weight == 0:
            return ValueError(u"Weights can not be 0")

        self.weight = weight
        self.required = required
        self.name = name

    def exclusive(self):
        return self.weight < 0
    def inclusive(self):
        return self.weight >= 0
    exclusive = property(exclusive)
    inclusive = property(inclusive)

    def _score_regex(self,password):
        match = self.rule.search(password)
        if match is None:
            if self.exclusive: # didn't match an exclusive rule
                return self.weight
            Elif self.inclusive and self.required: # didn't match on a required inclusive rule
                raise SecurityException(u"Violation of Rule: %s by input \"%s\"" % (self.name.title(), password))
            Elif self.inclusive and not self.required:
                return 0
        else:
            if self.inclusive:
                return self.weight
            Elif self.exclusive and self.required:
                raise SecurityException(u"Violation of Rule: %s by input \"%s\"" % (self.name,password))
            Elif self.exclusive and not self.required:
                return 0

        return 0

    def score(self,password):
        try:
            getattr(self.rule,"__call__")
        except AttributeError:
            return self._score_regex(password)
        else:
            return self.rule(password) * self.weight

    def __unicode__(self):
        return u"%s (%i)" % (self.name.title(), self.weight)

    def __str__(self):
        return self.__unicode__()

Umarım birileri bunu yararlı bulur!

Örnek Kullanım:

rules = [ Rule("^foobar",weight=20,required=True,name=u"The Fubared Rule"), ]
try:
    score = 0
    for rule in rules:
        score += rule.score()
except SecurityException e:
    print e 
else:
    print score

YASAL UYARI: Birim test edilmedi

0
SapphireSun

Alfa, sayısal ve sembollerin karıştırılması standart yaklaşımına ek olarak, geçen hafta MyOpenId'e kaydolduğumda fark ettim, şifre denetleyicisi, şifreniz bir sözlük kelimesine dayanıyorsa, numaralar ekleseniz veya alfaları benzer numaralarla değiştirseniz bile ('o' yerine sıfır, 'i' yerine '1' vb. kullanarak).

Çok etkilendim.

0
Steve Morgan