Skip to content
Snippets Groups Projects
Select Git revision
  • 5086227e9e776cfde78d48798807ce9c6b65dccc
  • dev default protected
  • release/1.9.1 protected
  • pini-1.8-docker
  • pini-sync-onlypeers
  • duniter-v2s-issue-123-industrialize-releases
  • feature/build-aarch64-nodejs16
  • release/1.8 protected
  • pini-docker
  • ci_tags
  • fix/1448/1.8/txs_not_stored
  • feature/node-20
  • fix/1441/node_summary_with_storage
  • fix/1442/improve_bma_tx_history
  • feature/wotwizard-1.8
  • release/1.9 protected
  • 1.7 protected
  • feature/docker-set-latest protected
  • feature/fast-docker-build-1.8.4
  • fast-docker-build protected
  • feature/dump-distance
  • v1.8.7 protected
  • v1.8.7-rc4 protected
  • v1.8.7-rc3 protected
  • v1.8.7-rc2 protected
  • v1.8.7-rc1 protected
  • v1.8.6 protected
  • v1.7.23 protected
  • v1.8.5 protected
  • v1.8.4 protected
  • v1.8.3 protected
  • v1.8.2 protected
  • v1.8.1 protected
  • v1.8.0 protected
  • v1.8.0-rc1 protected
  • v1.8.0-beta5 protected
  • v1.8.0-beta4 protected
  • v1.8.0-beta3 protected
  • v1.8.0-beta2 protected
  • v1.8.0-beta protected
  • v1.7.21 protected
41 results

index.ts

Blame
  • save_revoke_document.py 4.91 KiB
    # Copyright  2014-2021 Vincent Texier <vit@free.fr>
    #
    # DuniterPy is free software: you can redistribute it and/or modify
    # it under the terms of the GNU General Public License as published by
    # the Free Software Foundation, either version 3 of the License, or
    # (at your option) any later version.
    #
    # DuniterPy is distributed in the hope that it will be useful,
    # but WITHOUT ANY WARRANTY; without even the implied warranty of
    # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    # GNU General Public License for more details.
    #
    # You should have received a copy of the GNU General Public License
    # along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
    import getpass
    import os
    from typing import Optional
    
    from duniterpy.api import bma
    from duniterpy.api.client import Client
    from duniterpy.documents import Revocation, BlockUID, Identity
    from duniterpy.key import SigningKey
    
    if "XDG_CONFIG_HOME" in os.environ:
        home_path = os.environ["XDG_CONFIG_HOME"]
    elif "HOME" in os.environ:
        home_path = os.environ["HOME"]
    elif "APPDATA" in os.environ:
        home_path = os.environ["APPDATA"]
    else:
        home_path = os.path.dirname(__file__)
    
    # CONFIG #######################################
    
    # You can either use a complete defined endpoint : [NAME_OF_THE_API] [DOMAIN] [IPv4] [IPv6] [PORT] [PATH]
    # or the simple definition : [NAME_OF_THE_API] [DOMAIN] [PORT] [PATH]
    # Here we use the secure BASIC_MERKLED_API (BMAS)
    BMAS_ENDPOINT = "BMAS g1-test.duniter.org 443"
    
    # WARNING : Hide this file in a safe and secure place
    # If one day you forget your credentials,
    # you'll have to use your private key instead
    REVOCATION_DOCUMENT_FILE_PATH = os.path.join(
        home_path, "duniter_account_revocation_document.txt"
    )
    
    # Current protocol version
    PROTOCOL_VERSION = 10
    
    
    ################################################
    
    
    def get_identity_document(
        client: Client, current_block: dict, pubkey: str
    ) -> Optional[Identity]:
        """
        Get the identity document of the pubkey
    
        :param client: Client to connect to the api
        :param current_block: Current block data
        :param pubkey: UID/Public key
    
        :rtype: Identity
        """
        # Here we request for the path wot/lookup/pubkey
        lookup_data = client(bma.wot.lookup, pubkey)
        identity = None
    
        # parse results
        for result in lookup_data["results"]:
            if result["pubkey"] == pubkey:
                uids = result["uids"]
                uid_data = uids[0]
                # capture data
                timestamp = BlockUID.from_str(uid_data["meta"]["timestamp"])
                uid = uid_data["uid"]  # type: str
                signature = uid_data["self"]  # type: str
    
                # return self-certification document
                identity = Identity(
                    version=10,
                    currency=current_block["currency"],
                    pubkey=pubkey,
                    uid=uid,
                    ts=timestamp,
                    signature=signature,
                )
                break
    
        return identity
    
    
    def get_signed_raw_revocation_document(
        identity: Identity, salt: str, password: str
    ) -> str:
        """
        Generate account revocation document for given identity
    
        :param identity: Self Certification of the identity
        :param salt: Salt
        :param password: Password
    
        :rtype: str
        """
        revocation = Revocation(PROTOCOL_VERSION, identity.currency, identity, "")
    
        key = SigningKey.from_credentials(salt, password)
        revocation.sign([key])
        return revocation.signed_raw()
    
    
    def save_revoke_document():
        """
        Main code
        """
        # Create Client from endpoint string in Duniter format
        client = Client(BMAS_ENDPOINT)
    
        # Get the node summary infos to test the connection
        response = client(bma.node.summary)
        print(response)
    
        # prompt hidden user entry
        salt = getpass.getpass("Enter your passphrase (salt): ")
    
        # prompt hidden user entry
        password = getpass.getpass("Enter your password: ")
    
        # prompt public key
        pubkey = input("Enter your public key: ")
    
        # init signer instance
        signer = SigningKey.from_credentials(salt, password)
    
        # check public key
        if signer.pubkey != pubkey:
            print("Bad credentials!")
            return
    
        # capture current block to get currency name
        current_block = client(bma.blockchain.current)
    
        # create our Identity document to sign the Certification document
        identity = get_identity_document(client, current_block, pubkey)
        if identity is None:
            print("Identity not found for pubkey {0}".format(pubkey))
            # Close client aiohttp session
            return
    
        # get the revoke document
        revocation_signed_raw_document = get_signed_raw_revocation_document(
            identity, salt, password
        )
    
        # save revoke document in a file
        with open(REVOCATION_DOCUMENT_FILE_PATH, "w") as fp:
            fp.write(revocation_signed_raw_document)
    
        # document saved
        print("Revocation document saved in %s" % REVOCATION_DOCUMENT_FILE_PATH)
    
    
    if __name__ == "__main__":
        save_revoke_document()