def generate_machine_id_bytes() -> bytes: random_hex_string = choices( population=hexdigits.lower(), k=32, ) return b''.join((x.encode() for x in random_hex_string))
def index(argv: typing.List[str], args: argparse.Namespace): """ Queue an SQS message to the indexer lambda for each key in object storage beginning with `bundles/{prefix}`. If `prefix` is omitted, send a message for each key in object storage beginning with `bundles/` """ replica = Replica[args.replica] handle = Config.get_blobstore_handle(replica) index_queue_url = get_queue_url("dss-index-operation-" + os.environ['DSS_DEPLOYMENT_STAGE']) if "on-change" == args.send_notifications: send_notifications = None else: send_notifications = ("true" == args.send_notifications) def _forward_keys(pfx): with SQSMessenger(index_queue_url) as sqsm: for key in handle.list(replica.bucket, pfx): msg = dict(replica=replica.name, key=key) if send_notifications is not None: msg['send_notifications'] = send_notifications sqsm.send(json.dumps(msg)) with ThreadPoolExecutor(max_workers=10) as e: futures = [ e.submit(_forward_keys, f"bundles/{args.prefix}{c}") for c in set(hexdigits.lower()) ] for f in as_completed(futures): f.result()
def is_valid_passport_strict(passport: Dict[str, str]) -> bool: rules = { "byr": lambda x: 1920 <= int(x) <= 2002, "iyr": lambda x: 2010 <= int(x) <= 2020, "eyr": lambda x: 2020 <= int(x) <= 2030, "hgt": lambda x: { "cm": lambda cm: 150 <= cm <= 193, "in": lambda inch: 59 <= inch <= 76, }[x[-2:]](int(x[:-2])), "hcl": lambda x: len(x) == 7 and x[0] == "#" and all( digit in hexdigits.lower() for digit in x[1:]), "ecl": lambda x: x in ("amb", "blu", "brn", "gry", "grn", "hzl", "oth"), "pid": lambda x: len(x) == 9 and all(digit in decdigits for digit in x), } try: return all(rule(passport[field]) for field, rule in rules.items()) except KeyError: return False
def record(argv: typing.List[str], args: argparse.Namespace): """ Record events for `keys` into flashflood prefix `prefix` If `keys` is omitted, record an event for each bundle in `replica` via lambda forwarding. """ replica = Replica[args.replica] job_id = args.job_id or f"{uuid4()}" cmd_template = (f"events record --job-id {job_id} " f"--prefix {args.prefix} " f"--replica {replica.name} " f"--keys {{keys}}") if args.keys is None: start_time = datetime.now() def forward_keys(bundle_fqids): with SQSMessenger(command_queue_url) as sqsm: for fqid in bundle_fqids: sqsm.send(cmd_template.format(keys=f"bundles/{fqid}")) handle = Config.get_blobstore_handle(replica) with ThreadPoolExecutor(max_workers=4) as e: for c in set(hexdigits.lower()): bundle_fqids = Living(handle.list_v2(replica.bucket, f"bundles/{c}")) e.submit(forward_keys, bundle_fqids) monitor_logs(logs, job_id, start_time) else: for key in args.keys: msg = json.dumps(dict(action="record event", job_id=job_id, replica=replica.name, key=key)) record_event_for_bundle(Replica[args.replica], key, (args.prefix,), use_version_for_timestamp=True) print(msg)
def uniqid(self, prefix = '', more_entropy = False): from time import time m = time() from math import floor myuniqid = '%8x%05x' % (floor(m), (m - floor(m))*1000000) from string import hexdigits if more_entropy: valid_chars = list(set(hexdigits.lower())) entropy_string = '' for i in range(0,10,1): from random import choice entropy_string += choice(valid_chars) myuniqid = myuniqid + entropy_string myuniqid = prefix + myuniqid return myuniqid
def run(self, src, end, base): s = self.state logger.info("Made it to strtoul sim.") logger.info("Params:\nsrc=%s\nend=%s\nbase=%s\n", src, end, base) try: all_bytes = [s.memory.load(src + i, 1) for i in range(8)] total = claripy.BVV(0, 8 * 4) for i, b in enumerate(reversed(all_bytes)): logger.info("On byte: %s", b) f = partial(self.if_builder, b) out = reduce(f, hexdigits.lower(), claripy.BVV(0, 8 * 4)) total += (16 * i) + out except Exception as e: logger.error(e) exit(0) return total
def random_ip(v): if v == 4: octets = [] for x in xrange(4): octets.append(unicode(randint(0, 255))) return u'.'.join(octets) elif v == 6: octets = [] for x in xrange(8): octet = [] for x in xrange(4): octet.append(unicode(choice(hexdigits.lower()))) octets.append(u''.join(octet)) return u':'.join(octets) else: return
def build_character_set(self): '''Assemble the list of acceptable characters for password generation. ''' if self.hexadecimal: # If hexadecimal output enabled, return early. # Use *only* hex in character set. # Do some manipulations here to remove lowercase `a-f` if self.upper: hexcase = hexdigits.upper() else: hexcase = hexdigits.lower() self.char_set += ''.join(list(set(hexcase))) return if self.alpha: self.char_set += ascii_lowercase if self.upper: self.char_set += ascii_uppercase if self.numerals: self.char_set += digits if self.special: self.char_set += punctuation
def run(self, dst, fmt, arg1): s = self.state fmt = s.mem[fmt].string.concrete logger.info("Made it to sprintf sim.\n->dst=%s\n->fmt=%s", dst, fmt) logger.debug("arg=%s", arg1) if fmt != "%lx": logger.error("Injected the wrong sprintf") return 0 for in_idx, b in enumerate(map(arg1.get_byte, xrange(4))): out_idx = 2 * in_idx for i in range(7, 0, -4): nibble = b[i:i - 3] logger.debug("nibble: %s", nibble) f = partial(self.if_builder, nibble) out = reduce(f, hexdigits.lower(), claripy.BVV(0, 8)) # logger.debug("result: %s",chr(seval(s,out))) logger.debug("stored at: %s", out_idx) s.memory.store(dst + out_idx, out) out_idx += 1 return 8
def is_hex_str_lc(s): return set(list(s)) <= set(list(hexdigits.lower())) def is_hex_str_uc(s): return set(list(s)) <= set(list(hexdigits.upper()))
def is_hex_str_lc(s): return set(list(s)) <= set(list(hexdigits.lower()))
def make_id(length): string = "".join([random.choice(hexdigits.lower()) for _ in range(length)]) return string
def is_hexstring_lc(s): return _is_whatstring(s,hexdigits.lower())
# limitations under the License. ## """ Docker Hub API v2 Digest """ from enum import Enum, auto, unique from string import hexdigits as upperCaseHexDigits from typing import Sequence from attr import attrs __all__ = () # Docker Hub produces lowercase hex digits lowerCaseHexDigits = upperCaseHexDigits.lower() hexDigits = "".join(frozenset(lowerCaseHexDigits + upperCaseHexDigits)) asHex = hex class AutoName(str, Enum): @staticmethod def _generate_next_value_(name: str, start: int, count: int, last_values: Sequence[str]) -> str: return name @unique class DigestAlgorithm(AutoName): """
#!/usr/local/bin/python3 from string import hexdigits PASSPORT_FILE = 'input.txt' FIELDS = { 'byr': lambda y: 1920 <= int(y) <= 2002, 'iyr': lambda y: 2010 <= int(y) <= 2020, 'eyr': lambda y: 2020 <= int(y) <= 2030, 'hgt': lambda h: h[-2:] == 'cm' and 150 <= int(h[:-2]) <= 193 or h[-2:] == 'in' and 59 <= int(h[:-2]) <= 76, 'hcl': lambda h: h.startswith('#') and all(c in hexdigits.lower() for c in h[1:]), 'ecl': lambda e: e in 'amb blu brn gry grn hzl oth'.split(), 'pid': lambda p: len(p) == 9 and all(c.isdigit() for c in p) } def parse_passport(raw_passport): fields = raw_passport.rstrip().replace('\n', ' ').split(' ') return dict([f.split(':') for f in fields]) def is_valid_field(passport, field): return field in passport and FIELDS[field](passport[field]) def is_valid_passport(passport): return all(is_valid_field(passport, f) for f in FIELDS) if __name__ == '__main__': with open(PASSPORT_FILE) as f:
def __height_validator(value): """ Validates a height value. Centimeter values must end in 'cm' and be in the range 150-193, inch values must end in 'in', and be in the range 58-76. Any other value is invalid. """ if value.endswith('cm'): height = int(value[:-2]) return height in range(150, 194) if value.endswith('in'): height = int(value[:-2]) return height in range(59, 77) return False __VALID_HEX_DIGITS_LOWER = set(hexdigits.lower()) def __validate_hair_color(value): """ Validates a hair color. It must be a hexadecimal value, starting with '#', and containing 6 lowercase hexadecimal characters. """ if not value.startswith('#'): return False color = value[1:] if len(color) != 6: return False for char in color: if not char in __VALID_HEX_DIGITS_LOWER:
def force_range(iter, allowed=hexdigits.lower()): #This function yeilds constraints that ensure # members of iter are in the range of allowed chrs for x in iter: yield claripy.Or(*[x == y for y in allowed])