def _read_file(self, filename: str, password: str = '') -> dict: """ Reads the data from filename and returns the account dictionary, the encrypted master key, and the decrypted master key. """ # Read from the file if it exists. with pathlib_path(filename) as pass_file: lzma_data = pass_file.read_bytes() if pass_file.is_file() else b'' # Get the json data out of the file data or an empty json dict of # the file was empty. if lzma_data: json_data = lzma_decompress(lzma_data).decode() else: json_data = '{}' accounts_dict = json_loads(json_data) # Pop the master key out of the accounts dictionary so it won't be # operated on or listed. Also if no master key is found, create # one. encrypted_key = bytes.fromhex(accounts_dict.pop(self.MASTER_KEY_DIGEST, '')) if not encrypted_key: if not password: # Get the password to encrypt the master key. password = self._ask_pass('password') else: # Get the password to decrypt the key. password = self._ask_pass('password', verify=False) return CryptData(password, encrypted_key), accounts_dict
def decompress(self, source, cursor, compressedbytes, uncompressedbytes=None): if self.algo == uproot.const.kZLIB: from zlib import decompress as zlib_decompress return zlib_decompress(cursor.bytes(source, compressedbytes)) elif self.algo == uproot.const.kLZMA: try: from lzma import decompress as lzma_decompress except ImportError: try: from backports.lzma import decompress as lzma_decompress except ImportError: raise ImportError("Install lzma package with:\n pip install backports.lzma\nor\n conda install -c conda-forge backports.lzma\n(or just use Python >= 3.3).") return lzma_decompress(cursor.bytes(source, compressedbytes)) elif self.algo == uproot.const.kOldCompressionAlgo: raise NotImplementedError("ROOT's \"old\" algorithm (fCompress 300) is not supported") elif self.algo == uproot.const.kLZ4: try: from lz4.block import decompress as lz4_decompress except ImportError: raise ImportError("Install lz4 package with:\n pip install lz4\nor\n conda install -c anaconda lz4") if uncompressedbytes is None: raise ValueError("lz4 needs to know the uncompressed number of bytes") return lz4_decompress(cursor.bytes(source, compressedbytes), uncompressed_size=uncompressedbytes) else: raise ValueError("unrecognized compression algorithm: {0}".format(self.algo))
def __init__(self, bsp): from .bsp_file import BSPFile self._bsp: BSPFile = bsp self._lump: LumpInfo = bsp.lumps_info[self.lump_id] self._bsp.reader.seek(self._lump.offset) if self._lump.compressed: reader = self._bsp.reader lzma_id = reader.read_fourcc() assert lzma_id == "LZMA", f"Unknown compressed header({lzma_id})" decompressed_size = reader.read_uint32() compressed_size = reader.read_uint32() prob_byte = reader.read_int8() dict_size = reader.read_uint32() pb = prob_byte // (9 * 5) prob_byte -= pb * 9 * 5 lp = prob_byte // 9 lc = prob_byte - lp * 9 my_filters = [ {"id": lzma.FILTER_LZMA2, "dict_size": dict_size,"pb": pb, "lp": lp, "lc": lc}, ] self.reader = ByteIO( byte_object=lzma_decompress(reader.read_bytes(compressed_size), lzma.FORMAT_RAW, filters=my_filters)) else: self.reader = ByteIO(byte_object=self._bsp.reader.read_bytes(self._lump.size))
def read_file(filename: str, password: str = "") -> tuple: """ Reads the data from filename and returns the account dictionary, the encrypted master key, and the decrypted master key. """ # Read from the file if it exists. with pathlib_path(filename) as pass_file: lzma_data = pass_file.read_bytes() if pass_file.is_file() else b"" # Get the json data out of the file data or an empty json dict of # the file was empty. if lzma_data: json_data = lzma_decompress(lzma_data).decode() else: json_data = "{}" accounts_dict = json_loads(json_data) # Pop the master key out of the accounts dictionary so it won't be # operated on or listed. Also if no master key is found, create # one. encrypted_key = bytes.fromhex(accounts_dict.pop(MASTER_KEY_DIGEST, "")) encrypted_key, master_key = get_master_key(encrypted_key, password) return accounts_dict, encrypted_key, master_key
def read_file(filename: str) -> dict: """ Reads the data from filename and returns the account dictionary. """ # Read from the file if it exists. with pathlib_path(filename) as pass_file: lzma_data = pass_file.read_bytes() if pass_file.is_file() else b'' # Get the json data out of the file data or an empty json dict of # the file was empty. if lzma_data: json_data = lzma_decompress(lzma_data).decode() else: json_data = '{}' # Load the json data into a dictionary. return json_loads(json_data)
def _decompressfcn(compression, objlen, debug=False): algo, level = compression if algo == "zlib": # skip 9-byte header for ROOT's custom frame: # https://github.com/root-project/root/blob/master/core/zip/src/Bits.h#L646 if debug: def out(x): print("decompressing {0} bytes".format(len(x) - 9)) return zlib_decompress(x[9:]) return out else: return lambda x: zlib_decompress(x[9:]) elif algo == "lzma": # skip 9-byte header for LZMA, too: # https://github.com/root-project/root/blob/master/core/lzma/src/ZipLZMA.c#L81 if debug: def out(x): print("decompressing {0} bytes".format(len(x) - 9)) return lzma_decompress(x[9:]) return out else: return lambda x: lzma_decompress(x[9:]) elif algo == "lz4": # skip 9-byte header plus 8-byte hash: are there any official ROOT versions without the hash? # https://github.com/root-project/root/blob/master/core/lz4/src/ZipLZ4.cxx#L38 if debug: def out(x): print("decompressing {0} bytes".format(len(x) - 9 - 8)) return lz4_decompress(x[9 + 8:], uncompressed_size=objlen) return out else: return lambda x: lz4_decompress(x[9 + 8:], uncompressed_size=objlen) else: raise NotImplementedError("cannot decompress \"{0}\"".format(algo))
def get_frames(self): replay_frames = lzma_decompress(self.data).decode('utf-8').split(",") offset = int(replay_frames[1].split("|")[0]) + int( replay_frames[0].split("|")[0]) replay_frames = [frame.split("|") for frame in replay_frames[2:-2]] time = offset absolute_frames = [] times = [] for frame in replay_frames: time += int(frame[0]) if frame[0] == '0': absolute_frames.pop() times.pop() absolute_frames.append( [time, float(frame[1]), float(frame[2]), int(frame[3])]) times.append(time) return absolute_frames, times
def read_file(filename: str, password: str = '') -> tuple: """ Reads the data from filename and returns the account dictionary, the encrypted master key, and the decrypted master key. """ # Read from the file if it exists. with pathlib_path(filename) as pass_file: lzma_data = pass_file.read_bytes() if pass_file.is_file() else b'' # Get the json data out of the file data or an empty json dict of # the file was empty. if lzma_data: json_data = lzma_decompress(lzma_data).decode() else: json_data = '{}' accounts_dict = json_loads(json_data) # Pop the master key out of the accounts dictionary so it won't be # operated on or listed. Also if no master key is found, create # one. encrypted_key = bytes.fromhex(accounts_dict.pop(MASTER_KEY_DIGEST, '')) if not encrypted_key: if not password: # Get the password to encrypt the master key. password = get_pass('password') # Generate the largest key possible. master_key = Random.new().read(KEY_LEN) # Encrypt the key. encrypted_key = encrypt_key(master_key, password) else: # Get the password to decrypt the key. password = get_pass('password', verify=False) master_key = decrypt_key(encrypted_key, password) return accounts_dict, encrypted_key, master_key
def main(args: dict) -> int: """ Read the password file, decrypt it and print the requested info. """ filename = args.pop('filename') account = args.pop('account') remove_account = args.pop('remove_account') password = args.pop('password') if account: # Get the sha256 hash of the account name. hashed_account = bytes_to_str(SHA256.new(account.encode()).digest()) # Create the information dictionary from the info list supplied # by the user. info_dict = list_to_dict(args.pop('info_list'), args['info_seperator']) if info_dict: # Put the non hashed account name in the info dict so it is # not lost. info_dict['Account Name'] = account # Get the secret information. for key, value in info_dict.items(): if value == '{secret}': secret = get_pass(key) info_dict[key] = secret else: # No account name was given. hashed_account = '' # Create the file if it doesn't exist. if not os_isfile(filename): open_mode = 'w+b' else: open_mode = 'rb' with open(filename, open_mode) as pass_file: # Read all the data from the file. lzma_data = pass_file.read() # Get the json data out of the file data or an empty json dict of # the file was empty. if lzma_data: json_data = lzma_decompress(lzma_data).decode() else: json_data = '{}' # Load the json data into a dictionary. accounts_dict = json_loads(json_data) aes_key_digest = bytes_to_str(SHA512.new(b'\x00aes_key\x00').digest()) aes_key_enc = str_to_bytes(accounts_dict.pop(aes_key_digest, '')) aes_key_enc, aes_key = get_aes_key(aes_key_enc) if not hashed_account: if args.get('list_account_info', False): # List all accounts if none where given, but list was requested. account_str = '' for account_data in accounts_dict.values(): # account_dict = crypt_to_dict(account_data, password) account_dict = crypt_to_dict_key(account_data, aes_key) if account_dict: account_str += '\n' + dict_to_str(account_dict) import pydoc pydoc.pager(account_str) elif args.get('re-encrypt', False): # Try to re-encrypt every account. encrypt_pass = get_pass('encryption password') tmp_accounts_dict = accounts_dict.copy() for account_hash, account_data in accounts_dict.items(): account_dict = crypt_to_dict(account_data, password=password, skip_invalid=True) # account_dict = crypt_to_dict_key(account_data, aes_key) if account_dict: # new_account_data = dict_to_crypt(account_dict, encrypt_pass) new_account_data = dict_to_crypt_key(account_dict, aes_key) else: print("Invalid password. Account will use the old password") tmp_accounts_dict[account_hash] = new_account_data tmp_accounts_dict[aes_key_digest] = bytes_to_str(aes_key_enc) write_file(filename, tmp_accounts_dict) return 0 elif args.get('search', ''): search_str = args['search'].lower() # String to store all matching account information. account_str = '' for account_data in accounts_dict.values(): # Search through every account that can be decrypted with # the password, or ask for a password for each account. # account_dict = crypt_to_dict(account_data, password=password, # skip_invalid=True) account_dict = crypt_to_dict_key(account_data, aes_key) # If the password could decrypt the account, info search # throuth every key and value in the account. if account_dict: for key, value in account_dict.items(): if search_str in key.lower() or search_str in value.lower(): account_str += '\n' + dict_to_str(account_dict) # Don't add the same account more than once. break import pydoc pydoc.pager(account_str) else: # Pop the requested account out of the dictionary, so it can be # modified, removed, or just printed to stdout. account_data = accounts_dict.pop(hashed_account, '') # Don't do anything with the account_data if it is to be # removed. if remove_account: accounts_dict[aes_key_digest] = bytes_to_str(aes_key_enc) write_file(filename, accounts_dict) return 0 # If there was account data, then put the decrypted dictionary in # account_dict. Otherwise put an empty dictionary. if account_data: # account_dict = crypt_to_dict(account_data, skip_invalid=False) account_dict = crypt_to_dict_key(account_data, aes_key) else: account_dict = {} # Update the account info if new data was supplied. if info_dict: account_dict.update(info_dict) # Remove items from account_dict for which info_dict has an # empty value. (i.e. to remove items from an accounts info # the user needs to supply and empty value after the # sperator. for key, value in info_dict.items(): if not value.strip(): account_dict.pop(key) # Encrypt the account_dict. # account_data = dict_to_crypt(account_dict) account_data = dict_to_crypt_key(account_dict, aes_key) # Print the account info. if args.get('list_account_info', False) and account_dict: import pydoc pydoc.pager(dict_to_str(account_dict)) # Put the accounts data back into the dictionary. accounts_dict[hashed_account] = account_data accounts_dict[aes_key_digest] = bytes_to_str(aes_key_enc) # Write accounts_dict to the password file. write_file(filename, accounts_dict) return 0
file_corrupted = True # lzma elif algo_bytes == "XZ": uncompressed_bytes = fd_root.read(num_compressed_bytes) try: from lzma import decompress as lzma_decompress except ImportError: try: from backports.lzma import decompress as lzma_decompress except ImportError: raise ImportError( "Install lzma package with:\n pip install backports.lzma\nor\n conda install -c conda-forge backports.lzma\n(or just use Python >= 3.3)." ) try: lzma_decompress(uncompressed_bytes) except Exception, e: print("Corrupted basket") print(seek) print(num_uncompressed_bytes) print(e) file_corrupted = True # lz4 elif algo_bytes == "L4": print("Unsupported algorithm: " + algo_bytes + " , skipping...") try: import xxhash except ImportError: raise ImportError( "Install xxhash package with:\n pip install xxhash\nor\n conda install -c conda-forge python-xxhash" )
def dump_frames(self, file): readable_data = lzma_decompress(self.data).decode('utf-8') readable_data = readable_data.replace(",", "\n") with open(file, "w") as f: f.write(readable_data)
def out(x): print("decompressing {0} bytes".format(len(x) - 9)) return lzma_decompress(x[9:])