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()))