def close(self):
"""Close all the opened files."""
for file in self.files:
file.close()
# Format recognition methods
def is_format(self):
"""Return True if the prefix has same format than the pm."""
try:
for file in self.files:
ini = configparser.ConfigParser()
ini.read_file(file)
except: # noqa
return False
return True
def checkheader(self, header, only=False):
"""No header check is needed."""
return True
@classmethod
def header(cls):
"""No header for NetworkManager."""
return ''
register_managers(NetworkManager)
register_detecters(NetworkManager)
def open(self):
"""Ensure prefix is a path to a password repository."""
if not os.path.isdir(self.prefix):
raise PMError("%s is not a password repository." % self.prefix)
def close(self):
"""There is no file to close."""
# Format recognition methods
def is_format(self):
"""Ensure the prefix is a directory than contain a .gpg-id file."""
if os.path.isdir(self.prefix):
path = os.path.join(self.prefix, '.gpg-id')
if os.path.isfile(path):
return True
return False
def checkheader(self, header, only=False):
"""No header check is needed."""
return True
@classmethod
def header(cls):
"""No header for pass."""
return ''
register_managers(PasswordStore)
register_detecters(PasswordStore)
self.keepass.save()
# Format recognition methods
def detecter_open(self):
"""Enter the tryformat context manager."""
self.file = open(self.prefix, 'rb')
def detecter_close(self):
"""Leave the tryformat context manager."""
self.file.close()
def is_format(self):
"""Return True if the file is a KDBX file."""
sign = self.file.read(4)
if sign != self.magic:
return False
return True
def checkheader(self, header, only=False):
"""No header check."""
return True
@classmethod
def header(cls):
"""No header for KDBX file."""
return ''
register_detecters(KDBX)
def parse(self):
"""Parse HTML based file."""
raise NotImplementedError()
# Format recognition methods
def is_format(self):
"""Return True if the file is an HTML file."""
try:
self.tree = ElementTree.XML(self.file.read())
if self.tree.tag != 'html':
return False
except (ParseError, ExpatError):
return False
return True
def checkheader(self, header, only=False):
"""Ensure the file header is the same than the pm header."""
found = self.tree.find(header)
if found is None:
return False
return True
@classmethod
def header(cls):
"""Header for HTML file."""
return cls.html_header
register_detecters(XML, HTML)
entry[keys.get(key, key)] = value
self.data.append(entry)
# Format recognition methods
def is_format(self):
"""Return True if the file is a YAML file."""
try:
self.yamls = yaml.safe_load(self.file)
if isinstance(self.yamls, str):
return False
except (yaml.scanner.ScannerError, yaml.parser.ParserError,
UnicodeDecodeError):
return False
return True
def checkheader(self, header, only=False):
"""Ensure the file header is the same than the pm header."""
for key, value in header.items():
if self.yamls.get(key, '') != value:
return False
return True
@classmethod
def header(cls):
"""Header for YML file."""
return cls.yml_format
register_detecters(YAML)
sections = scontent.get('sections', [])
for section in sections:
for field in section.get('fields', []):
value = field.get('v', '')
if value.startswith('otpauth://'):
entry['otpauth'] = value
item.update(scontent)
for key, value in item.items():
if key not in self.ignore:
entry[keys.get(key, key)] = value
self.data.append(entry)
self._sortgroup(folders)
# Format recognition method
def is_format(self):
"""Return True if the file is a 1PIF file."""
try:
self.jsons = self.pif2json(self.file)
except (json.decoder.JSONDecodeError, UnicodeDecodeError):
return False
return True
def checkheader(self, header, only=False):
"""No header check is needed."""
return True
register_detecters(JSON, PIF)
try:
dialect = csv.Sniffer().sniff(self.file.read(4096),
delimiters=self.delimiter)
if dialect.quotechar != self.quotechar: # pragma: no cover
return False
self.file.seek(0)
self.reader = csv.DictReader(self.file, dialect=dialect)
except (csv.Error, UnicodeDecodeError):
return False
return True
def checkheader(self, header, only=False):
"""Ensure the file header is the same than the pm header."""
try:
if only and len(self.reader.fieldnames) != len(header):
return False
for csvkey in header:
if csvkey not in self.reader.fieldnames:
return False
return True
except csv.Error:
return False
@classmethod
def header(cls):
"""Header for CSV file."""
return cls.keys.values()
register_detecters(CSV)
import shutil
from subprocess import Popen, PIPE # nosec
from pass_import.core import register_detecters
from pass_import.detecter import Decrypter
from pass_import.errors import FormatError
class GPG(Decrypter):
"""Decrypter for GPG."""
format = 'gpg'
def decrypt(self):
"""Import data is GPG encrypted, let's decrypt it."""
gpgbinary = shutil.which('gpg2') or shutil.which('gpg')
cmd = [gpgbinary, '--with-colons', '--batch', '--decrypt', self.prefix]
with Popen(cmd,
shell=False,
universal_newlines=False,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE) as process:
(stdout, stderr) = process.communicate()
if process.wait(): # pragma: no cover
raise FormatError("%s %s" % (stderr, stdout))
return stdout.decode()[:-1]
register_detecters(GPG)
# Format recognition methods
def is_format(self):
"""Check keychain file format."""
try:
self.yamls = self.keychain2yaml(self.file)
if isinstance(self.yamls, str):
return False
except (yaml.scanner.ScannerError, yaml.parser.ParserError,
UnicodeDecodeError):
return False
return True
def checkheader(self, header, only=False):
"""Check keychain format."""
if isinstance(self.yamls, list):
self.yamls = self.yamls[0]
for yamlkey in header:
if yamlkey not in self.yamls:
return False
return True
@classmethod
def header(cls):
"""Get keychain format header."""
return cls.keychain_format
register_managers(AppleKeychain)
register_detecters(AppleKeychain)
