def make_message() -> bytes:
pub_header = PublicHeader()
pub_header.protocol_version = bytes(VERSION, 'ascii')
pub_header.packet_number = 1
pub_header.connection_id = random.randint(0, 0xffffffffffffffff)
chlo_msg = handshake.Message()
chlo_msg.tag = b'CHLO'
chlo_msg.tags = tags.Container({
'VER': VERSION, 'PDMD': 'X509',
'PAD': b'\x00' * 1000
})
chlo_msg_buff = chlo_msg.to_bytes()
stream_header = StreamFrameHeader()
stream_header.id = 1
stream_header.has_data_length = True
stream_header.data_length = len(chlo_msg_buff)
# TODO: infer id length from id field.
stream_header.id_length = 1
pub_header_buff = pub_header.to_bytes()
stream_header_buff = stream_header.to_bytes()
padding = b'\x00' * (1300 - (len(pub_header_buff) + 12 \
+ len(stream_header_buff) + len(chlo_msg_buff)))
packet_hash = fnv.hash(pub_header_buff + stream_header_buff + chlo_msg_buff + padding)
return pub_header_buff + packet_hash.to_bytes(16, byteorder='little')[:12] \
+ stream_header_buff + chlo_msg_buff + padding
def make_message() -> bytes:
pub_header = PublicHeader()
pub_header.protocol_version = bytes(VERSION, 'ascii')
pub_header.packet_number = 1
pub_header.connection_id = random.randint(0, 0xffffffffffffffff)
chlo_msg = handshake.Message()
chlo_msg.tag = b'CHLO'
chlo_msg.tags = tags.Container({
'VER': VERSION,
'PDMD': 'X509',
'PAD': b'\x00' * 1000
})
chlo_msg_buff = chlo_msg.to_bytes()
stream_header = StreamFrameHeader()
stream_header.id = 1
stream_header.has_data_length = True
stream_header.data_length = len(chlo_msg_buff)
# TODO: infer id length from id field.
stream_header.id_length = 1
pub_header_buff = pub_header.to_bytes()
stream_header_buff = stream_header.to_bytes()
padding = b'\x00' * (1300 - (len(pub_header_buff) + 12 \
+ len(stream_header_buff) + len(chlo_msg_buff)))
packet_hash = fnv.hash(pub_header_buff + stream_header_buff +
chlo_msg_buff + padding)
return pub_header_buff + packet_hash.to_bytes(16, byteorder='little')[:12] \
+ stream_header_buff + chlo_msg_buff + padding
def get_index_of_word(self, word):
hash = None
if (word in self.dict):
hash = self.dict[word]
else:
hash_input_int = fnv.hash(word.encode('utf-8'), bits=64)
hash = (self.a * hash_input_int + self.b) % self.p
self.dict[word] = hash
return hash
def calc_packet_hash(self) -> int:
"""Calculates packet hash.
FNV-1a algorithm is used to hash the packet content.
Returns:
96 bit packet hash.
"""
self._ensure_packet_hash_offset_is_set()
without_hash = bytes_excluded(self.data, self.packet_hash_offset,
PACKET_HASH_SIZE)
return fnv.ensure_bits_count(fnv.hash(without_hash),
PACKET_HASH_SIZE * 8)
def calc_packet_hash(self) -> int:
"""Calculates packet hash.
FNV-1a algorithm is used to hash the packet content.
Returns:
96 bit packet hash.
"""
self._ensure_packet_hash_offset_is_set()
without_hash = bytes_excluded(self.data, self.packet_hash_offset,
PACKET_HASH_SIZE)
return fnv.ensure_bits_count(
fnv.hash(without_hash), PACKET_HASH_SIZE * 8)
def fnv1Hash(file):
total = 0
count = 0
with open(file, "r", encoding='utf-8') as f:
for line in f:
if (line[0] == 'Q'):
x = fnv.hash(line.encode(), algorithm=fnv.fnv, bits=64)
binVal = str(format(x, '#010b'))
binVal = binVal.replace('0b', "")
binVal = binVal.split('1')
if (binVal[-1] != ''):
total += pow(2, len(binVal[-1]))
count += 1
return ([total, count])
def main(json_file):
hashes = [
0x3944AA7E,
0x7EA69E72,
0xDBA7A248,
0x57FF1EA4,
0x71948CA4,
]
names = json.load(open(json_file, "r"))
for i in names:
n = i["name"] if i["name"] != "None" else i["orig-name"]
if n != "None" and n is not None:
# s = fnv.hash(n[2:].encode("ascii") + b"\x00", algorithm=fnv.fnv_1a, bits=32)
s1 = fnv.hash(n[2:].encode("ascii"), algorithm=fnv.fnv_1a, bits=32)
if s1 in hashes:
print("%s: 0x%X" % (n, s1))
def _hash(x):
return fnv.hash(str.encode(x)) % num_bucket
def _hash(self, word):
return fnv.hash(str.encode(word)) % self.length
def hash_function(a, b, word):
encoded_word = fnv.hash(word.encode("utf-8"), bits=64)
hf = (a * encoded_word + b) % p
return hf
def it_returns_the_calculated_hash_for_specified_data():
data = b'\x01\x02\x03\x04'
assert_that(fnv.hash(data, algorithm=fnv.fnv_1a),
is_(136442159731806137627837275212626352805))
p=ayy[:,0:21]
z=ayy[:,1:21]
for i in range(len(x)):
train.append(x[i])
for i in range(len(z)):
test.append(z[i])
BFM=[0]*2381
for i in range(len(train)):
y=xxhash.xxh32()
y.update(str(train[i]))
h1=y.intdigest()%794
h2=m.hash(str(train[i]))%794
h3=(fnv.hash(train[i],algorithm=fnv.fnv_1a,bits=64))%793
BFM[h1]=1
BFM[h2+794]=1
BFM[h3+1588]=1
ds=open("outputBFM.csv","w")
ds.write("NAME,MALWARE,BEGING\n")
for i in range(len(test)):
mal=0
ben=0
y=xxhash.xxh32()
y.update(str(test[i]))
h1=y.intdigest()%794
h2=m.hash(str(test[i]))%794
h3=(fnv.hash(test[i],algorithm=fnv.fnv_1a,bits=64))%793
if(BFM[h1]==1 and BFM[h2+794]==1 and BFM[h3+1588]==1):
def _hash(word):
return fnv.hash(str.encode(word)) % 10000000
def hash(self, bits=32):
return fnv.hash(self.name, algorithm=fnv.fnv_1a, bits=bits)
def ngram2Vector(self, ngram, model):
id = fnv.hash(str.encode(ngram)) % model.shape[0]
return model[id]
def ngram2Vector(self, ngram):
id = fnv.hash(str.encode(ngram)) % self.fasttext_model_ngram.shape[0]
return self.fasttext_model_ngram[id]
def get_task(client, table, owner_id, project, task_id):
suffix = "{:04X}".format(
fnv.hash(task_id.encode(), algorithm=fnv.fnv_1a, bits=32) % 0x10000)
upa = "{}:{}:{}:{}".format(owner_id, project,
task_id.split('-')[0], suffix)
return get_row(client, table, {"UPA": upa, "TaskID": task_id})
def it_allows_to_specify_hash_size_in_bits():
data = b'\x01\x02\x03\x04'
assert_that(fnv.hash(data, algorithm=fnv.fnv_1a, bits=64),
is_(13725386680924731485))
