def minify_website(args):
css_in = ' '.join(get_css_in(args))
css_out = f'{args.output_dir}/css/base.css'
if args.minify:
command = f"purifycss -w '*algolia*' --min {css_in} '{args.output_dir}/*.html' " \
f"'{args.output_dir}/docs/en/**/*.html' '{args.website_dir}/js/**/*.js' > {css_out}"
else:
command = f'cat {css_in} > {css_out}'
logging.info(command)
output = subprocess.check_output(command, shell=True)
logging.debug(output)
with open(css_out, 'rb') as f:
css_digest = hashlib.sha3_224(f.read()).hexdigest()[0:8]
js_in = get_js_in(args)
js_out = f'{args.output_dir}/js/base.js'
if args.minify:
js_in = [js[1:-1] for js in js_in]
closure_args = [
'--js', *js_in, '--js_output_file', js_out, '--compilation_level',
'SIMPLE', '--dependency_mode', 'NONE', '--third_party',
'--use_types_for_optimization', '--isolation_mode', 'IIFE'
]
logging.info(closure_args)
if closure.run(*closure_args):
raise RuntimeError('failed to run closure compiler')
else:
logging.info(command)
js_in = ' '.join(js_in)
output = subprocess.check_output(f'cat {js_in} > {js_out}', shell=True)
logging.debug(output)
with open(js_out, 'rb') as f:
js_digest = hashlib.sha3_224(f.read()).hexdigest()[0:8]
logging.info(js_digest)
if args.minify:
logging.info('Minifying website')
for root, _, filenames in os.walk(args.output_dir):
for filename in filenames:
path = os.path.join(root, filename)
if not (filename.endswith('.html')
or filename.endswith('.css')):
continue
logging.info('Minifying %s', path)
with open(path, 'rb') as f:
content = f.read().decode('utf-8')
if filename.endswith('.html'):
content = htmlmin.minify(content, remove_empty_space=False)
content = content.replace('base.css?css_digest',
f'base.css?{css_digest}')
content = content.replace('base.js?js_digest',
f'base.js?{js_digest}')
elif filename.endswith('.css'):
content = cssmin.cssmin(content)
elif filename.endswith('.js'):
content = jsmin.jsmin(content)
with open(path, 'wb') as f:
f.write(content.encode('utf-8'))
def minify_website(args):
css_in = " ".join(get_css_in(args))
css_out = f"{args.output_dir}/docs/css/base.css"
os.makedirs(f"{args.output_dir}/docs/css")
command = f"cat {css_in}"
output = subprocess.check_output(command, shell=True)
with open(css_out, "wb+") as f:
f.write(output)
with open(css_out, "rb") as f:
css_digest = hashlib.sha3_224(f.read()).hexdigest()[0:8]
js_in = " ".join(get_js_in(args))
js_out = f"{args.output_dir}/docs/js/base.js"
os.makedirs(f"{args.output_dir}/docs/js")
command = f"cat {js_in}"
output = subprocess.check_output(command, shell=True)
with open(js_out, "wb+") as f:
f.write(output)
with open(js_out, "rb") as f:
js_digest = hashlib.sha3_224(f.read()).hexdigest()[0:8]
logging.info(js_digest)
def test_duid_mint():
mhash = hashlib.sha3_224(b"0123456789abcdef").hexdigest()
dhash = hashlib.sha3_224(b"fedcba9876543210").hexdigest()
print(mhash)
print(dhash)
uid = DcmUIDMint().content_hash_uid(hex_mhash=mhash, hex_dhash=dhash)
assert uid == "1.2.826.0.1.3680043.10.43.4.62.0.806243101896.283258269229"
res = DcmUIDMint().hashes_from_duid(uid)
pprint(res)
assert res.get("duid") == uid
assert res.get("dlvl") == DLv.INSTANCE
assert mhash.startswith(res["mhash_s"])
assert dhash.startswith(res["dhash_s"])
assert "namespace" in res
assert res.get("namespace") == DcmUIDMint.namespace
uid2 = DcmUIDMint().content_hash_uid(namespace="testing",
hex_mhash=mhash,
dlvl=DLv.STUDY)
assert uid2 == "1.2.826.0.1.3680043.10.43.4.16.2.806243101896.0"
res2 = DcmUIDMint().hashes_from_duid(uid2)
pprint(res2)
assert res2["dlvl"] == DLv.STUDY
assert res2['ns_hash'] != res["ns_hash"]
assert res2["dhash_s"] == "0"
assert "namespace" not in res2
def type_7():
if verbose == True:
startTime = time.time()
with open(wordlist, "r", encoding="ISO-8859-1") as FileObj:
for line in FileObj:
passwd1 = line.replace("\n", "")
passwd_h = hashlib.sha3_224(passwd1.encode())
passwd_hash = passwd_h.hexdigest()
print("Trying \"{}\"".format(str(passwd1)))
if user_hash == passwd_hash:
print("[+] Hash cracked! Results: " + str(line))
endTime = time.time()
deltaTime = endTime - startTime
print("[+] Cracking finished in {}s".format(
str(format(deltaTime, ".2f"))))
sys.exit()
print("[-] Hash not found! Maybe try an other wordlist.")
sys.exit()
else:
startTime = time.time()
with open(wordlist, "r", encoding="ISO-8859-1") as FileObj:
for line in FileObj:
passwd1 = line.replace("\n", "")
passwd_h = hashlib.sha3_224(passwd1.encode())
passwd_hash = passwd_h.hexdigest()
if user_hash == passwd_hash:
print("[+] Hash cracked! Results: " + str(line))
endTime = time.time()
deltaTime = endTime - startTime
print("[+] Cracking finished in {}s".format(
str(format(deltaTime, ".2f"))))
sys.exit()
print("[-] Hash not found! Maybe try an other wordlist.")
sys.exit()
def generate_s3_key(user_id, file_name):
if user_id:
return hashlib.sha3_224(user_id.encode() +
file_name.encode()).hexdigest()
else:
return hashlib.sha3_224(
str(random.randint(1, 2**10)).encode() +
file_name.encode()).hexdigest()
def sha3_224(s=None, f=None):
if (s != None):
now = datetime.now()
time = datetime.strftime(now, "%X")
time1 = datetime.strftime(now, "%X"
"_"
"%d"
"_"
"%m"
"_"
"%y").replace(":", "_")
time2 = time1.replace("_", ":")
hashed = hashlib.sha3_224(s.encode('utf-8')).hexdigest()
print(
"\33[36m{}\33[0m \33[32m{}\33[0m".format(time, hashed),
" \33[30m\33[42m[ Encrypted ]\33[0m \33[0m \33[0m <- {} ".format(
s), "\n")
file = open("logs/" + time2 + "--sha3_224-enc.txt",
"a",
encoding="utf-8".format(time2))
file.write("""
LOG DATA :
[Encrypted : SHA3_224 ] [ Date : {} ]
------------------------------------------------------------
{} [>] {} """.format(now, s, hashed))
file.close()
elif (f != None):
with open(f, "r", encoding="utf-8") as file:
for i in file:
now = datetime.now()
time = datetime.strftime(now, "%X")
time1 = datetime.strftime(now, "%X"
"_"
"%d"
"_"
"%m"
"_"
"%y").replace(":", "_")
time2 = time1.replace("_", ":")
data = i.replace('\n', '')
hashed = hashlib.sha3_224(data.encode('utf-8')).hexdigest()
print(
"\33[36m{}\33[0m \33[32m{}\33[0m".format(time, hashed),
" \33[30m\33[42m[ Encrypted ]\33[0m \33[0m \33[0m <- {} ".
format(data))
file = open("logs/" + time2 + "--sha3_224-enc.txt",
"a",
encoding="utf-8".format(time2))
file.write("""
LOG DATA :
[Encrypted : SHA3_224 ] [ Date : {} ]
------------------------------------------------------------
{} [>] {}\n
""".format(now, data, hashed))
file.close()
print("\n")
def word_hash(word):
# It takes one argument word and will create hash """
md5 = hashlib.md5(word.encode()).hexdigest()
sha1 = hashlib.sha1(word.encode()).hexdigest()
sha224 = hashlib.sha224(word.encode()).hexdigest()
blake2s = hashlib.blake2s(word.encode()).hexdigest()
blake2b = hashlib.blake2b(word.encode()).hexdigest()
sha3_384 = hashlib.sha3_384(word.encode()).hexdigest()
sha384 = hashlib.sha384(word.encode()).hexdigest()
sha3_512 = hashlib.sha3_512(word.encode()).hexdigest()
sha3_224 = hashlib.sha3_224(word.encode()).hexdigest()
sha512 = hashlib.sha512(word.encode()).hexdigest()
sha256 = hashlib.sha256(word.encode()).hexdigest()
sha3_256 = hashlib.sha3_224(word.encode()).hexdigest()
ntlm = (binascii.hexlify(
hashlib.new('md4', word.encode('utf-16le')).digest())).decode()
print('md5 :', md5)
print()
print('sha1 :', sha1)
print()
print('sha224 :', sha224)
print()
print('blake2s :', blake2s)
print()
print('blake2b :', blake2b)
print()
print('sha3_384:', sha3_384)
print()
print('sha384 :', sha384)
print()
print('sha3_512:', sha3_512)
print()
print('sha3_224:', sha3_224)
print()
print('sha512 :', sha512)
print()
print('sha256 :', sha256)
print()
print('sha3_256:', sha3_256)
print()
print('ntlm :', ntlm)
print()
# check if word alrady exists into database
chk = check_me(word)
if chk is False:
# Store all hashes into database
choice = input("Enter y to store word in database : ")
if choice == 'y':
sql.execute(
'insert into Hashes_Table(name, md5 , sha1, sha224 , blake2s , blake2b , sha3_384 , sha384 , sha3_512, sha3_224, sha512, sha256, sha3_256, ntlm) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?)',
(word, md5, sha1, sha224, blake2s, blake2b, sha3_384, sha384,
sha3_512, sha3_224, sha512, sha256, sha3_256, ntlm))
sql.commit()
print("word : " + word)
return
def hashIt(self):
inp = [str(self.pcollid), str(self.x), str(self.y)]
s = hashlib.sha3_224()
for item in inp:
hasher = hashlib.sha3_224()
hasher.update(str(item))
s.update(hasher.hexdigest()[self.hindexi:self.hindexj])
s.update(str(s))
return s.hexdigest()[self.hindexi:self.hindexj]
def minify_website(args):
css_in = ' '.join(get_css_in(args))
css_out = f'{args.output_dir}/css/base.css'
if args.minify:
command = f"purifycss -w '*algolia*' --min {css_in} '{args.output_dir}/*.html' " \
f"'{args.output_dir}/docs/en/**/*.html' '{args.website_dir}/js/**/*.js' > {css_out}"
else:
command = f'cat {css_in} > {css_out}'
logging.info(command)
output = subprocess.check_output(command, shell=True)
logging.debug(output)
with open(css_out, 'rb') as f:
css_digest = hashlib.sha3_224(f.read()).hexdigest()[0:8]
js_in = get_js_in(args)
js_out = f'{args.output_dir}/js/base.js'
if args.minify:
js_in = [js[1:-1] for js in js_in]
closure_args = [
'--js', *js_in, '--js_output_file', js_out,
'--compilation_level', 'SIMPLE',
'--dependency_mode', 'NONE',
'--third_party', '--use_types_for_optimization',
'--isolation_mode', 'IIFE'
]
logging.info(closure_args)
if closure.run(*closure_args):
raise RuntimeError('failed to run closure compiler')
with open(js_out, 'r') as f:
js_content = jsmin.jsmin(f.read())
with open(js_out, 'w') as f:
f.write(js_content)
else:
js_in = ' '.join(js_in)
command = f'cat {js_in} > {js_out}'
logging.info(command)
output = subprocess.check_output(command, shell=True)
logging.debug(output)
with open(js_out, 'rb') as f:
js_digest = hashlib.sha3_224(f.read()).hexdigest()[0:8]
logging.info(js_digest)
if args.minify:
logging.info('Minifying website')
with concurrent.futures.ThreadPoolExecutor() as executor:
futures = []
for root, _, filenames in os.walk(args.output_dir):
for filename in filenames:
path = os.path.join(root, filename)
futures.append(executor.submit(minify_file, path, css_digest, js_digest))
for future in futures:
exc = future.exception()
if exc:
logging.error(exc)
sys.exit(1)
def checkChange(self):
""" check memory for change and save them.
returns what changed so Hyxtalker can send updates to Hyx
"""
def findChanges():
from itertools import count
start = 0
length = 0
result = []
for old, new, ind in zip(self.heapbytes, buf, count()):
if old == new:
if length > 0:
data = buf[start:start + length]
# if length == 1: # if data is a single byte, python converts it to an int
# data= bytes([data])
result.append((start, data))
length = 0
start = ind + 1
else:
length += 1
if self.heapbytes[-1] != buf[
-1]: # edge case for very last byte in heap
data = buf[start:start + length]
result.append((start, data))
return result
# check if something changed
newstart, newstop = self.getStartStop()
if newstart == self.start and newstop == self.stop:
with open("/proc/%d/mem" % self.pid, "rb") as mem:
mem.seek(self.start)
buf = bytearray(self.stop - self.start)
assert self.stop - self.start == mem.readinto(buf)
newhash = hashlib.sha3_224(buf).digest()
if newhash != self.hash:
self.hash = newhash
tuplelist = findChanges()
self.heapbytes = buf
return "bytes", tuplelist
else:
return "same", 0
else:
ret = self.start, self.stop
self.start = newstart
self.stop = newstop
with open("/proc/%d/mem" % self.pid, "rb") as mem:
mem.seek(self.start)
self.heapbytes = bytearray(self.stop - self.start)
assert self.stop - self.start == mem.readinto(self.heapbytes)
self.hash = hashlib.sha3_224(self.heapbytes).digest()
return "length", ret
def hashIt(self):
inp = [str(self.k), str(self.nk), str(self.val), str(self.stype)]
s = hashlib.sha3_224()
#ToDO this type of hashing only string values of k,nk,val can generate same hash for different k,nk,val.
#TODO for example, (1,11,2) and (11,1,2) can give same hash.
#this method concat hashes of k,nk & v and then takes hash of the string.
for item in inp:
hasher = hashlib.sha3_224()
hasher.update(str(item))
s.update(hasher.hexdigest()[self.hindexi:self.hindexj])
return s.hexdigest()[self.hindexi:self.hindexj]
def add_data(word_file, salt_value=None, post_value=None, rep=0):
n = 0
# it will create rainbow table with given file
fp = open(word_file, 'r', encoding="Latin-1")
for word in fp:
try:
n += 1
word = word.strip(string.whitespace)
if salt_value is not None:
word = salt_value + word # Prepend the salt value
if post_value is not None:
word += post_value # append the salt value
if arg.verbose:
print(word)
if rep == 1:
chk = check_me(word)
if rep == 0:
chk = False
if chk is False:
# this function will create hashes
md5 = hashlib.md5(word.encode()).hexdigest()
sha1 = hashlib.sha1(word.encode()).hexdigest()
sha224 = hashlib.sha224(word.encode()).hexdigest()
blake2s = hashlib.blake2s(word.encode()).hexdigest()
blake2b = hashlib.blake2b(word.encode()).hexdigest()
sha3_384 = hashlib.sha3_384(word.encode()).hexdigest()
sha384 = hashlib.sha384(word.encode()).hexdigest()
sha3_512 = hashlib.sha3_512(word.encode()).hexdigest()
sha3_224 = hashlib.sha3_224(word.encode()).hexdigest()
sha512 = hashlib.sha512(word.encode()).hexdigest()
sha256 = hashlib.sha256(word.encode()).hexdigest()
sha3_256 = hashlib.sha3_224(word.encode()).hexdigest()
ntlm = (binascii.hexlify(
hashlib.new('md4',
word.encode('utf-16le')).digest())).decode()
sql.execute(
'insert into Hashes_Table(name, md5 , sha1, sha224 , blake2s , blake2b , sha3_384 , sha384 , sha3_512, '
'sha3_224, sha512, sha256, sha3_256, ntlm ) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?)',
(word, md5, sha1, sha224, blake2s, blake2b, sha3_384,
sha384, sha3_512, sha3_224, sha512, sha256, sha3_256,
ntlm))
except Exception:
print(Exception)
sql.commit()
print('WORD: ', n)
def _load_sdf(self, sdf_str):
"""
Adds the appropriate SDF to the sprite cache.
"""
kwargs, sdf_t = parse_sdf_str(sdf_str)
arg_str = ''.join([f'{k}={kwargs[k]}' for k in sorted(kwargs)])
cache_name = hashlib.sha3_224(arg_str.encode()).hexdigest()
path = os.path.join(
self.cache_dir,
f'SDF/{sdf_t}/{cache_name[:2]}/{cache_name[2:]}.png'
)
if path not in self._sprite_cache:
if not os.path.isfile(path):
cache_dir = os.path.split(path)[0]
if not os.path.isdir(cache_dir):
os.makedirs(cache_dir)
if sdf_t == 'box':
image = sdf.framed_box_im(**kwargs)
elif sdf_t == 'circle':
image = sdf.framed_circle_im(**kwargs)
else:
raise ValueError(f'Unknown SDF type: "{sdf_t}"')
image.save(path)
self._sprite_cache[path] = _image2sprite(image, self.factory)
else:
self._sprite_cache[path] = _image2sprite(
Image.open(path),
self.factory
)
return self._sprite_cache[path]
def test_hash_bytes():
test_string = b'hi there'
assert j.data.hash.md5(test_string) == hashlib.md5(test_string).hexdigest()
assert j.data.hash.sha1(test_string) == hashlib.sha1(
test_string).hexdigest()
assert j.data.hash.sha224(test_string) == hashlib.sha224(
test_string).hexdigest()
assert j.data.hash.sha256(test_string) == hashlib.sha256(
test_string).hexdigest()
assert j.data.hash.sha384(test_string) == hashlib.sha384(
test_string).hexdigest()
assert j.data.hash.sha512(test_string) == hashlib.sha512(
test_string).hexdigest()
assert j.data.hash.sha3_224(test_string) == hashlib.sha3_224(
test_string).hexdigest()
assert j.data.hash.sha3_256(test_string) == hashlib.sha3_256(
test_string).hexdigest()
assert j.data.hash.sha3_384(test_string) == hashlib.sha3_384(
test_string).hexdigest()
assert j.data.hash.sha3_512(test_string) == hashlib.sha3_512(
test_string).hexdigest()
assert j.data.hash.blake2b(test_string) == hashlib.blake2b(
test_string).hexdigest()
assert j.data.hash.blake2s(test_string) == hashlib.blake2s(
test_string).hexdigest()
assert j.data.hash.shake_128(test_string) == hashlib.shake_128(
test_string).hexdigest(16)
assert j.data.hash.shake_256(test_string) == hashlib.shake_256(
test_string).hexdigest(16)
def test_hash_strings():
test_string = "my company is codescalers"
assert j.data.hash.md5(test_string) == hashlib.md5(
test_string.encode()).hexdigest()
assert j.data.hash.sha1(test_string) == hashlib.sha1(
test_string.encode()).hexdigest()
assert j.data.hash.sha224(test_string) == hashlib.sha224(
test_string.encode()).hexdigest()
assert j.data.hash.sha256(test_string) == hashlib.sha256(
test_string.encode()).hexdigest()
assert j.data.hash.sha384(test_string) == hashlib.sha384(
test_string.encode()).hexdigest()
assert j.data.hash.sha512(test_string) == hashlib.sha512(
test_string.encode()).hexdigest()
assert j.data.hash.sha3_224(test_string) == hashlib.sha3_224(
test_string.encode()).hexdigest()
assert j.data.hash.sha3_256(test_string) == hashlib.sha3_256(
test_string.encode()).hexdigest()
assert j.data.hash.sha3_384(test_string) == hashlib.sha3_384(
test_string.encode()).hexdigest()
assert j.data.hash.sha3_512(test_string) == hashlib.sha3_512(
test_string.encode()).hexdigest()
assert j.data.hash.blake2b(test_string) == hashlib.blake2b(
test_string.encode()).hexdigest()
assert j.data.hash.blake2s(test_string) == hashlib.blake2s(
test_string.encode()).hexdigest()
assert j.data.hash.shake_128(test_string) == hashlib.shake_128(
test_string.encode()).hexdigest(16)
assert j.data.hash.shake_256(test_string) == hashlib.shake_256(
test_string.encode()).hexdigest(16)
def hashpassword(self, password):
salt = hashlib.sha3_512()
salt.update("$%&^&*())(&*^&%%$##$$#$%&^^(*(*++===".encode())
password += salt.hexdigest()
passw = hashlib.sha3_224()
passw.update(password.encode())
return passw.hexdigest()
def sha3_224_hex(hexstr):
if len(hexstr) % 2 != 0:
raise ValueError("Error: Length of hex string should be even")
m = hashlib.sha3_224()
data = binascii.a2b_hex(str(hexstr))
m.update(data)
return m.hexdigest()
async def MainParser(args):
user = args.user
server_conf = parse_config.parse()["Server"]
db = await create_pool.create(server_conf.get("mysql_db"))
logging.warning(_("Borrando usuario '%s' :-("), user)
userid = await db.return_first_result("extract_userid", user)
if (userid is None):
logging.error(_("El usuario no existe"))
return
else:
(userid, ) = userid
await db.return_first_result("delete_user", userid)
public_key_dst = "%s/pubkeys/%s" % (server_conf.get("init_path"),
hashlib.sha3_224(
user.encode()).hexdigest())
logging.debug(_("Borrando clave pública: %s"), public_key_dst)
if (os.path.isfile(public_key_dst)):
os.remove(public_key_dst)
else:
logging.warning(
_("No se pudo eliminar la clave pública porque no existe"))
logging.info(_("Usuario '%s' eliminado."), user)
def getImage(save_dir_path, img_list):
make_dir(save_dir_path)
save_img_path = os.path.join(save_dir_path, 'imgs')
make_dir(save_img_path)
opener = urllib.request.build_opener()
http = httplib2.Http(".cache")
for i in range(len(img_list)):
try:
url = img_list[i]
extension = os.path.splitext(img_list[i])[-1]
if extension.lower() in ('.jpg', '.jpeg', '.gif', '.png', '.bmp'):
encoded_url = url.encode(
'utf-8') # required encoding for hashed
a = hashlib.sha3_224()
hashed_url = hashlib.sha3_256(encoded_url).hexdigest()
full_path = os.path.join(save_img_path,
hashed_url + extension.lower())
response, content = http.request(url)
with open(full_path, 'wb') as f:
f.write(content)
print('saved image... {}'.format(url))
make_correspondence_table(correspondence_table, url,
hashed_url)
except Exception as e:
print(e)
print("failed to download images.")
continue
async def insert_user(user: str,
password: str,
token_limit: int = 1,
guest_user: bool = False,
*,
cursor) -> None:
"""Añade un nuevo usuario
Args:
user:
El nombre de usuario
password:
La contraseña
token_limit:
El límite de token's permitidos
guest_user:
**True** si es un usuario invitado; **False** si no.
"""
logging.debug(_("Creando nuevo usuario: %s"), user)
user_hash = hashlib.sha3_224(user.encode()).hexdigest()
await cursor.execute(
"INSERT INTO users(user, password, token_limit, user_hash, guest_user) VALUES (%s, %s, %s, %s, %s)",
(user, password, token_limit, user_hash, guest_user))
logging.debug(_("Usuario %s (%s) creado satisfactoriamente"), user,
user_hash)
def sha3_224(fname):
""" """
hash_sha3_224 = hashlib.sha3_224()
with open(fname, "rb") as f:
for chunk in iter(lambda: f.read(4096), b""):
hash_sha3_224.update(chunk)
return hash_sha3_224.hexdigest()
def test_content_access(self):
"""
Test access content from hard disk vs cache
Applies to cache versus web content & database store
"""
# test without memcached -- load from hard disk
trials = BoazBase.get_trial_size()
content = BoazBase.get_content_file()
start_time = time.perf_counter_ns()
for i in range(0, trials):
fd = open(content, "rb")
fd.read() # read from disk
end_time = time.perf_counter_ns()
BoazBase.print_time("\nContent from HD", trials, end_time - start_time)
# load content from cache
self.mc.flush_all()
key = str(
int(hashlib.sha3_224(content.encode('utf-8')).hexdigest()[:5],
16)).encode('utf-8')
fd = open(content, "rb")
bytes = fd.read() # read from disk once
self.mc.set(key, bytes) # store bytes in cache
start_time = time.perf_counter_ns()
for i in range(0, trials):
self.mc.get(key) # read from cache
end_time = time.perf_counter_ns()
BoazBase.print_time("\nContent from Cache", trials,
end_time - start_time)
fd.close()
def hasherFromString(s):
import hashlib
if s == 'sha1':
return hashlib.sha1()
elif s == 'sha224':
return hashlib.sha224()
elif s == 'sha256':
return hashlib.sha256()
elif s == 'sha384':
return hashlib.sha384()
elif s == 'sha512':
return hashlib.sha512()
elif s == 'blake2b':
return hashlib.blake2b()
elif s == 'blake2s':
return hashlib.blake2s()
elif s == 'md5':
return hashlib.md5()
elif s == 'sha3_224':
return hashlib.sha3_224()
elif s == 'sha3_256':
return hashlib.sha3_256()
elif s == 'sha3_384':
return hashlib.sha3_384()
elif s == 'sha3_512':
return hashlib.sha3_512()
elif s == 'shake_128':
return hashlib.shake_128()
elif s == 'shake_256':
return hashlib.shake_256()
else:
raise ValueError('Unknown hash type ' + s)
def hashing(name, string):
if name == 'SHA1':
return hashlib.sha1(string.encode('utf-8')).hexdigest()
elif name == 'SHA3_224':
return hashlib.sha3_224(string.encode('utf-8')).hexdigest()
elif name == 'SHA3_256':
return hashlib.sha3_256(string.encode('utf-8')).hexdigest()
elif name == 'SHA3_384':
return hashlib.sha3_384(string.encode('utf-8')).hexdigest()
elif name == 'SHA3_512':
return hashlib.sha3_512(string.encode('utf-8')).hexdigest()
elif name == 'SHA224':
return hashlib.sha224(string.encode('utf-8')).hexdigest()
elif name == 'SHA256':
return hashlib.sha256(string.encode('utf-8')).hexdigest()
elif name == 'SHA384':
return hashlib.sha384(string.encode('utf-8')).hexdigest()
elif name == 'SHA512':
return hashlib.sha512(string.encode('utf-8')).hexdigest()
elif name == 'MD5':
return hashlib.md5(string.encode('utf-8')).hexdigest()
elif name == 'BLAKE2b':
return hashlib.blake2b(string.encode('utf-8')).hexdigest()
elif name == 'BLAKE2s':
return hashlib.blake2s(string.encode('utf-8')).hexdigest()
def hashfun(text):
"""
Converts a str object to a hash which was configured in modules.conf of the cobbler settings.
:param text: The text to hash.
:type text: str
:return: The hash of the text. This should output the same hash when entered the same text.
"""
hashfunction = get_module_name("authentication", "hash_algorithm",
"sha3_512")
if hashfunction == "sha3_224":
hashalgorithm = hashlib.sha3_224(text.encode('utf-8'))
elif hashfunction == "sha3_384":
hashalgorithm = hashlib.sha3_384(text.encode('utf-8'))
elif hashfunction == "sha3_256":
hashalgorithm = hashlib.sha3_256(text.encode('utf-8'))
elif hashfunction == "sha3_512":
hashalgorithm = hashlib.sha3_512(text.encode('utf-8'))
elif hashfunction == "blake2b":
hashalgorithm = hashlib.blake2b(text.encode('utf-8'))
elif hashfunction == "blake2s":
hashalgorithm = hashlib.blake2s(text.encode('utf-8'))
elif hashfunction == "shake_128":
hashalgorithm = hashlib.shake_128(text.encode('utf-8'))
elif hashfunction == "shake_256":
hashalgorithm = hashlib.shake_256(text.encode('utf-8'))
else:
errortext = "The hashfunction (Currently: %s) must be one of the defined in /etc/cobbler/modules.conf!" \
% hashfunction
raise ValueError(errortext)
return hashalgorithm.hexdigest()
def s(n):
_h = hashlib.sha3_224()
buf = n.encode()
_h.update(buf)
H = _h.hexdigest()
print('SHA3 224: ' + H)
return H
def cmd_passwordSearch():
# initialize a string
password = input("\n Enter your password:"******"\nSHA3-224 Hash: ", obj_sha3_224.hexdigest())
print("\nSHA3-256 Hash: ", obj_sha3_256.hexdigest())
print("\nSHA3-384 Hash: ", obj_sha3_384.hexdigest())
print("\nSHA3-512 Hash: ", obj_sha3_512.hexdigest())
print("\nSHA3-keccak-512 Hash: ", keccak_hash.hexdigest())
sha3k512 = keccak_hash.hexdigest()
sub_pass = sha3k512[0:10]
#print("First 10 characters from the password:"******"https://passwords.xposedornot.com/api/v1/pass/anon/" + sub_pass)
json_data = json.loads(response.text)
print("\nOutput:", json_data)
def get_hash(self):
if exists(self.stdin) and isfile(self.stdin):
print(f"File: {self.stdin}")
with open(self.stdin, "rb") as f:
self.stdin = f.read()
if type(self.stdin) == str:
self.stdin = bytes(self.stdin.strip(), "utf8")
for h in self.hash_functions:
if h == "md5": yield ("MD5:", md5(self.stdin).hexdigest())
if h == "sha1": yield ("SHA1:", sha1(self.stdin).hexdigest())
if h == "sha224": yield ("SHA224:", sha224(self.stdin).hexdigest())
if h == "sha256": yield ("SHA256:", sha256(self.stdin).hexdigest())
if h == "sha384": yield ("SHA256:", sha384(self.stdin).hexdigest())
if h == "sha512": yield ("SHA512:", sha512(self.stdin).hexdigest())
if h == "sha3_224":
yield ("SHA3_224:", sha3_224(self.stdin).hexdigest())
if h == "sha3_256":
yield ("SHA3_256:", sha3_256(self.stdin).hexdigest())
if h == "sha3_384":
yield ("SHA3_384:", sha3_384(self.stdin).hexdigest())
if h == "sha3_512":
yield ("SHA3_512", sha3_512(self.stdin).hexdigest())
if h == "blake2b":
yield ("BLAKE2B:", blake2b(self.stdin).hexdigest())
if h == "blake2s":
yield ("BLAKE2S:", blake2s(self.stdin).hexdigest())
def hasherFromString(s):
import hashlib
if s == 'sha1':
return hashlib.sha1()
elif s == 'sha224':
return hashlib.sha224()
elif s == 'sha256':
return hashlib.sha256()
elif s == 'sha384':
return hashlib.sha384()
elif s == 'sha512':
return hashlib.sha512()
elif s == 'blake2b':
return hashlib.blake2b()
elif s == 'blake2s':
return hashlib.blake2s()
elif s == 'md5':
return hashlib.md5()
elif s == 'sha3_224':
return hashlib.sha3_224()
elif s == 'sha3_256':
return hashlib.sha3_256()
elif s == 'sha3_384':
return hashlib.sha3_384()
elif s == 'sha3_512':
return hashlib.sha3_512()
elif s == 'shake_128':
return hashlib.shake_128()
elif s == 'shake_256':
return hashlib.shake_256()
else:
return None
def haszowanie_sha3_224(tekst):
start = time.time()
wynik = hashlib.sha3_224(tekst.encode("utf8")).hexdigest()
end = time.time() - start
print("Skrot wygenerowany dzieki funkcji SHA3-224: " + wynik +
", czas generacji to: " + str(end * 1000) + " ms" +
", a dlugosc ciagu wyjsciowego to: " + str(len(wynik)))
def hash(self, data):
'''!
Method to generate a series of 12 hashes for a given data
string, in the format of <MD5>:<SHA1>:<SHA224>:<SHA3
244>:<SHA256>:<SHA3 256>:<SHA384>:<SHA3 384>:<SHA512>:<SHA3
215>:<Blake 2b>:<Blake 2s>.
@param data String: Data string to generate hash.
@return: Hash
'''
data = str(data)
data = bytes(data, 'utf-8')
x = [
hashlib.md5(data).hexdigest(),
hashlib.sha1(data).hexdigest(),
hashlib.sha224(data).hexdigest(),
hashlib.sha3_224(data).hexdigest(),
hashlib.sha256(data).hexdigest(),
hashlib.sha3_256(data).hexdigest(),
hashlib.sha384(data).hexdigest(),
hashlib.sha3_384(data).hexdigest(),
hashlib.sha512(data).hexdigest(),
hashlib.sha3_512(data).hexdigest(),
hashlib.blake2b(data).hexdigest(),
hashlib.blake2s(data).hexdigest()
]
return ':'.join(x)
def test_sha3224(self):
"""
Test SHA3-224 hash.
"""
if "sha3_224" not in hashlib.algorithms_available:
pass
else:
assert bh.hashlib_hash("tempfile.txt", hashlib.sha3_224()) == "93cc89107b9bd807dead1ae95ce8c4b0f9b8acb2a3eef704e2fad109"
def run(self, parent, blocks):
block = blocks.pop(0)
match = self.RE.search(block)
if match:
# If there's a match, then this is a labeled paragraph. We'll add
# the paragraph tag, label id, and initial text, then process the
# rest of the blocks normally.
label, text = match.group('label'), match.group('text')
# Labeled paragraphs without text should use a div element
if text == '':
el = util.etree.SubElement(parent, 'div')
else:
el = util.etree.SubElement(parent, 'p')
el.set('id', label)
# We use CSS classes to indent paragraph text. To get the correct
# class, we count the number of dashes in the label to determine
# how deeply nested the paragraph is. Inline interps have special
# prefixes that are removed before counting the dashes.
# e.g. 6-a-Interp-1 becomes 1 and gets a `level-0` class
# e.g. 12-b-Interp-2-i becomes 2-i and gets a `level-1` class
label = re.sub(
r'^(\w+\-)+interp\-', '', label, flags=re.IGNORECASE
)
# Appendices also have special prefixes that need to be stripped.
# e.g. A-1-a becomes a and gets a `level-0` class
# e.g. A-2-d-1 becomes d-1 and gets a `level-1` class
label = re.sub(r'^[A-Z]\d?\-\w+\-?', '', label)
level = label.count('-')
class_name = 'regdown-block level-{}'.format(level)
el.set('class', class_name)
el.text = text.lstrip()
elif block.strip():
if self.parser.state.isstate('list'):
# Pass off to the ParagraphProcessor for lists
super(ParagraphProcessor, self).run(
parent, blocks
) # pragma: no cover
else:
# Generate a label that is a hash of the block contents. This
# way it won't change unless the rest of this block changes.
text = block.lstrip()
label = sha3_224(text.encode('utf-8')).hexdigest()
class_name = 'regdown-block'
p = util.etree.SubElement(parent, 'p')
p.set('id', label)
p.set('class', class_name)
p.text = text
def get_engine(hashtype):
"""
Get hashlib engine from hash type.
:param hashtype: Hash type.
:type hashtype: str
"""
hashengines = {"md5": hashlib.md5(),
"sha1": hashlib.sha1(),
"sha224": hashlib.sha224(),
"sha256": hashlib.sha256(),
"sha384": hashlib.sha384(),
"sha512": hashlib.sha512()}
if utilities.new_enough(6):
hashengines.update({"sha3224": hashlib.sha3_224(),
"sha3256": hashlib.sha3_256(),
"sha3384": hashlib.sha3_384(),
"sha3512": hashlib.sha3_512()})
return hashengines[hashtype]
import sys
import hashlib
import sha3
# User is offered choice of input (file/string)
print("Welcome to hash checker. This program can calculate the hash of a string or file.")
question = input("Do you wish to check the hash of a string (S) or file (F)? Enter S or F: ")
# If user choses file, accept filename as input, open, read file, compute hashes
if question == "F" or question == "f":
filename = input("Enter a file name: ")
contents = open(filename, 'rb').read()
yoursha1 = hashlib.sha1(contents)
yoursha256 = hashlib.sha256(contents)
yoursha512 = hashlib.sha512(contents)
yoursha3224 = hashlib.sha3_224(contents)
yoursha3256 = hashlib.sha3_256(contents)
yoursha3384 = hashlib.sha3_384(contents)
yoursha3512 = hashlib.sha3_512(contents)
else:
# Prompt user to enter string and compute hashes
guess = input("\nPlease enter a string: ")
yoursha1 = hashlib.sha1(guess.encode())
yoursha256 = hashlib.sha256(guess.encode())
yoursha512 = hashlib.sha512(guess.encode())
yoursha3224 = hashlib.sha3_224(guess.encode())
yoursha3256 = hashlib.sha3_256(guess.encode())
yoursha3384 = hashlib.sha3_384(guess.encode())
yoursha3512 = hashlib.sha3_512(guess.encode())
# Convert hashes to readable form and print
