punkr 1.0.0

Bunkr operations wrapper

Punkr

Punkr (Python Bunkr) is a python wrapper around the RPC server running within the Bunkr daemon. It requires the daemon to be running to send the Bunkr operations.

Install

Install punkr with pip: $ pip install punkr

Compatible with python 3.6+

Punkr class

Punkr class is the main structure to use. It can work either synchronously or asynchronously. All methods have their async replica, they can be identified by the async_* prefix in the method names.

• new-text-secret -> create a new secret whose content is a simple text
• new-ssh-key -> create a new secret whose content is an ECDSA ssh key
• new-file-secret -> dump a file content as a new secret
• new-group -> create a new group
• import-ssh-key -> import an ssh key from a file into a secret
• list-secrets -> list all stored secrets
• list-devices -> list all shared devices
• list-groups -> list all tracked groups
• send-device -> share the current Bunkr device
• receive-device -> import a shared Bunkr device
• remove-device -> remove a shared device reference from Bunkr
• remove-local -> untrack a secret, it does not delete the secret from the plattform
• rename -> rename a secret, device or group
• create -> create a new empty secret
• write -> write a secret with new content
• access -> retrieve the content of a secret
• grant -> grant capabilities to a group or device for an specified secret or group
• revoke -> revoke a given capability
• delete -> erase a secret existence
• receive-capability -> import a capability for a given secret
• reset-triples -> synchronize triples for a secret
• noop-test -> health check operation over a secret
• secret-info -> get secret public information
• sign-ecdsa -> make an ECDSA signature with a ECDSA Bunkr secret
• ssh-public-data -> retrieve a secret public data
• signin -> signin into the platfform
• confirm-signin -> confirm the signin process

Examples

if __name__ == "__main__":
    import asyncio
    # create a connection to the local Bunkr RPC server
    punkr = Punkr("/tmp/bunkr_daemon.sock")
    to_delete = []
    try:
        # create a new text secret (synchronously)
        print(punkr.new_text_secret("MySuperSecret", 'secret created from punkr'))
        to_delete.append("MySuperSecret")
        commands = (
            (Command.ACCESS, ["MySuperSecret"]), # This is the structure of a batch command argument
            (Command.ACCESS, ["MySuperSecret"]),
            (Command.ACCESS, ["MySuperSecret"]),
        )
        # create corutine to access the secret (asynchronously, order of results is not guaranteed)
        async def async_test():
            async for result in punkr.async_batch_commands(*commands):
                print(result)
        # run corutine
        asyncio.run(async_test())
        # run corutine and get the results (order of result is guaranteed, but not ordered of execution)
        results1 = asyncio.run(punkr.async_ordered_batch_commands(*commands))
        print(results1)
        # execute a synchronous batch, ordered of execution and results ir guaranteed
        results2 = list(punkr.batch_commands(*commands))
        print(results2)
        assert results1 == results2

        # create group
        punkr.new_group("the_group")
        to_delete.append("the_group")
        # create ssh key
        punkr.new_ssh_key("test_key")
        to_delete.append("test_key")
        # listing
        res = punkr.list_secrets()
        assert len(res["content"]["secrets"]) > 0
        res = punkr.list_devices()
        assert len(res["devices"]) > 0
        res = punkr.list_groups()
        assert len(res["groups"]) > 0

        # rename
        punkr.rename("the_group", "useless_group")
        punkr.rename("useless_group", "the_group")

        # create, write, access cycle
        content = "some useless content"
        punkr.create("useless_secret", SecretType.GenericGF256)
        punkr.write("useless_secret", content, "text")
        to_delete.append("useless_secret")

        res = punkr.access("useless_secret")
        assert res["content"] ==  content
        assert res["mode"] == "text"

        # granting
        punkr.grant("the_group", "useless_secret")
        # revoke
        punkr.revoke("the_group", "useless_secret")

        # reset triples
        punkr.reset_triples("useless_secret")
        # noop
        punkr.noop("useless_secret")
        # secret info
        res = punkr.secret_info("useless_secret")
        print(res["msg"])

        # ecdsa signature
        res = punkr.sign_ecdsa("test_key", "Zm9v")
        print(res["r"])
        print(res["s"])

        # ssh public data
        res = punkr.ssh_public_data("test_key")
        print(res["public_data"]["public_key"])

        # send device
        res = punkr.send_device("my_device")
        print(res["url_short"])
        print(res["url_raw"])

    except PunkrException as e:
        print("Error while performing a Bunkr operation:")
        print(e)
    except Exception as e:
        print(e)
    finally:
        # delete the secret (synchronously)

        for s in to_delete:
            try:
                punkr.delete(s)
            except PunkrException as e:
                print(f"Error deleting secret {s}: {e}")

Copyright (c) [2019] [Off-the-grid-inc]