def generate_config(self, env_script, start_script, server_cert=None): """Generates the plugin configuration file Parameters ---------- env_script : str The CLI call used to load the environment in which the plugin is installed start_script : str The script used to start the plugin server_cert : str, optional If the Qiita server used does not have a valid certificate, the path to the Qiita certificate so the plugin can connect over HTTPS to it """ logger.debug('Entered BaseQiitaPlugin.generate_config()') sr = SystemRandom() chars = ascii_letters + digits client_id = ''.join(sr.choice(chars) for i in range(50)) client_secret = ''.join(sr.choice(chars) for i in range(255)) server_cert = server_cert if server_cert else "" with open(self.conf_fp, 'w') as f: f.write(CONF_TEMPLATE % (self.name, self.version, self.description, env_script, start_script, self._plugin_type, self.publications, server_cert, client_id, client_secret))
def insert_special_char(word, specials=SPECIAL_CHARS, rnd=None): """Insert a char out of `specials` into `word`. `rnd`, if passed in, will be used as a (pseudo) random number generator. We use `.choice()` only. Returns the modified word. """ if rnd is None: rnd = SystemRandom() char_list = list(word) char_list[rnd.choice(range(len(char_list)))] = rnd.choice(specials) return ''.join(char_list)
def createUserSessionKey(org, username, sessionId, consistency=ConsistencyLevel.LOCAL_QUORUM, session=None): """ Create a session key record in the usersessionkeys table for the given user session :org: Name of organization for the user :username: Name of the user :sessionid: ID of the session to create a key for """ charList = (list(range(48, 58)) + # Numbers list(range(65, 91)) + # Uppercase list(range(97, 123))) # Lowercase sysrand = SystemRandom() sessionKey = ''.join( chr(sysrand.choice(charList)) for i in range(64)) try: createUserSessionKeyQuery = CassandraCluster.getPreparedStatement( """ INSERT INTO usersessionkeys ( sessionkey, org, username, sessionid ) VALUES ( ?, ?, ?, ? ) """, keyspace=session.keyspace) createUserSessionKeyQuery.consistency_level = consistency session.execute(createUserSessionKeyQuery, (sessionKey, org, username, sessionId)) return sessionKey except Exception as e: log.critical("Exception in AuthDB.createUserSessionKey: %s" % (e,))
def random_password(description, min_chars=10, max_chars=20): """ Creates a random password from uppercase letters, lowercase letters and digits with a length between min_chars and max_chars """ # Open saved passwords file or create new one. try: fh = open("info/passwords.json", "r+") passwords = json.load(fh) except IOError: fh = open("info/passwords.json", "w+") passwords = {} # Return password if it exists already if description in passwords: fh.close() return passwords[description] # Create new password if it does not exist else: seeded_random = SystemRandom() chars = ascii_letters + digits password_length = seeded_random.randint(min_chars, max_chars) password = "".join(seeded_random.choice(chars) for _ in range(password_length)) passwords[description] = password fh.seek(0) json.dump(passwords, fh, indent=4) fh.close() return password
def generate(word_list, words=5, specials=0): rnd = SystemRandom() words = [ rnd.choice(word_list) for _ in range(words) ] # Insert at most options.special special characters. This is not # exactly the procedure described in the Diceware web page, because # this handles the case where there are more than 6 words in the # passphrase and more than 6 characters in the word. if specials: split_words = [ map(None, x) for x in words ] for _ in range(specials): # i is the index of the word in which the special character # replacement takes place. i = rnd.randrange(len(split_words)) # j is the index of the character to be replaced with a special # character. j = rnd.randrange(len(split_words[i])) # k is the index of the special character k = rnd.randrange(len(SPECIAL_CHARS)) # Split to individual characters, replace the k'th char, unsplit split_words[i][j] = SPECIAL_CHARS[k] with_specials = [ "".join(x) for x in split_words ] else: with_specials = words return words, with_specials
def generate_password(self): import string from random import SystemRandom rnd = SystemRandom() # use SystemRandom to get real random numbers chars = string.letters + string.digits length = 20 return "".join(rnd.choice(chars) for _ in range(length))
def get_encrypted_password(password, hashtype='sha512', salt=None): # TODO: find a way to construct dynamically from system cryptmethod= { 'md5': '1', 'blowfish': '2a', 'sha256': '5', 'sha512': '6', } if hashtype in cryptmethod: if salt is None: r = SystemRandom() if hashtype in ['md5']: saltsize = 8 else: saltsize = 16 salt = ''.join([r.choice(string.ascii_letters + string.digits) for _ in range(saltsize)]) if not HAS_PASSLIB: if sys.platform.startswith('darwin'): raise errors.AnsibleFilterError('|password_hash requires the passlib python module to generate password hashes on Mac OS X/Darwin') saltstring = "$%s$%s" % (cryptmethod[hashtype],salt) encrypted = crypt.crypt(password, saltstring) else: if hashtype == 'blowfish': cls = passlib.hash.bcrypt; else: cls = getattr(passlib.hash, '%s_crypt' % hashtype) encrypted = cls.encrypt(password, salt=salt) return encrypted return None
def __init__(self, config, director, scheduler, _reactor=reactor): self._reactor = reactor self.director = director self.scheduler = scheduler self.config = config self.measurement_path = FilePath(config.measurements_directory) # We use a double submit token to protect against XSRF rng = SystemRandom() token_space = string.letters+string.digits self._xsrf_token = b''.join([rng.choice(token_space) for _ in range(30)]) self._director_started = False self._is_initialized = config.is_initialized() # We use exponential backoff to trigger retries of the startup of # the director. self._director_startup_retries = 0 # Maximum delay should be 30 minutes self._director_max_retry_delay = 30*60 self.status_poller = LongPoller( self._long_polling_timeout, _reactor) self.director_event_poller = LongPoller( self._long_polling_timeout, _reactor) # XXX move this elsewhere self.director_event_poller.start() self.status_poller.start() self.director.subscribe(self.handle_director_event) if self._is_initialized: self.start_director()
def __init__(self, known_pattern=None, session=db_session): '''Instantiates a color game based on a random color pattern. If known_pattern is specified, this color pattern is used to create the game instead of a random pattern. This should only be used for testing purposes. If session is specified, this DB session is used instead of the standard session. :param known_pattern: a list (or tuple) of one-letter colors (default: None) :param session: the DB session (default: standard color game session) ''' # Make sure to cleanup database resources on exit register(self._cleanup) # Set up DB session self.s = session if known_pattern is None: sr = SystemRandom() self.pattern = [sr.choice(colors_short) for _ in range(PATTERN_LENGTH)] else: self.pattern = known_pattern self.pattern_set = set(self.pattern) self.game = ColorGame(pattern=ColorPattern(self.pattern)) self.s.add(self.game) self.s.commit()
def get_passphrase(wordnum=6, specialsnum=1, delimiter='', lang='en', capitalized=True, wordlist_fd=None): """Get a diceware passphrase. The passphrase returned will contain `wordnum` words deliimted by `delimiter`. If `capitalized` is ``True``, all words will be capitalized. If `wordlist_fd`, a file descriptor, is given, it will be used instead of a 'built-in' wordlist (and `lang` will be ignored). `wordlist_fd` must be open for reading. The wordlist to pick words from is determined by `lang`, representing a language (unless `wordlist_fd` is given). """ if wordlist_fd is None: wordlist_fd = open(get_wordlist_path(lang), 'r') word_list = get_wordlist(wordlist_fd) rnd = SystemRandom() words = [rnd.choice(word_list) for x in range(wordnum)] if capitalized: words = [x.capitalize() for x in words] result = delimiter.join(words) for _ in range(specialsnum): result = insert_special_char(result, rnd=rnd) return result
def createRandomToken(self): '''Create a random byte sequence to use as a repeating token''' r = SystemRandom() token = bytearray() numBytes = r.choice([3, 4, 5, 6]) for i in range(numBytes): token.append(r.randrange(256)) return token
def create_token(length=10) -> bool: r = SystemRandom() token = ''.join([r.choice(string.ascii_lowercase+string.digits) for _ in range(length)]) new_token = RegistrationToken(token) if add_to_db(new_token): return new_token
def generate_token(length=40, chars=UNICODE_ASCII_CHARACTER_SET): """Generates a non-guessable OAuth token OAuth 2.0 rfc does not specify the format of tokens except that they should be strings of random characters. """ from random import SystemRandom rand = SystemRandom() return ''.join(rand.choice(chars) for x in range(length))
def build_slug(): """ Returns a random string made from two words from the wordlist, such as "deter-trig". """ wordlist = open(get_resource_path('wordlist.txt')).read().split('\n') wordlist.remove('') r = SystemRandom() return '-'.join(r.choice(wordlist) for x in range(2))
def rndstr(size=16): """ Returns a string of random ascii characters or digits :param size: The length of the string :return: string """ _basech = string.ascii_letters + string.digits return "".join([rnd.choice(_basech) for _ in range(size)])
def unreserved(size=64): """ Returns a string of random ascii characters, digits and unreserved characters :param size: The length of the string :return: string """ return "".join([rnd.choice(BASECH) for _ in range(size)])
def randstring(length): """ Return a random base62 string of the specified length. """ alphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" string = "" rng = SystemRandom() for i in range(length): string += rng.choice(alphabet) return string
def save_new_secret_key(app): if not os.path.exists(LOCAL_CONFIG_FILE): copy_default_config_to_local() config = ConfigParser() config.read(LOCAL_CONFIG_FILE) rng = SystemRandom() secret_key = "".join([rng.choice(string.ascii_letters + string.digits) for _ in xrange(25)]) app.config['SECRET_KEY'] = secret_key config.set('faraday_server', 'secret_key', secret_key) with open(LOCAL_CONFIG_FILE, 'w') as configfile: config.write(configfile)
def set_secret(secret_filename): #this may throw an error if the file cannot be created, but that's OK, because #then users will know to create it themselves f = open(secret_filename, "w") random = SystemRandom() letters = [chr(ord('A') + i) for i in xrange(26)] letters += [chr(ord('a') + i) for i in xrange(26)] letters += map(str, xrange(10)) password = "".join([random.choice(letters) for i in xrange(10)]) f.write(password) f.close() return password
def test_add(self): r = SystemRandom() for i in range(10): p = getRandPrime(5) while p <= 10: p = getRandPrime(5) e = ecc.ECC(r.randint(1, 100), r.randint(1, 100), p) all_points = list(e.listPointGenerator()) for j in range(100): point1 = r.choice(all_points) point2 = r.choice(all_points) point = e.add(point1, point2) self.assertEqual(e.isInCurve(point), True)
def auth_request(command, manager, options, logger): key = command.data variants = string.digits + string.ascii_letters rand = SystemRandom() size = len(key) client_solt = "".join(rand.choice(variants) for _ in range(size)) content = "{}{}{}".format(options.get("secret"), client_solt, key) _hash = _cr_methods.get(options.get("hash_method")) if hash: content = _hash(bytes(content, "utf-8")).hexdigest() else: content = "no method" return command.create(target=CommandTargetType.auth, data="{}:{}".format(content, client_solt))
def unambiguous_random_string(length): random = SystemRandom() ambiguous_chars = { 'B', '8', 'G', '6', 'I', '1', 'l', '0', 'O', 'Q', 'D', 'S', '5', 'Z', '2' } choices = filter(lambda char: char not in ambiguous_chars, string.digits + string.ascii_lowercase) return ''.join(random.choice(choices) for _ in xrange(length))
def rand(end, start=None, step=None): r = SystemRandom() if isinstance(end, (int, long)): if not start: start = 0 if not step: step = 1 return r.randrange(start, end, step) elif hasattr(end, '__iter__'): if start or step: raise errors.AnsibleFilterError('start and step can only be used with integer values') return r.choice(end) else: raise errors.AnsibleFilterError('random can only be used on sequences and integers')
class WordDB(object): """ Stores statistical markov chain patterns. """ learnfile = None def __init__(self): self.words = {} self.rnd = SystemRandom() def add_link(self, first, second): """ Adds a new link in the chain """ self.words.setdefault(first, list()).append(second) def get_next(self, first): """ Given the current node, pick the next one at random """ return self.rnd.choice(self.words[first]) def generate(self, start=True, stop=False): word = self.get_next(start) while word != stop: yield word word = self.get_next(word) def genline(self, *p, **kw): return ' '.join(self.generate(*p, **kw)) def add_line(self, line): prev = True # Start #TODO: parse out puncuation as seperate nodes for w in line.split(): self.add_link(prev, w) prev = w self.add_link(prev, False) #Finish if self.learnfile is not None: print repr(line) if line[-1] != '\n': line += '\n' self.learnfile.write(line) def load_linefile(self, file): for line in file: self.add_line(line)
def grub2_hash(password, salt=None, iterations=10000): if salt is None: r = SystemRandom() salt = ''.join([r.choice(string.ascii_letters + string.digits) for _ in range(64)]) if not HAS_PASSLIB: if sys.platform.startswith('darwin'): raise errors.AnsibleFilterError('|password_hash requires the passlib python module to generate password hashes on Mac OS X/Darwin') saltstring = "$%s$%s" % (cryptmethod[hashtype],salt) encrypted = grub_pbkdf2_sha512.encrypt(password, salt=salt, rounds=iterations) else: encrypted = grub_pbkdf2_sha512.encrypt(password, salt=salt, rounds=iterations) return encrypted
def generate_question(self): """Generate random question.""" generator = SystemRandom() operation = generator.choice(self.operators) first = generator.randint(self.interval[0], self.interval[1]) second = generator.randint(self.interval[0], self.interval[1]) # We don't want negative answers if operation == '-': first += self.interval[1] return ' '.join(( str(first), operation, str(second) ))
def get_random_string(length): """Creates a random string of the given length with alphanumeric chars Parameters ---------- length : int The desired length of the string Returns ------- str The new random string """ sr = SystemRandom() chars = ascii_letters + digits return ''.join(sr.choice(chars) for i in range(length))
def random_salt_function(salt_len=12): """ Creates random salt for password. :param salt_len: Length of salt. Default :data:`12` :type param: :class:`int` :return: Computed salt :rtype: str """ charset = "abcdefghijklmnopqrstuxyz" charset = charset + charset.upper() + '1234567890' chars = [] rand = SystemRandom() for _ in range(salt_len): chars.append(rand.choice(charset)) return "".join(chars)
def rand(environment, end, start=None, step=None, seed=None): if seed is None: r = SystemRandom() else: r = Random(seed) if isinstance(end, integer_types): if not start: start = 0 if not step: step = 1 return r.randrange(start, end + 1, step) elif hasattr(end, '__iter__'): if start or step: raise AnsibleFilterError('start and step can only be used with integer values') return r.choice(end) else: raise AnsibleFilterError('random can only be used on sequences and integers')
def save(self, *args, **kwargs): """ get ordernumber from database sequence """ if not self.token: gen = SystemRandom() self.token = ''.join(gen.choice(string.ascii_lowercase + string.digits) for x in range(64)) if not self.ordernumber: from django.db import connection cursor = connection.cursor() cursor.execute("SELECT nextval('booking_ordernum_seq')") (ordernum,) = cursor.fetchone() self.ordernumber = str(ordernum) return super(Booking, self).save(*args, **kwargs)
def generate_secure_random_string(N): cryptogen = SystemRandom() return ''.join( cryptogen.choice(string.ascii_uppercase + string.digits) for _ in range(N))
def gen_password(lenght=PWD_DEFAULT_LENGHT): sys_random = SystemRandom() return "".join(sys_random.choice(PWD_ALPHABET) for _ in range(lenght))
#!/usr/bin/env python import sys from secret import flag, Primes from random import SystemRandom from Crypto.Util.number import * Rand = SystemRandom() p = Rand.choice(Primes) q = Rand.choice(Primes) n = p * q e = 65537 sys.stdout.write("n = " + str(n) + '\n') sys.stdout.write("e = " + str(e) + '\n') sys.stdout.write("What do you want to Encrypt :: ") sys.stdout.flush() Inp = sys.stdin.readline().strip('\n') if Inp == 'flag': Inp = flag m = bytes_to_long(Inp) c = pow(m, e, n) sys.stdout.write("c = " + str(c) + '\n') sys.stdout.flush() sys.exit()
import sqlite3 from random import SystemRandom sql_connection = sqlite3.connect('website.db') sql_cursor = sql_connection.cursor() name = input('User Name: ') bio = input('User Bio: ') email = input('User Email: ') rank = int(input('User Rank(0=no, 1=post restrict, 2=post free, 3=admin): ')) assert(name) assert(bio) assert(email) assert(rank >= 0 and rank <= 3) sr = SystemRandom() salt = sr.choice(range(10000000,99999999)) sql_cursor.execute('insert into users values (?, ?, ?, ?, ?)', \ (name, bio, str(salt), email, rank)) sql_connection.commit()
def random_string(length): """Return a random string using the system's RNG.""" rng = SystemRandom() return ''.join(rng.choice(string.printable) for i in range(length))
def _generate_pass(): """Generate a random string of fixed length.""" sysrand = SystemRandom() passwd_charset = string.ascii_letters + string.digits return ''.join([sysrand.choice(passwd_charset) for _ in range(32)])
class PassphraseGenerator: PASSPHRASE_WORDS_COUNT = 7 # Enforce a reasonable maximum length for passphrases to avoid DoS MAX_PASSPHRASE_LENGTH = 128 MIN_PASSPHRASE_LENGTH = 20 _WORD_LIST_MINIMUM_SIZE = 7300 # Minimum number of words in any of the word lists def __init__(self, language_to_words: Dict[str, List[str]], fallback_language: str = "en") -> None: # SystemRandom sources from the system rand (e.g. urandom, CryptGenRandom, etc) # It supplies a CSPRNG but with an interface that supports methods like choice self._random_generator = SystemRandom() self._fallback_language = fallback_language self._language_to_words = language_to_words if self._fallback_language not in self._language_to_words: raise InvalidWordListError( "Missing words list for fallback language '{}'".format( self._fallback_language)) # Validate each words list for language, word_list in self._language_to_words.items(): # Ensure that there are enough words in the list word_list_size = len(word_list) if word_list_size < self._WORD_LIST_MINIMUM_SIZE: raise InvalidWordListError( "The word list for language '{}' only contains {} long-enough words;" " minimum required is {} words.".format( language, word_list_size, self._WORD_LIST_MINIMUM_SIZE, )) # Ensure all words are ascii try: " ".join(word_list).encode("ascii") except UnicodeEncodeError: raise InvalidWordListError( "The word list for language '{}' contains non-ASCII words." ) # Ensure that passphrases longer than what's supported can't be generated longest_word = max(word_list, key=len) longest_passphrase_length = len( longest_word) * self.PASSPHRASE_WORDS_COUNT longest_passphrase_length += self.PASSPHRASE_WORDS_COUNT # One space between each word if longest_passphrase_length >= self.MAX_PASSPHRASE_LENGTH: raise InvalidWordListError( "Passphrases over the maximum length ({}) may be generated:" " longest word in word list for language '{}' is '{}' and number of words per" " passphrase is {}".format( self.MAX_PASSPHRASE_LENGTH, language, longest_word, self.PASSPHRASE_WORDS_COUNT, )) # Ensure that passphrases shorter than what's supported can't be generated shortest_word = min(word_list, key=len) shortest_passphrase_length = len( shortest_word) * self.PASSPHRASE_WORDS_COUNT shortest_passphrase_length += self.PASSPHRASE_WORDS_COUNT if shortest_passphrase_length <= self.MIN_PASSPHRASE_LENGTH: raise InvalidWordListError( "Passphrases under the minimum length ({}) may be generated:" " shortest word in word list for language '{}' is '{}' and number of words per" " passphrase is {}".format( self.MIN_PASSPHRASE_LENGTH, language, shortest_word, self.PASSPHRASE_WORDS_COUNT, )) @classmethod def get_default(cls) -> "PassphraseGenerator": global _current_generator if _current_generator is None: language_to_words = _parse_available_words_list( Path(config.SECUREDROP_ROOT)) _current_generator = cls(language_to_words) return _current_generator @property def available_languages(self) -> Set[str]: return set(self._language_to_words.keys()) def generate_passphrase( self, preferred_language: Optional[str] = None) -> DicewarePassphrase: final_language = preferred_language if preferred_language else self._fallback_language try: words_list = self._language_to_words[final_language] except KeyError: # If there is no wordlist for the desired language, fall back to the word list for the # default language words_list = self._language_to_words[self._fallback_language] words = [ self._random_generator.choice(words_list) for _ in range(self.PASSPHRASE_WORDS_COUNT) ] # type: List[str] return DicewarePassphrase(" ".join(words))
def rndstr(size=6, chars=string.ascii_uppercase + string.digits): cryptogen = SystemRandom() return ''.join(cryptogen.choice(chars) for _ in range(size))
def generate_password(length=8): rnd = SystemRandom() if length > 255: length = 255 return "".join([rnd.choice(string.hexdigits) for _ in range(length)])
def mksalt(): """Generate SHA512 salt.""" sr = SystemRandom() return '$6$' + ''.join( sr.choice(ascii_letters + digits + './') for char in range(16))
def generate_token(length=30, chars=UNICODE_ASCII_CHARACTER_SET): rand = SystemRandom() return ''.join(rand.choice(chars) for x in range(length))
def znc_random(size=20): r = SystemRandom() return ''.join([r.choice(randbase) for _ in range(size)])
#!/usr/bin/env python {% from 'ip.sls' import external_ip %} import os from random import SystemRandom random = SystemRandom() all_words = file('/usr/share/dict/words').read().split() random_word = lambda: random.choice(all_words) def random_words(*dist): return ' '.join(random_word().capitalize().replace("'s", "") for _ in xrange(weighted_choice(*dist))) def weighted_choice(*dist): "For quick&dirtiness, weights must be integers." return random.choice(sum(([item] * weight for item, weight in dist), [])) def gen_cert_call(): "Typical-ish parameters with some very unscientific randomization." args = {} args['keyalg'] = weighted_choice(('RSA', 4), ('EC', 1)) # `man keytool` default_keysize = {'RSA': 2048, 'DSA': 1024, 'EC': 256}[args['keyalg']]
class SecretKeyGenerator: """SecretKeyGenerator class""" def __init__(self, chars=properties.DEFAULT_CHARS, file_name=properties.DEFAULT_FILE_NAME, len_of_secret_key=properties.DEFAULT_LENGTH_OF_SECRET_KEY): self._chars = chars self._secret_key = "" self._len_of_secret_key = len_of_secret_key self._file_name = file_name self._system_random = SystemRandom() def _get_random_string(self): """ Getting random string from self._chars. This random string is going to be the secret key """ self._secret_key = ''.join(self._system_random.choice(self._chars) for _ in range(self._len_of_secret_key)) def get_secret_key_from_file(self) -> str: """ Getting secret key from a file Returns: secret_key: str """ secret_key_file = open(self._file_name, 'r') secret_key = secret_key_file.readline() secret_key_file.close() return secret_key def _validate_secret_key(self, secret_key_to_validate: str): """ Checking if the secret key is valid Args: secret_key_to_validate: str Raises: ValueError: if the secret key is invalid """ if len(secret_key_to_validate) != self._len_of_secret_key: secret_key_file = open(self._file_name, 'w') secret_key_file.write("") secret_key_file.close() raise ValueError def _write_secret_key_to_file(self): """Writing the secret key to file""" secret_key_file = open(self._file_name, 'w') secret_key_file.write(self._secret_key) secret_key_file.close() def generate(self) -> str: """ Processing generation of the secret key If the file already contains the correct secret key, then this method reads the secret key and returns it. If the file already contains an incorrect secret key, then this method deletes that file and creates a new one with a correct secret key. If no file was found, then this method creates a new file with the correct secret key. Returns: str: secret key """ try: secret_key_from_file = self.get_secret_key_from_file() self._validate_secret_key(secret_key_from_file) self._secret_key = secret_key_from_file except (FileNotFoundError, ValueError): self._get_random_string() self._write_secret_key_to_file() return self._secret_key
def crea_seed(): alphabet = u'9ABCDEFGHIJKLMNOPQRSTUVWXYZ' generator = SystemRandom() return(u''.join(generator.choice(alphabet) for _ in range(81)))
def on_start(self): cryptogen = SystemRandom() with open('users.json') as f: self.voters = json.loads(f.read()) self.voter = cryptogen.choice(list(self.voters.items()))
def generate_token(leng=64): sr = SystemRandom() return ''.join([ sr.choice(string.ascii_lowercase + "0123456789") for i in range(leng) ])
height = img.size[1]*2 print("{} x {}".format(width, height)) out_image_A = Image.new('1', (width, height)) out_image_B = Image.new('1', (width, height)) draw_A = ImageDraw.Draw(out_image_A) draw_B = ImageDraw.Draw(out_image_B) C0 = ((1, 0, 1, 0), (0, 1, 0, 1)) C1 = ((1, 0, 0, 1), (0, 1, 1, 0)) # Cycle through pixels for x in xrange(0, int(width/2)): for y in xrange(0, int(height/2)): pixel = img.getpixel((x, y)) if pixel == 0: #Pixel was black pat1 = random.choice(C1) draw_A.point((x*2, y*2), pat1[0]) draw_A.point((x*2+1, y*2), pat1[1]) draw_A.point((x*2, y*2+1), pat1[0]) draw_A.point((x*2+1, y*2+1), pat1[1]) pat2 = C1[1 - C1.index(pat1)] draw_B.point((x*2, y*2), pat2[2]) draw_B.point((x*2+1, y*2), pat2[3]) draw_B.point((x*2, y*2+1), pat2[2]) draw_B.point((x*2+1, y*2+1), pat2[3]) else : #Pixel was white pat1 = random.choice(C0) draw_A.point((x*2, y*2), pat1[0]) draw_A.point((x*2+1, y*2), pat1[1])