我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用hashlib.sha224()。
def GetIntegrity(self, data): """Calculate the integirty value of given data using remote peers hash""" if self.hash_type == None: return None elif self.hash_type == 0: # SHA-1 return hashlib.sha1(data).digest() elif self.hash_type == 1: # SHA-224 return hashlib.sha224(data).digest() elif self.hash_type == 2: # SHA-256 return hashlib.sha256(data).digest() elif self.hash_type == 3: # SHA-384 return hashlib.sha384(data).digest() elif self.hash_type == 4: # SHA-512 return hashlib.sha512(data).digest() else: return None
def get_hashsums(file_path): hash_sums = od() hash_sums['md5sum'] = hashlib.md5() hash_sums['sha1sum'] = hashlib.sha1() hash_sums['sha224sum'] = hashlib.sha224() hash_sums['sha256sum'] = hashlib.sha256() hash_sums['sha384sum'] = hashlib.sha384() hash_sums['sha512sum'] = hashlib.sha512() with open(file_path, 'rb') as fd: data_chunk = fd.read(1024) while data_chunk: for hashsum in hash_sums.keys(): hash_sums[hashsum].update(data_chunk) data_chunk = fd.read(1024) results = od() for key,value in hash_sums.items(): results[key] = value.hexdigest() return results
def get_digest(value): """Return a hashlib digest algorithm from a string.""" if not isinstance(value, str): return value value = value.lower() if value == "md5": return md5 elif value == "sha1": return sha1 elif value == "sha224": return sha224 elif value == "sha256": return sha256 elif value == "sha384": return sha384 elif value == "sha512": return sha512 else: raise ValueError("Invalid digest algorithm: %s" % value)
def get_digest(value): """ Returns a hashlib digest algorithm from a string """ if not isinstance(value, str): return value value = value.lower() if value == "md5": return md5 elif value == "sha1": return sha1 elif value == "sha224": return sha224 elif value == "sha256": return sha256 elif value == "sha384": return sha384 elif value == "sha512": return sha512 else: raise ValueError("Invalid digest algorithm: %s" % value)
def get_digest(value): """ Returns a hashlib digest algorithm from a string """ if not isinstance(value, str): return value value = value.lower() if value == "md5": return hashlib.md5 elif value == "sha1": return hashlib.sha1 elif value == "sha224": return hashlib.sha224 elif value == "sha256": return hashlib.sha256 elif value == "sha384": return hashlib.sha384 elif value == "sha512": return hashlib.sha512 else: raise ValueError("Invalid digest algorithm: %s" % value)
def hash_monitor_names(service): """ Uses the get_mon_map() function to get information about the monitor cluster. Hash the name of each monitor. Return a sorted list of monitor hashes in an ascending order. :param service: six.string_types. The Ceph user name to run the command under :rtype : dict. json dict of monitor name, ip address and rank example: { 'name': 'ip-172-31-13-165', 'rank': 0, 'addr': '172.31.13.165:6789/0'} """ try: hash_list = [] monitor_list = get_mon_map(service=service) if monitor_list['monmap']['mons']: for mon in monitor_list['monmap']['mons']: hash_list.append( hashlib.sha224(mon['name'].encode('utf-8')).hexdigest()) return sorted(hash_list) else: return None except (ValueError, CalledProcessError): raise
def _get_cache_path_parts(self, link): """Get parts of part that must be os.path.joined with cache_dir """ # We want to generate an url to use as our cache key, we don't want to # just re-use the URL because it might have other items in the fragment # and we don't care about those. key_parts = [link.url_without_fragment] if link.hash_name is not None and link.hash is not None: key_parts.append("=".join([link.hash_name, link.hash])) key_url = "#".join(key_parts) # Encode our key url with sha224, we'll use this because it has similar # security properties to sha256, but with a shorter total output (and # thus less secure). However the differences don't make a lot of # difference for our use case here. hashed = hashlib.sha224(key_url.encode()).hexdigest() # We want to nest the directories some to prevent having a ton of top # level directories where we might run out of sub directories on some # FS. parts = [hashed[:2], hashed[2:4], hashed[4:6], hashed[6:]] return parts
def __init__(self, name, directory, digest=None): self.directory = directory self.name = name self._set_path() if self.name and self.name[0] == '"': raise TypeError('Unexpected double quote ( " )') if os.path.isdir(self.path) and name[-1] != '/': self.name = name + '/' self.digest = digest if digest is None and self.persisted(): self._set_version() digest_text = self.path + str(self.version) if sys.version_info[0] == 3 and digest_text: digest_text = digest_text.encode('utf-8') self.full_digest = hashlib.sha224(digest_text).hexdigest() self.digest = self.full_digest[0:12]
def load_config(self, config): with open(config) as c: cfg = json.load(c) m = hashlib.sha224() m.update(bytes(cfg['subnet'], 'utf-8')) m.update(bytes(cfg['swap_size'])) m.update(bytes(cfg['root_size'])) m.update(bytes(cfg['extra_args'], 'utf-8')) # TODO: check sizes for f in cfg['hashes']: with open(f, 'rb') as fl: for line in fl: m.update(line) cfg['sha224'] = m.hexdigest() cfg['subnet'] = ipaddress.ip_network(cfg['subnet']) cfg['image_method'] = IMAGE_METHOD return cfg
def __init__(self, url="http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png", cache_key=None, min_zoom=0, max_zoom=19, tile_size=256, image_ext="png", attribution="© OpenStreetMap contributors", subdomains="abc"): super(MapSource, self).__init__() if cache_key is None: # possible cache hit, but very unlikely cache_key = hashlib.sha224(url.encode("utf8")).hexdigest()[:10] self.url = url self.cache_key = cache_key self.min_zoom = min_zoom self.max_zoom = max_zoom self.tile_size = tile_size self.image_ext = image_ext self.attribution = attribution self.subdomains = subdomains self.cache_fmt = "{cache_key}_{zoom}_{tile_x}_{tile_y}.{image_ext}" self.dp_tile_size = min(dp(self.tile_size), self.tile_size * 2) self.default_lat = self.default_lon = self.default_zoom = None self.bounds = None
def __init__(self, url="http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png", cache_key=None, min_zoom=0, max_zoom=19, tile_size=256, image_ext="png", attribution="© OpenStreetMap contributors", subdomains="abc", **kwargs): super(MapSource, self).__init__() if cache_key is None: # possible cache hit, but very unlikely cache_key = hashlib.sha224(url.encode("utf8")).hexdigest()[:10] self.url = url self.cache_key = cache_key self.min_zoom = min_zoom self.max_zoom = max_zoom self.tile_size = tile_size self.image_ext = image_ext self.attribution = attribution self.subdomains = subdomains self.cache_fmt = "{cache_key}_{zoom}_{tile_x}_{tile_y}.{image_ext}" self.dp_tile_size = min(dp(self.tile_size), self.tile_size * 2) self.default_lat = self.default_lon = self.default_zoom = None self.bounds = None self.cache_dir = kwargs.get('cache_dir', CACHE_DIR)
def anonymize_user(doc): """Preprocess an event by anonymizing user information.""" ip = doc.pop('ip_address', None) if ip: doc.update(get_geoip(ip)) uid = doc.pop('user_id', '') ua = doc.pop('user_agent', '') m = hashlib.sha224() # TODO: include random salt here, that changes once a day. # m.update(random_salt) if uid: m.update(uid.encode('utf-8')) elif ua: m.update(ua.encode('utf-8')) else: # TODO: add random data? pass doc.update(dict( visitor_id=m.hexdigest() )) return doc
def encode(x): return hashlib.sha224(x.encode()).hexdigest()
def _cache_for_link(cache_dir, link): """ Return a directory to store cached wheels in for link. Because there are M wheels for any one sdist, we provide a directory to cache them in, and then consult that directory when looking up cache hits. We only insert things into the cache if they have plausible version numbers, so that we don't contaminate the cache with things that were not unique. E.g. ./package might have dozens of installs done for it and build a version of 0.0...and if we built and cached a wheel, we'd end up using the same wheel even if the source has been edited. :param cache_dir: The cache_dir being used by pip. :param link: The link of the sdist for which this will cache wheels. """ # We want to generate an url to use as our cache key, we don't want to just # re-use the URL because it might have other items in the fragment and we # don't care about those. key_parts = [link.url_without_fragment] if link.hash_name is not None and link.hash is not None: key_parts.append("=".join([link.hash_name, link.hash])) key_url = "#".join(key_parts) # Encode our key url with sha224, we'll use this because it has similar # security properties to sha256, but with a shorter total output (and thus # less secure). However the differences don't make a lot of difference for # our use case here. hashed = hashlib.sha224(key_url.encode()).hexdigest() # We want to nest the directories some to prevent having a ton of top level # directories where we might run out of sub directories on some FS. parts = [hashed[:2], hashed[2:4], hashed[4:6], hashed[6:]] # Inside of the base location for cached wheels, expand our parts and join # them all together. return os.path.join(cache_dir, "wheels", *parts)
def hashing_password(password): try: hashpw = hashlib.sha224() hashpw.update(password) data = hashpw.hexdigest() return data except Exception: return False
def check_password(password_input,password_hash): try: hashpw = hashlib.sha224() hashpw.update(password) data = hashpw.hexdigest() if data == passworddb: return True else: return False except Exception: return False
def main(argv): if len(argv) != 1: sys.exit('Usage: pass_auth3.py <file_name>') print '\nPassword Request Program v.04\n' try: file_conn = open(sys.argv[1]) password = file_conn.readline()[:-1] file_conn.close() except: sys.exit('There was a problem reading the file!') pass_try = 0 x = 3 while pass_try < x: user_input = hashlib.sha224(getpass.getpass('Please Enter Password: ')).hexdigest() if user_input != password: pass_try += 1 print 'Incorrect Password, ' + str(x-pass_try) + ' more attempts left\n' else: pass_try = 4 if pass_try == x and user_input != password: sys.exit('Incorrect Password, terminating... \n') print 'User is logged in!\n'
def make_hashkey_nonetime(solt): soltt = str(solt+'secrettskkey') soltt = soltt.encode('utf-8') return hashlib.sha224(soltt).hexdigest()
def make_hashkey(solt): soltt = str(solt)+str(time.time()*1000) soltt = soltt.encode('utf-8') return hashlib.sha224(soltt).hexdigest()
