def makeMessage(magic, command, payload):
"""
4 magic uint32_t Magic value indicating message origin network, and used to seek to next message when stream state is unknown
12 command char[12] ASCII string identifying the packet content, NULL padded (non-NULL padding results in packet rejected)
4 length uint32_t Length of payload in number of bytes
4 checksum uint32_t First 4 bytes of sha256(sha256(payload))
? payload uchar[] The actual data
"""
from struct import pack
from hash import sha256
checksum = sha256(sha256(payload))[0:4]
return pack('<L12sL4s', magic, command, len(payload), checksum) + payload
def decrypt(self, ciphertext): hashValue = hash.sha256(rsa.decodeCiphertext(ciphertext, self.pubkey)) if hashValue in self.prevMessages: return "" else: self.prevMessages.add(hashValue) return map(lambda x: rsa.decryptInt(x, self.privkey), ciphertext)
def base58CheckEncode(payload):
from base58 import b58encode
from hash import sha256
def countLeadingZeroes(s):
count = 0
for c in s:
if c == '\0':
count += 1
else:
break
return count
checksum = sha256(sha256(payload))[0:4]
result = payload + checksum
return b'1' * countLeadingZeroes(result) + b58encode(result)
def mine(self, difficulty, diff_bits=None):
if (diff_bits != None):
if (diff_bits < difficulty): # diff bits must be over or equal to difficulty
return 'diff_bits too low'
elif (diff_bits > 0):
return 'bad diff_bits'
else:
# set self diff bits to the specifyed diff_bits
self.diff_bits = diff_bits
else:
# set the target diff bits to the minimum difficulty (difficulty var)
self.diff_bits = difficulty
txn_count = 0
for _ in self.transactions:
txn_count += 1
if (txn_count > 1):
if (self.transactions[0].type != 1):
amount = BLOCK_REWARD
coinbase_txn = coinbase(MINING_ADDR, amount)
tmp = self
for i in range(len(self.transactions)):
if (i == 0):
tmp.transactions[0] = coinbase_txn
else:
tmp.transactions[i] = self.transactions[i-1]
tmp.transactions.append(self.transactions[-1])
self.transactions = tmp.transactions
else:
self.transactions.append(coinbase(MINING_ADDR, BLOCK_REWARD))
work = self.as_bytes()
target = diff2target(self.diff_bits)
start = millis()
begin = start
hashes = 0
for nonce in range(max_nonce):
hashes += 1
if (millis() - start >= 60000):
log.info(
"Mining at {} h/s".format(math.ceil(hashes/((millis()-start)/1000))))
start = millis()
hashes = 0
# increment the nonce
self.nonce = nonce
work = self.as_bytes()
# hash the block
hash_result = sha256(work)
# print("hash={} nonce={} value={} target={}".format(hash_result, nonce, int(hash_result, 16), target))
# check if this is a valid result, below the target
if (check_diff(self.diff_bits, hash_result) == True):
# set the hash of self to the hash we found
self.hash = str(hash_result)
if nonce > 0 and millis()-begin > 0:
log.info(
"Avg. hashrate={} h/s".format(math.ceil(nonce/((millis()-begin)/1000))))
return None
def base58CheckDecode(payload):
from base58 import b58decode
from hash import sha256
def countLeadingOnes(s):
count = 0
for c in s:
if c == '1':
count += 1
else:
break
return count
nzeros = countLeadingOnes(payload)
payload = payload[nzeros:]
payload = b58decode(payload)
checksum = payload[-4:]
payload = b'\0' * nzeros + payload[:-4]
calculated_checksum = sha256(sha256(payload))[:4]
if checksum != calculated_checksum:
raise Exception('ivalid checksum')
return payload
def text_hash(self, i): s = self.coinbase["amount"] + self.coinbase["recipient"] if self.coinbase else "" for t in self.tx: s += t['amount'] + t['from'] + t['recipient'] if self.previous: s += self.previous.hash else: s += "0" * 64 return sha256(str(self.block) + str(i) + s)
def hash(self):
s = self.coinbase["amount"] + self.coinbase[
"recipient"] if self.coinbase else ""
for t in self.tx:
s += t.to_string()
if self.previous:
s += self.previous.hash
else:
s += "0" * 64
return sha256(str(self.block) + str(self.nonce) + s)
def create_index(basepath, includes=[], excludes=[], archive=None):
basepath = os.path.normpath(basepath)
fileindex = FileIndex(basepath)
filefilter = FileFilter(includes=includes, excludes=excludes)
# Read the files in the directory.
queue = [basepath]
while len(queue) > 0:
path = queue.pop()
if filefilter.is_filtered(path): continue
try:
if os.path.isdir(path):
for child in os.listdir(path): queue.append(os.path.join(path, child))
else:
fd = create_descriptor(path, basepath)
old_fd = archive[fd.relpath] if archive else None
if not old_fd:
sys.stdout.write('Calculating SHA256 for {}... '.format(path))
starttime = time.time()
fd.sha256 = sha256 = hash.sha256(path)
sys.stdout.write('({})\n'.format(datetime.timedelta(seconds=time.time()-starttime)))
sys.stdout.flush()
if archive: archive.insert(fd)
elif old_fd.size != fd.size or old_fd.mtime != fd.mtime:
sys.stdout.write('Calculating SHA256 for {}... '.format(path))
starttime = time.time()
fd.sha256 = sha256 = hash.sha256(path)
sys.stdout.write('({})\n'.format(datetime.timedelta(seconds=time.time()-starttime)))
sys.stdout.flush()
if archive: archive.update(fd)
else:
fd.sha256 = old_fd.sha256
fileindex.files.append(fd)
except (EnvironmentError, SystemError) as e:
sys.stderr.write('Could not process {}: {}\n'.format(path, e))
sys.stderr.flush()
return fileindex
def do_work(filename, list_data, pkgname_parent="", flag_delete=False):
logger_do_work = logging.getLogger("do_work")
l = []
for sub_filename in walk_dir(filename):
if os.path.islink(sub_filename):
os.unlink(sub_filename)
logger_do_work.debug('unlink %s' % sub_filename)
continue
#FIXME: 判断解压临时存储位置是否能放得下
#TODO: 考虑分片读取数据降低内存压力
file_bindata = open(sub_filename, 'rb').read()
d_md5 = hash.md5(file_bindata)
d_sha1 = hash.sha1(file_bindata)
d_sha256 = hash.sha256(file_bindata)
filesize = os.stat(sub_filename).st_size
cmd = 'file "%s" | cut -c %s-' % (sub_filename, len(sub_filename) + 3)
logger_do_work.debug(cmd)
filetype = os.popen(cmd).read().strip()
if os.path.isfile(filename):
t_filename = sub_filename[sub_filename.index(pkgname_parent) +
len(pkgname_parent):]
else:
t_filename = sub_filename.partition(filename)[2]
if is_pack(sub_filename):
dir_temp = o_unpack.unpack(sub_filename)
pkg_info = (t_filename, pkgname_parent, d_md5, d_sha1, d_sha256,
filesize, filetype)
logger_do_work.debug("recursive do_work start: %s", t_filename)
ll = do_work(dir_temp, list_data, t_filename, flag_delete=True)
logger_do_work.debug("recursive do_work end: %s", t_filename)
d = {}
d[pkg_info] = ll
l.append(d)
else:
l.append((t_filename, pkgname_parent, d_md5, d_sha1, d_sha256,
filesize, filetype))
if flag_delete:
removefiles(sub_filename)
else:
if flag_delete:
removefiles(filename)
return l
def do_work(filename, list_data, pkgname_parent="", flag_delete=False):
logger_do_work = logging.getLogger("do_work")
l = []
for sub_filename in walk_dir(filename):
if os.path.islink(sub_filename):
os.unlink(sub_filename)
logger_do_work.debug('unlink %s' % sub_filename)
continue
#FIXME: 判断解压临时存储位置是否能放得下
#TODO: 考虑分片读取数据降低内存压力
file_bindata = open(sub_filename, 'rb').read()
d_md5 = hash.md5(file_bindata)
d_sha1 = hash.sha1(file_bindata)
d_sha256 = hash.sha256(file_bindata)
filesize = os.stat(sub_filename).st_size
cmd= 'file "%s" | cut -c %s-' % (sub_filename, len(sub_filename)+3)
logger_do_work.debug(cmd)
filetype =os.popen(cmd).read().strip()
if os.path.isfile(filename):
t_filename = sub_filename[sub_filename.index(pkgname_parent)+len(pkgname_parent):]
else:
t_filename = sub_filename.partition(filename)[2]
if is_pack(sub_filename):
dir_temp = o_unpack.unpack(sub_filename)
pkg_info = (t_filename, pkgname_parent, d_md5, d_sha1, d_sha256, filesize, filetype)
logger_do_work.debug("recursive do_work start: %s", t_filename)
ll = do_work(dir_temp,list_data, t_filename, flag_delete=True)
logger_do_work.debug("recursive do_work end: %s", t_filename)
d = {}
d[pkg_info] = ll
l.append(d)
else:
l.append((t_filename, pkgname_parent, d_md5, d_sha1, d_sha256, filesize, filetype))
if flag_delete:
removefiles(sub_filename)
else:
if flag_delete:
removefiles(filename)
return l
def login(self, ip, port): sendSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sendSocket.connect((ip, port)) sendSocket.send(str(self.username)+","+str(self.publicValue)) salt, serverPublicValue = self.recieveServerValues(sendSocket) if salt is None or serverPublicValue is None: sendSocket.close() return False sharedSecret = convert.intToByteString(hash.sha256(convert.intToByteString(self.sharedSecretValue))) validator = srp.generateClientValidator(sharedSecret, salt) sendSocket.send(str(validator)) if self.recieveOK(sendSocket): sendSocket.close() return True sendSocket.close() return False
def runServer(self):
#Socket setup
recieveSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
recieveSocket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR, 1)
recieveSocket.bind(("", self.port))
recieveSocket.listen(5)
#Establish connection
clientSock, _ = recieveSocket.accept()
userName, clientPublicValue = self.recieveClientValues(clientSock)
#Error case
if userName is None or clientPublicValue is None:
return
passwordVerifier, salt = self.users[userName]
sessionPrivateKey = srp.generatePrivateKey()
u = random.randint(0, 2**128)
#Send public values
clientSock.sendall(str(convert.byteStringToInt(salt))+","+str(dh.generatePublicValue(sessionPrivateKey, srp.STANDARD_G, srp.STANDARD_N))+","+str(u))
#Derive shared secret
sharedSecret = pow(clientPublicValue*pow(passwordVerifier, u, srp.STANDARD_N), sessionPrivateKey, srp.STANDARD_N)
sharedSecret = convert.intToByteString(hash.sha256(convert.intToByteString(sharedSecret)))
clientValidator = self.recieveClientValidator(clientSock)
#Error check
if clientValidator is not None:
if clientValidator == srp.generateClientValidator(sharedSecret, salt):
clientSock.sendall("OK")
return
try:
clientSock.sendall("NOTOK")
except Exception:
pass
def radio_button_selection(selection, filepath, label):
""" Get selection from the radio button
Parameters
----------
selection: int
Algorithm choice between MD5 and SHA-256
filepath: str
A string representing the absolute path of the file
label: Label()
Text label representing the final hash (result)
"""
algorithm_choice = selection.get()
if algorithm_choice == 1:
result_hash = hash.md5(filepath)
elif algorithm_choice == 2:
result_hash = hash.sha256(filepath)
else:
result_hash = "Error while computing hash"
label.config(text=result_hash)
def login(self, ip, port): sendSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sendSocket.connect((ip, port)) privateKey = srp.generatePrivateKey() sendSocket.send(str(self.username)+","+str(srp.generateClientPublicValue(privateKey))) salt, serverPublicValue, u = self.recieveServerValues(sendSocket) if salt is None or serverPublicValue is None or u is None: sendSocket.close() return False x = srp.getHashInt(self.password+salt) sharedSecret = pow(serverPublicValue, (privateKey+u*x), srp.STANDARD_N) sharedSecret = convert.intToByteString(hash.sha256(convert.intToByteString(sharedSecret))) validator = srp.generateClientValidator(sharedSecret, salt) sendSocket.send(str(validator)) if self.recieveOK(sendSocket): sendSocket.close() return True sendSocket.close() return False
def getHashInt(value): return hash.sha256(value)
def sign_data(privkey, data):
from hash import sha256
datahash = sha256(sha256(data))
return sign_hash(privkey=privkey, datahash=datahash)
def seed2bin(seed, nonce=0):
from hash import sha256, keccak256, blake256
from struct import pack
data = pack(">L", nonce) + str2bytes(seed)
return sha256(keccak256(blake256(data)))
def text_hash(self, i):
return sha256(str(self.block) + str(i) + self.data)
def hash(self):
return sha256(str(self.block) + str(self.nonce) + self.data)
def generateClientValidator(self, password, salt, clientPublicValue, serverPrivateKey, u, debug = False): passwordVerifier = srp.generatePasswordVerifier(password, salt) sharedSecret = pow(clientPublicValue * pow(passwordVerifier, u, srp.STANDARD_N), serverPrivateKey, srp.STANDARD_N) sharedSecret = convert.intToByteString(hash.sha256(convert.intToByteString(sharedSecret))) return srp.generateClientValidator(sharedSecret, salt)
def flawedCheckSignature(message, signature, publicKey):
decryptedSignature = decryptString(signature, publicKey, True)
messageDigest = convert.intToByteString(hash.sha256(message))
return re.match(chr(0)+chr(1)+chr(255)+"+"+chr(0)+re.escape(messageDigest), decryptedSignature) is not None
def serverDeriveSharedSecret(clientPublicValue, serverPrivateKey, passwordVerifier, g= STANDARD_G, k = STANDARD_K, N = STANDARD_N): publicValueHash = derivePublicValueHash(clientPublicValue, generateServerPublicValue(serverPrivateKey, passwordVerifier, g, k, N)) S = pow(clientPublicValue*pow(passwordVerifier, publicValueHash, N), serverPrivateKey, N) return convert.intToByteString(hash.sha256(convert.intToByteString(S)))
def hash(self): s = self.previous.hash if self.previous else "0" * 64 return sha256(str(self.block) + str(self.nonce) + str(self.data) + s)
def text_hash(self, i): s = self.previous.hash if self.previous else "0" * 64 return sha256(str(self.block) + str(i) + str(self.data) + s)
def derivePublicValueHash(publicValueA, publicValueB): return hash.sha256(convert.intToByteString(publicValueA) + convert.intToByteString(publicValueB))
def hash_in(self):
work = self.as_bytes()
self.hash = sha256(work)
return self.hash
def clientDeriveSharedSecret(password, salt, clientPrivateKey, serverPublicValue, g = STANDARD_G, k = STANDARD_K, N = STANDARD_N): x = getHashInt(password+salt) publicValueHash = derivePublicValueHash(generateClientPublicValue(clientPrivateKey, g, N), serverPublicValue) S = pow((serverPublicValue - k*pow(g, x, N)), (clientPrivateKey+publicValueHash*x), N) return convert.intToByteString(hash.sha256(convert.intToByteString(S)))