是否有可读且可发音的Python密码生成器？

在Python中生成一个随机字符串（如shows）非常简单。但是，是否有任何Python项目可以生成一些既可发音又可读的密码字符串？所谓可读性，我的意思是不把零和O都放在同一个字符串中，等等。我不在乎它是否具有最大熵，只是一些比我可能选择的更好的东西。：）

你可以创建一个简单的单词，然后用一系列常用/可发音的单词来训练它

不久前，为了好玩，我写了一个简单的生成器。这是：

#! /usr/bin/python

from cStringIO import StringIO
from sys import argv
import random

USAGE="usage: ./markov.py input_file"
END_TAG='<end>'
SEPARATOR='\n'

def append(model,token, target):
    if token not in model:
        model[token]=[]
    model[token].append(target)

def add_to_model(model,word, end_tag=END_TAG):
    append(model,'',word[:2])
    for i in xrange(len(word)-2):
        append(model, word[i:i+2],word[i+2])
    append(model,word[-2:],end_tag)

def generate(model, end_tag=END_TAG):
    ret=''
    while True:
        cur=random.choice(model[ret[-2:]])
        if cur==end_tag:
            break
        else:
            ret+=cur
    return ret

if __name__=='__main__':
    if len(argv)>1:
        data=file(argv[1],'r').read().split(SEPARATOR)
        model={}
        for word in data:
            add_to_model(model,word)
        print generate(model)
    else:
        print USAGE

#/usr/bin/python
从cStringIO导入StringIO
从系统导入argv
随机输入
用法=“用法：./markov.py输入文件”
结束标记=“”
分隔符='\n'
def追加（型号、令牌、目标）：
如果令牌不在模型中：
模型[令牌]=[]
模型[token]。追加（目标）
def add_to_model（model，word，end_tag=end_tag）：
追加（型号“”，单词[：2]）
对于X范围内的i（len（word）-2）：
追加（型号，单词[i:i+2]，单词[i+2]）
追加（型号，单词[-2:]，结束标记）
def生成（型号，结束标记=结束标记）：
ret=''
尽管如此：
cur=random.choice（模型[ret[-2:]）
如果cur==结束标记：
打破
其他：
ret+=cur
回程网
如果“名称”=“\uuuuuuuu主要”：
如果len（argv）>1：
数据=文件（argv[1]，'r'）.read（）.split（分隔符）
模型={}
对于word输入数据：
将\添加到\模型（模型，word）
打印生成（模型）
其他：
打印使用

如果你真的只是在寻找“比我能弥补的更好”的东西 “可发音”，然后可以使用

random.sample（）

从 辅音-元音-辅音假音节：

import string
import itertools
import random

initial_consonants = (set(string.ascii_lowercase) - set('aeiou')
                      # remove those easily confused with others
                      - set('qxc')
                      # add some crunchy clusters
                      | set(['bl', 'br', 'cl', 'cr', 'dr', 'fl',
                             'fr', 'gl', 'gr', 'pl', 'pr', 'sk',
                             'sl', 'sm', 'sn', 'sp', 'st', 'str',
                             'sw', 'tr'])
                      )

final_consonants = (set(string.ascii_lowercase) - set('aeiou')
                    # confusable
                    - set('qxcsj')
                    # crunchy clusters
                    | set(['ct', 'ft', 'mp', 'nd', 'ng', 'nk', 'nt',
                           'pt', 'sk', 'sp', 'ss', 'st'])
                    )

vowels = 'aeiou' # we'll keep this simple

# each syllable is consonant-vowel-consonant "pronounceable"
syllables = map(''.join, itertools.product(initial_consonants, 
                                           vowels, 
                                           final_consonants))

# you could trow in number combinations, maybe capitalized versions... 

def gibberish(wordcount, wordlist=syllables):
    return ' '.join(random.sample(wordlist, wordcount))

然后，您只需选择适当数量的“单词”：

我的统计数据有点模糊，但这对于非国家安全局来说可能就足够了 目的。请注意，

random.sample（）

无需更换即可运行。我还应该指出，如果恶意方知道您正在使用此方法，它将容易受到字典攻击。一小撮咖啡会有帮助的

---

更新：对于那些感兴趣的人，可以从以下网址获得更新的、可分叉的版本。

我喜欢西蒙·萨宾的版本：

我想我所从事的项目是适用的。我从超过1400万个密码（来自RockYou.com密码转储）中学习了马尔可夫模型，并以这种方式创建了人工密码。博客文章（以及附带的代码）如下所示。一些人工密码：

• 表111
• genny0
• mikk92
• 吕明锐10633769
• bubuzzarap71666
• Isamistillo13020
• dunl0velyiristalecasia4799

我是这部电影的忠实粉丝。非常可定制，pip可安装，“acrostic”功能为用户提供了一个很好的方法，为他们生成的单词集提供记忆线索。

胡言乱语

import string
import random

__all__ = ('generate_word', 'generate_words')

initial_consonants = list(set(string.ascii_lowercase) - set('aeiou')
                      # remove those easily confused with others
                      - set('qxc')
                      # add some crunchy clusters
                      | set(['bl', 'br', 'cl', 'cr', 'dr', 'fl',
                             'fr', 'gl', 'gr', 'pl', 'pr', 'sk',
                             'sl', 'sm', 'sn', 'sp', 'st', 'str',
                             'sw', 'tr', 'ch', 'sh'])
                      )

final_consonants = list(set(string.ascii_lowercase) - set('aeiou')
                    # remove the confusables
                    - set('qxcsj')
                    # crunchy clusters
                    | set(['ct', 'ft', 'mp', 'nd', 'ng', 'nk', 'nt',
                           'pt', 'sk', 'sp', 'ss', 'st', 'ch', 'sh'])
                    )

vowels = 'aeiou'


def generate_word():
    """Returns a random consonant-vowel-consonant pseudo-word."""
    return ''.join(random.choice(s) for s in (initial_consonants,
                                              vowels,
                                              final_consonants))


def generate_words(wordcount):
    """Returns a list of ``wordcount`` pseudo-words."""
    return [generate_word() for _ in range(wordcount)]


def console_main():
    import sys
    try:
        wordcount = int(sys.argv[1])
    except (IndexError, ValueError):
        wordcount = 1
    print(' '.join(generate_words(wordcount)))


if __name__ == '__main__':
    console_main()

---

看起来很有趣-它会产生多少熵？我假设它是基于输入文件的，所以如果我在文本文件中有很多数字和符号，它会更强大。但是，如何避免零和“0”同时出现，或1/l？或者这也是基于输入文件-因此，如果文件中没有相同的字符串，马尔可夫生成器将学习不将它们放在一起？事实上，在评论之后，我突然想到我可以省略1/0-这似乎会导致我在读取计算机生成的密码时出现90%的问题。：）@约翰C：没错。生成的字符串完全取决于输入文件的内容。这类似于我在1995年使用的算法，用于为在线服务上的试用帐户生成随机密码。除了我在Applesoft BASIC中写的以外。：-）我的算法偶尔会在元音之前或之后插入一个

h

，以增加exhoticness.@kindall+1“exhoticness”。也许我会添加

oy

，

ji

，

ch

，

ee

，

zz

，

fj

，和

tz

，来增加一点多元文化的味道=）我要注意的另一件事。。。你必须小心，这东西不会引起亵渎。我的程序中有一个步骤，如果它包含某些顽皮的子字符串，就会抛出一个伪单词。通过不将“ck”作为终端集群，您做得很好，但我认为您的代码仍然可以生成一些非常粗俗的单词。嗯，也许不是。。。你也把第一个位置的“c”去掉了，说得好。不要让任何人在你输入密码短语时偷听到你在低语某些精选词。想要一些与你的劝告相符吗？顺便说一句，你可能会发现相关：）@MAK，可爱-这有点像建立第二个AI来追捕流氓AI…）（巧合的是，福岛核反应堆成了所有新闻）。这看起来几乎和投票结果最接近的答案一模一样，包括一些评论，唯一真正的区别是

main（）

函数。如果你要改变别人的答案，你真的应该给他们一些信任。

import string
import random

__all__ = ('generate_word', 'generate_words')

initial_consonants = list(set(string.ascii_lowercase) - set('aeiou')
                      # remove those easily confused with others
                      - set('qxc')
                      # add some crunchy clusters
                      | set(['bl', 'br', 'cl', 'cr', 'dr', 'fl',
                             'fr', 'gl', 'gr', 'pl', 'pr', 'sk',
                             'sl', 'sm', 'sn', 'sp', 'st', 'str',
                             'sw', 'tr', 'ch', 'sh'])
                      )

final_consonants = list(set(string.ascii_lowercase) - set('aeiou')
                    # remove the confusables
                    - set('qxcsj')
                    # crunchy clusters
                    | set(['ct', 'ft', 'mp', 'nd', 'ng', 'nk', 'nt',
                           'pt', 'sk', 'sp', 'ss', 'st', 'ch', 'sh'])
                    )

vowels = 'aeiou'


def generate_word():
    """Returns a random consonant-vowel-consonant pseudo-word."""
    return ''.join(random.choice(s) for s in (initial_consonants,
                                              vowels,
                                              final_consonants))


def generate_words(wordcount):
    """Returns a list of ``wordcount`` pseudo-words."""
    return [generate_word() for _ in range(wordcount)]


def console_main():
    import sys
    try:
        wordcount = int(sys.argv[1])
    except (IndexError, ValueError):
        wordcount = 1
    print(' '.join(generate_words(wordcount)))


if __name__ == '__main__':
    console_main()