def test_to_from_sign(self):
r = 100
s = 911
sig = Signature()
D = sig.to_signature(r, s)
r1, s1 = sig.from_signature(D)
assert r == r1
assert s == s1
def seal(self):
"""
Seal method.
"""
self._env_res = self._envelope.encrypt()
message = str(self._envelope.cipher) + str(self._envelope.crypt_key)
self._signature = Signature(self._sha, self._rsa_key, message)
self._signature.sign()
def do_calculation(options):
if options.report is None:
options.report = "report.txt"
print "Creating file for report ({0}/{1})".format(os.getcwd(), options.report)
hash = hashModule.get_hash(options.data)
sign = Signature.getSignature(hash)
sign["H"] = hash
ElGamalSignatureIO.writeElGamalSignature(sign, options.report, options.data)
print "\nSignature was successful write to {0}/{1}".format(os.getcwd(), options.report)
def signMessage(self, message):
usedLeaf = self.pickLeaf()
print("Hash used Leaf:")
keyPair = usedLeaf.getKeyPair()
singleSignature = self.generator.createSignatureForMessage(
message, keyPair)
leaf = usedLeaf
hashesNeededToVerify = self.getHashesOfSiblings(leaf)
return Signature(keyPair[0], singleSignature, hashesNeededToVerify)
def encrypter(self):
self.generateAesKey()
encodedImage = self.imageToBase64() #bytes
image = encodedImage.decode() #string
paddingLength = math.ceil(len(image) / 16) * 16 - len(image)
image = image + " " * paddingLength
encryptedImage = self.AES_Key.encrypt(image.encode())
publicKey = RSA.importKey(self.loadKey())
encryptedAES = self.AES_KeyEncryption(publicKey)
sign = Signature(self.imagePath)
encryption = []
encryption.append(self.AES_Key.iv)
encryption.append(encryptedAES)
encryption.append(encryptedImage)
encryption.append(sign.generateSignature())
self.save(encryption)
class Seal:
"""
Class Seal represents digital seal.
It combines digital envelope and digital signature.
"""
def __init__(self, encryption_algorithm, key_type, rsa_key_size, message,
mode, sha_type):
"""
Initialization method.
:param encryption_algorithm: which symmetric algorithm will be used
:param key_type: key size for the symmetric algorithm
:param rsa_key_size: key size for the asymmetric algorithm
:param message: encryption data
:param mode: mode of the symmetric algorithm
:param sha_type: SHA-2 type
"""
self._sha = sha_type
self._rsa_key = rsa_key_size
# generate envelope
self._envelope = Envelope(encryption_algorithm, key_type, rsa_key_size,
message, mode)
self._signature = None
# envelope encryption result
self._env_res = None
def seal(self):
"""
Seal method.
"""
self._env_res = self._envelope.encrypt()
message = str(self._envelope.cipher) + str(self._envelope.crypt_key)
self._signature = Signature(self._sha, self._rsa_key, message)
self._signature.sign()
def unseal(self):
"""
Unseal method.
:return: original message
"""
msg = self._envelope.decrypt(self._env_res)
# verifies the signature
verification = self._signature.verify()
return msg, verification
def set_signature_value(self, interest, private_key):
"""
It uses set_signature class method in the Signature module to do actual signature
so different digital signature algorithms can be used without affecting the interest
:param interest: main content
:param private_key: private key of the user
:return: sets the signature value in the object
"""
signature = Signature.set_signature(interest, private_key)
self.get_signature_value().set_tlv_value(signature)
def do_check(options):
readSign = ElGamalSignatureIO.readParseElGamalSignature(options.data)
if os.path.isfile(readSign["path"]) is False:
print "File does not exist '{0}'".format(readSign["path"])
exit()
if options.path is None:
hash = hashModule.get_hash(readSign["path"])
else:
hash = hashModule.get_hash(options.path)
sign = Signature.getSignature(hash)
if readSign["H"] == hash and Signature.verificationSignature(readSign) is True:
print "\nSignature is correct."
else:
print "\nSignature is incorrect."
print "Read data"
for x, y in readSign.items():
if x != "path":
print "\t{0} is {1}".format(x, format(y, "032x"))
print "Caclulated signature"
for x, y in sign.items():
print "\t{0} is {1}".format(x, format(y, "032x"))
def read_corpus(CONTEXT):
sig = Signature()
token_frequency = {}
# Build the word to int mapping and count frequencies
logger.info("First iteration: Counting words and create signature.")
for word in brown.words():
word_id = sig.add_word(word)
token_frequency[word_id] = 1 + token_frequency.get(word_id, 0)
logger.info("Identifying infrequent words that will be ignored.")
too_infrequent_words = set([word for word, count in token_frequency.items()
if count < THRESHOLD])
# Create the actual corpus
logger.info("Second iteration: Creating cleaned numeric corpus.")
corpus = []
for word in brown.words():
word_id = sig.get_for_word(word)
if word_id not in too_infrequent_words:
corpus.append(word_id)
x = []
y = []
# Create the windows and create data and labels
logger.info("Third iteration: Creating context windows.")
for i in range(len(corpus)):
c = i + CONTEXT
if c + CONTEXT < len(corpus):
before = corpus[c - CONTEXT: c]
after = corpus[c + 1: c + CONTEXT + 1]
x.append(np.array(before + after))
y.append(corpus[c])
return (np.array(x, dtype='int32'),
np.array(y, dtype='int32'),
np.asarray(sig.int_to_word),
sig)
def read_corpus(CONTEXT):
sig = Signature()
token_frequency = {}
# Build the word to int mapping and count frequencies
logger.info("First iteration: Counting words and create signature.")
for word in brown.words():
word_id = sig.add_word(word)
token_frequency[word_id] = 1 + token_frequency.get(word_id, 0)
logger.info("Identifying infrequent words that will be ignored.")
too_infrequent_words = set(
[word for word, count in token_frequency.items() if count < THRESHOLD])
# Create the actual corpus
logger.info("Second iteration: Creating cleaned numeric corpus.")
corpus = []
for word in brown.words():
word_id = sig.get_for_word(word)
if word_id not in too_infrequent_words:
corpus.append(word_id)
x = []
y = []
# Create the windows and create data and labels
logger.info("Third iteration: Creating context windows.")
for i in range(len(corpus)):
c = i + CONTEXT
if c + CONTEXT < len(corpus):
before = corpus[c - CONTEXT:c]
after = corpus[c + 1:c + CONTEXT + 1]
x.append(np.array(before + after))
y.append(corpus[c])
return (np.array(x, dtype='int32'), np.array(y, dtype='int32'),
np.asarray(sig.int_to_word), sig)
def Build_Weight_Database( self,
database,
version,
num_of_kpts,
cutoff,
force_update = False,
K = 10,
depth = 4,
nleaves = 10000):
updated = self.Train_Database_Sign(database,version, num_of_kpts, force_update, K, depth, nleaves)
#load signature
sign_dir = os.path.join(self.SIGN_DIR, 'db_version_' + str(version))
sign = Signature()
sign.load_sign(sign_dir, self.SIGN_FILE+str(num_of_kpts))
print 'Siganture Loaded'
wt_file = os.path.join(sign_dir, self.WEIGHT_FILE+str(num_of_kpts)+'_'+str(cutoff))
wts_file = os.path.join(sign_dir, self.WEIGHT_SIGN_FILE+str(num_of_kpts)+'_'+str(cutoff))
if updated or (not os.path.isfile(wt_file) and not os.path.isfile(wts_file)):
wt = Weight(cutoff)
wt.get_weight(sign.sign_database)
wt.weight_train_database(sign.sign_database)
wt.save_weights(sign_dir, self.WEIGHT_FILE+str(num_of_kpts)+'_'+str(cutoff))
wt.save_weighted_sign(sign_dir, self.WEIGHT_SIGN_FILE+str(num_of_kpts)+'_'+str(cutoff))
print ' '
print 'Wegihted Sign Generated'
else:
print 'Weighted Sign Has Already Been Generated'
def sign(self, z):
"""Sign the content
Parameters
----------
z :
xxxxxx
"""
k = randint(
0, N
) # random number integer from 0 to N. >>>>>>>>>>>>>>>> TODO: for real-world applications, need to use better generator
r = (k * G).x.num # is the x coordinate of kG
k_inv = pow(
k, N - 2,
N) # fermat's litthe theorem with n, which is a prime number
s = (z + r * self.secret) * k_inv % N # s = (z + re) / k
if s > N / 2:
s = N - s
return Signature(r, s)
def getSignatures(signatureFile):
fp = open(signatureFile, "rb")
content = fp.read()
fp.close()
litteral = Word(alphas + nums + "_")
regex_pattern = CharsNotIn("(")
tags = (OneOrMore(Group('#' + litteral))).setResultsName("tags")
hierarchy_modifier = oneOf("<= =")
java_type = Group(
Optional(hierarchy_modifier) +
Word(alphas + nums + "_" + "." + "[" + "]" + "$"))
return_type = (java_type | "*").setResultsName("return_type")
method_name = (litteral | "<init>"
| regex_pattern).setResultsName("method_name")
parameter = Group((java_type + litteral))
parameter_list = (delimitedList(parameter)
| "*").setResultsName("parameters")
body_instruction = (CharsNotIn("{;}"))
signature_body = (delimitedList(body_instruction,
";")).setResultsName("signature_body")
class_name = (java_type
| Group(Optional(hierarchy_modifier) +
CharsNotIn(":"))).setResultsName("class_name")
signature_stmt = Group((Optional(tags) + return_type + class_name+":"+method_name+ \
"(" + Optional(parameter_list) + ")"+"{"+Optional(signature_body)+"}"))
grammar = OneOrMore(signature_stmt)
grammar.ignore(dblSlashComment)
result = grammar.parseString(content)
#IPython.embed()
#debug_db_data(content,result)
signatures = [Signature(sig) for sig in result]
return signatures
def op_checksig(stack, z):
# check that there are at least 2 elements on the stack
if len(stack) < 2:
return False
# the top element of the stack is the SEC pubkey
sec_pubkey = stack.pop()
# the next element of the stack is the DER signature
# take off the last byte of the signature as that's the hash_type
der_signature = stack.pop()[:-1]
# parse the serialized pubkey and signature into objects
try:
point = S256Point.parse(sec_pubkey)
sig = Signature.parse(der_signature)
except (ValueError, SyntaxError) as e:
LOGGER.info(e)
return False
# verify the signature using S256Point.verify()
# push an encoded 1 or 0 depending on whether the signature verified
if point.verify(z, sig):
stack.append(encode_num(1))
else:
stack.append(encode_num(0))
return True
print ioerror
def load_weighted_sign(self, file_dir, file_name):
try:
with open(os.path.join(file_dir, file_name), 'rb') as file_data:
self.weighted_sign = np.load(file_data)
except IOError as ioerror:
print ioerror
if __name__ == '__main__':
# load signature
L = (10**(4+1)-1) / (10-1) - 1
sign_database = np.empty(shape=(180, L))
sign = Signature()
sign.load_sign('./Signature/1000/', 'sign_1000')
wt = Weight(0.01)
wt.get_weight(sign.sign_database)
#print wt.weights
wt.weight_train_database(sign.sign_database)
wt.save_weights('./Signature/1000/', 'weights')
wt.save_weighted_sign('./Signature/1000/', 'weighted_sign')
def verify_signature(self, data, public_key):
signature = self.get_value()
claim = Signature.verify_signature(data, signature, public_key)
return claim
def Classifier(self,
database,
version,
num_of_kpts,
cutoff,
top = 5,
K = 10,
depth=4):
num_in_set = database[0]
num_of_sets = database[1]
test_database = database[3]
total = num_in_set * num_of_sets
num_in_test_set = len(test_database) / num_of_sets
classify_score =np.zeros(num_of_sets)
class_name = [[] for i in range(num_of_sets)]
#load weight
wt = Weight(cutoff)
sign_dir = os.path.join(self.SIGN_DIR, 'db_version_' + str(version))
wt.load_weights(sign_dir, self.WEIGHT_FILE+str(num_of_kpts)+'_'+str(cutoff))
wt.load_weighted_sign(sign_dir, self.WEIGHT_SIGN_FILE+str(num_of_kpts)+'_'+str(cutoff))
#Load tree
tree_dir = os.path.join(self.TREE_DIR, 'db_version_' + str(version))
tr = vl._vlfeat.VlHIKMTree(0, 0)
tr.load(os.path.join(tree_dir, str(num_of_kpts) + self.TREE_FILE))
for k in test_database:
#randomly get image from the img_dir
img = Image.open(k[2]).convert('L')
img = self.StandalizeImage(img, 480)
img_data = np.asarray(img, dtype=float)
#generate desc, sign and weighted sign
kp = Keypoint()
#kp.load_keypoint(self.KEYPOINT_DIR, self.KEYPOINT_FILE+str(num_of_kpts))
kp.generate_keypoint(num_of_kpts, img.size[0], img.size[1], self.SIGMA)
desc = Descriptor()
desc.generate_desc(img_data, kp.kpt)
#very important !! convert desc to float type
#desc_f = np.array(desc.desc, dtype=float)
sign = Signature()
s = sign.generate_sign(tr,desc.desc, K, depth)
weighted_sign = wt.weight_sign(s)
#vote
d=np.empty(total)
for i in range(0, total):
d[i] = self.dist(wt.weighted_sign[i,:], weighted_sign)
perm = np.argsort(d)
vote_for = np.floor((perm[0:top])/num_in_set)+1
votes = vl.vl_binsum(np.zeros(num_of_sets), np.ones(top), vote_for)
#print votes
best = np.argmax(votes)
if best == k[1]:
classify_score[k[1]] += 1
print '=>'+str(k[0])
class_name[k[1]] = k[3]
classify_score = classify_score / num_in_test_set
return zip(class_name, classify_score.tolist())
def test_generate_signature(self):
nonce = "F6LAN4jmikVPqNllhwnHnEvtXH0obTY4"
s = Signature(TestSignature.secret)
signed_request = s.generate(self._emulate_post_request(),nonce)
self.assertEqual(signed_request['signature']['token'],'987a82c940ccde6adc557a2d6b564a61488d3605')
def test_rand_int(self):
s = Signature()
for i in range(10):
r = s.rand_int()
print(r.bit_length())
def do_debug(options): hash = hashModule.get_hash(options.data) Signature.debugVerificationSignature(hash)
def set_signature_info(self):
sign_info = Signature.info()
self.get_signature_info().set_tlv_value(sign_info)
import json
from base64 import b64encode
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from base64 import b64decode
import random
import string
from Signature import Signature
from Crypto.Hash import SHA256
signature = Signature()
def randomString(stringLength=10):
"""Generate a random string of fixed length """
letters = string.ascii_uppercase
return ''.join(random.choice(letters) for i in range(stringLength))
def encrypt(data):
key = get_random_bytes(32)
cipher = AES.new(key, AES.MODE_OFB)
ct_bytes = cipher.encrypt(data)
iv = b64encode(cipher.iv).decode('utf-8')
ct = b64encode(ct_bytes).decode('utf-8')
k = b64encode(key).decode('utf-8')
result = json.dumps({'iv': iv, 'ciphertext': ct, 'key': k})
print(result)
return result
def verify(self):
digest = self.loadKey(self.cipherTextPath)[3]
sign = Signature('RESULT.jpg')
print(sign.verifySignature(digest))
from SignatureFilters import MethodsFilter, ArgumentsFilter, ArgumentsNotSetFilter
from Signature import Signature
# Global list of signatures for iOS apps
IOS_SIGNATURES = []
# Signature titles have to be unique or HTML reports will break
# TODO: Fix it
# XML signature
IOS_SIGNATURES.append(
Signature(
title='Vulnerable XML Parser',
description='An XML parser is configured to resolve external entities.',
severity=Signature.SEVERITY_HIGH,
filter=ArgumentsFilter(
classes_to_match=['NSXMLParser'],
methods_to_match=['setShouldResolveExternalEntities:'],
args_to_match=[(['arguments',
'shouldResolveExternalEntities'], 'True')])))
# Security Framework signatures
IOS_SIGNATURES.append(
Signature(
title='Client Certificate Import',
description=
'The application imported a private key and a certificate from a PKCS12 file.',
severity=Signature.SEVERITY_INF,
filter=MethodsFilter(classes_to_match=['C'],
methods_to_match=['SecPKCS12Import'])))
def run_selected():
new_window = Toplevel(root)
new_window.geometry("400x270")
calc_side_geometry(new_window)
noError = True
if button_value.get() == 1:
algorithm = cat1
mode = cat1_2
rsa = cat1_3
elif button_value.get() == 2:
sha = cat2
rsa = cat2_2
else:
algorithm = cat3
mode = cat3_2
rsa = cat3_3
sha = cat3_4
# check if everything is selected
if button_value.get() == 1:
task = 'Digitalna omotnica'
if algorithm.get() == 'Select' or mode.get() == 'Select' or rsa.get(
) == 'Select':
messagebox.showerror('Error', "Niste odabrali sve vrijednosti!")
new_window.destroy()
noError = False
elif button_value.get() == 2:
task = 'Digitalni potpis'
if sha.get() == 'Select' or rsa.get() == 'Select':
messagebox.showerror('Error', "Niste odabrali sve vrijednosti!")
new_window.destroy()
noError = False
elif button_value.get() == 3:
task = 'Digitalni pečat'
if algorithm.get() == 'Select' or mode.get() == 'Select' or rsa.get(
) == 'Select' or sha.get() == 'Select':
messagebox.showerror('Error', "Niste odabrali sve vrijednosti!")
new_window.destroy()
noError = False
if text.get() == "" and noError:
messagebox.showerror('Error', "Niste unijeli tekst!")
new_window.destroy()
noError = False
if noError:
Label(new_window, text=task.upper(),
font=font_style_2).pack(pady=(2, 5))
Label(new_window, text="Tekst koji ste unijeli:",
font=font_style).pack(pady=(40, 5))
Label(new_window, text=text.get()).pack()
if button_value.get() == 1:
Label(new_window,
text="Tekst koji je dobiven dekriptiranjem:",
font=font_style).pack(pady=(40, 5))
envelope = Envelope(algorithm.get().split()[0],
algorithm.get().split()[1],
int(rsa.get().split()[1]), text.get(),
mode.get())
sym_obj = envelope.encrypt()
decrypted = envelope.decrypt(sym_obj)
Label(new_window, text=decrypted).pack()
elif button_value.get() == 2:
Label(new_window,
text="Ishod digitalnog potpisivanja:",
font=font_style).pack(pady=(40, 5))
signature = Signature(sha.get()[3:], int(rsa.get().split()[1]),
text.get())
signature.sign()
verification = signature.verify()
Label(new_window, text=verification).pack()
else:
seal = Seal(algorithm.get().split()[0],
algorithm.get().split()[1], int(rsa.get().split()[1]),
text.get(), mode.get(),
sha.get()[3:])
seal.seal()
decrypted, verification = seal.unseal()
Label(new_window,
text="Tekst koji je dobiven dekriptiranjem:",
font=font_style).pack(pady=(20, 5))
Label(new_window, text=decrypted).pack()
Label(new_window,
text="Ishod digitalnog potpisivanja:",
font=font_style).pack(pady=(20, 5))
Label(new_window, text=verification).pack()
def test_sign_verify(self):
T = b"\x01\x02\x03\x04"
sig = Signature()
_, D = sig.sign(T)
assert sig.verify(T, D)
def verify_signature(self, interest, public_key):
signature = self.get_value()
claim = Signature.verify_signature(interest, signature, public_key)
return claim
def Train_Database_Sign(self,
database,
version,
num_of_kpts,
force_update = False,
K = 10,#tree branch
depth = 4, #depth
nleaves = 10000 #leaves in the tree
):
#load information from database
num_in_set = database[0]
num_of_sets = database[1]
data_dir = database[2]
total = num_in_set * num_of_sets
updated = force_update # will be turned true if one of the steps has been processed, so that the following step will be focused to processs!
'''
generate desc~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ dir should be saved
'''
desc_dir = os.path.join(self.DESC_DIR, 'db_version_'+str(version), str(num_of_kpts))
if updated or (not os.path.isdir(desc_dir) or os.listdir(desc_dir) == []):
updated = True
if not os.path.isdir(os.path.join(self.DESC_DIR, 'db_version_'+str(version))):
os.mkdir(os.path.join(self.DESC_DIR, 'db_version_'+str(version)))
if not os.path.isdir(desc_dir):
os.mkdir(desc_dir)
for d in data_dir:
img_idx = d[0]
class_idx = d[1]
img_dir = d[2]
'''
k is the index of desc included in the name, should be ordered by the class
'''
k = img_idx + class_idx * num_in_set
#load image(load image, convert to np array with float type)
img = Image.open(img_dir).convert('L')
img_s = self.StandalizeImage(img, 480)
img_data = np.asarray(img_s, dtype=float)
kp = Keypoint()
kp.generate_keypoint(num_of_kpts, img.size[0], img.size[1], self.SIGMA) #sigma is set to 1 currently
#kp.save_keypoint(self.KEYPOINT_DIR, self.KEYPOINT_FILE+str(num_of_kpts)) #save to a directory
print 'Random keypoint generated'
#generate desc
desc = Descriptor()
desc.generate_desc(img_data, kp.kpt)
desc.save_desc(desc_dir, self.DESC_FILE + str(k))
print desc.desc
#load to a large matrix
#desc_database[:, k*num_of_kpts:k+num_of_kpts] = desc.desc #add to the database therefore later can be used to train the tree
print '=>'+str(k) ,
print 'Descriptor Generated'
#load desc
desc_database = np.empty(shape=(128, total*num_of_kpts), dtype=np.uint8)
for k in range(0, total):
desc = Descriptor()
desc.load_desc(desc_dir, self.DESC_FILE + str(k))
desc_database[:, k*num_of_kpts:(k+1)*num_of_kpts] = desc.desc
print 'Descriptor Loaded'
'''
Build the tree~~~~~~~~~~~~~~~~~~~~~~~~~
'''
tree_dir = os.path.join(self.TREE_DIR, 'db_version_' + str(version))
if updated or (not os.path.isfile(os.path.join(tree_dir, str(num_of_kpts) + self.TREE_FILE))):
updated = True
if not os.path.isdir(tree_dir):
os.mkdir(tree_dir)
tree = Tree()
tree.generate_tree(desc_database, K, nleaves, tree_dir, str(num_of_kpts) + self.TREE_FILE)
print 'Tree built'
'''
Generate signature~~~~~~~~~~~~~~~~~~~~~~~~~
'''
sign_dir = os.path.join(self.SIGN_DIR, 'db_version_' + str(version))
if updated or (not os.path.isfile(os.path.join(sign_dir, self.SIGN_FILE+str(num_of_kpts)))):
updated = True
tr = vl._vlfeat.VlHIKMTree(0, 0)
tr.load(os.path.join(tree_dir, str(num_of_kpts) + self.TREE_FILE))
print 'Tree Loaded'
sign = Signature()
sign.generate_sign_database_dir(tr, desc_database, K, depth, total, num_of_kpts)
if not os.path.isdir(sign_dir):
os.mkdir(sign_dir)
sign.save_sign(sign_dir, self.SIGN_FILE+str(num_of_kpts))
print 'Signature Generated'
else:
print 'Signature Already Generated'
del desc_database
return updated;
def test_validate_signature(self):
s = Signature(TestSignature.secret)
self.assertTrue(s.validate(self._emulate_get_request()))
