FM / cloudinit

/snap/core18/2999/usr/lib/python3/dist-packages/cloudinit/

/snap/core18/2999/usr/lib/python3/dist-packages/cloudinit

Name	Size	Mode	Actions
analyze/	-	0755	rm
cmd/	-	0755	rm
config/	-	0755	rm
distros/	-	0755	rm
filters/	-	0755	rm
handlers/	-	0755	rm
mergers/	-	0755	rm
net/	-	0755	rm
reporting/	-	0755	rm
sources/	-	0755	rm
__pycache__/	-	0755	rm
apport.py	5881	0644	edit dl rm
atomic_helper.py	1417	0644	edit dl rm
cloud.py	3574	0644	edit dl rm
dhclient_hook.py	2549	0644	edit dl rm
dmi.py	6979	0644	edit dl rm
event.py	2097	0644	edit dl rm
features.py	3146	0644	edit dl rm
gpg.py	4424	0644	edit dl rm
helpers.py	16828	0644	edit dl rm
importer.py	1789	0644	edit dl rm
log.py	4432	0644	edit dl rm
netinfo.py	23115	0644	edit dl rm
patcher.py	1130	0644	edit dl rm
persistence.py	2605	0644	edit dl rm
registry.py	1045	0644	edit dl rm
safeyaml.py	7905	0644	edit dl rm
settings.py	2041	0644	edit dl rm
signal_handler.py	1826	0644	edit dl rm
simpletable.py	1976	0644	edit dl rm
ssh_util.py	21211	0644	edit dl rm
stages.py	35311	0644	edit dl rm
subp.py	13558	0644	edit dl rm
templater.py	5965	0644	edit dl rm
temp_utils.py	3268	0644	edit dl rm
type_utils.py	726	0644	edit dl rm
url_helper.py	28628	0644	edit dl rm
user_data.py	14841	0644	edit dl rm
util.py	92622	0644	edit dl rm
version.py	596	0644	edit dl rm
warnings.py	3932	0644	edit dl rm
__init__.py	0	0644	edit dl rm

Edit: /snap/core18/2999/usr/lib/python3/dist-packages/cloudinit/gpg.py (4424B)

# Copyright (C) 2016 Canonical Ltd.
#
# Author: Scott Moser <scott.moser@canonical.com>
# Author: Christian Ehrhardt <christian.ehrhardt@canonical.com>
#
# This file is part of cloud-init. See LICENSE file for license information.

"""gpg.py - Collection of gpg key related functions"""

import time

from cloudinit import log as logging
from cloudinit import subp

LOG = logging.getLogger(__name__)

GPG_LIST = [
    "gpg",
    "--with-fingerprint",
    "--no-default-keyring",
    "--list-keys",
    "--keyring",
]

def export_armour(key):
    """Export gpg key, armoured key gets returned"""
    try:
        (armour, _) = subp.subp(
            ["gpg", "--export", "--armour", key], capture=True
        )
    except subp.ProcessExecutionError as error:
        # debug, since it happens for any key not on the system initially
        LOG.debug('Failed to export armoured key "%s": %s', key, error)
        armour = None
    return armour

def dearmor(key):
    """Dearmor gpg key, dearmored key gets returned

note: man gpg(1) makes no mention of an --armour spelling, only --armor
    """
    return subp.subp(["gpg", "--dearmor"], data=key, decode=False).stdout

def list(key_file, human_output=False):
    """List keys from a keyring with fingerprints. Default to a stable machine
    parseable format.

@param key_file: a string containing a filepath to a key
    @param human_output: return output intended for human parsing
    """
    cmd = []
    cmd.extend(GPG_LIST)
    if not human_output:
        cmd.append("--with-colons")

cmd.append(key_file)
    (stdout, stderr) = subp.subp(cmd, capture=True)
    if stderr:
        LOG.warning('Failed to export armoured key "%s": %s', key_file, stderr)
    return stdout

def recv_key(key, keyserver, retries=(1, 1)):
    """Receive gpg key from the specified keyserver.

Retries are done by default because keyservers can be unreliable.
    Additionally, there is no way to determine the difference between
    a non-existant key and a failure.  In both cases gpg (at least 2.2.4)
    exits with status 2 and stderr: "keyserver receive failed: No data"
    It is assumed that a key provided to cloud-init exists on the keyserver
    so re-trying makes better sense than failing.

@param key: a string key fingerprint (as passed to gpg --recv-keys).
    @param keyserver: the keyserver to request keys from.
    @param retries: an iterable of sleep lengths for retries.
                    Use None to indicate no retries."""
    LOG.debug("Importing key '%s' from keyserver '%s'", key, keyserver)
    cmd = ["gpg", "--no-tty", "--keyserver=%s" % keyserver, "--recv-keys", key]
    if retries is None:
        retries = []
    trynum = 0
    error = None
    sleeps = iter(retries)
    while True:
        trynum += 1
        try:
            subp.subp(cmd, capture=True)
            LOG.debug(
                "Imported key '%s' from keyserver '%s' on try %d",
                key,
                keyserver,
                trynum,
            )
            return
        except subp.ProcessExecutionError as e:
            error = e
        try:
            naplen = next(sleeps)
            LOG.debug(
                "Import failed with exit code %d, will try again in %ss",
                error.exit_code,
                naplen,
            )
            time.sleep(naplen)
        except StopIteration as e:
            raise ValueError(
                "Failed to import key '%s' from keyserver '%s' "
                "after %d tries: %s" % (key, keyserver, trynum, error)
            ) from e

def delete_key(key):
    """Delete the specified key from the local gpg ring"""
    try:
        subp.subp(
            ["gpg", "--batch", "--yes", "--delete-keys", key], capture=True
        )
    except subp.ProcessExecutionError as error:
        LOG.warning('Failed delete key "%s": %s', key, error)

def getkeybyid(keyid, keyserver="keyserver.ubuntu.com"):
    """get gpg keyid from keyserver"""
    armour = export_armour(keyid)
    if not armour:
        try:
            recv_key(keyid, keyserver=keyserver)
            armour = export_armour(keyid)
        except ValueError:
            LOG.exception("Failed to obtain gpg key %s", keyid)
            raise
        finally:
            # delete just imported key to leave environment as it was before
            delete_key(keyid)

return armour

# vi: ts=4 expandtab

cmd: