Issue with npub key signing for DM messages

main.py

@@ -0,0 +1,118 @@
+from nostr.client.client import NostrClient
+from nostr.event import Event
+from nostr.key import PublicKey
+import asyncio
+import threading
+import time
+import datetime
+
+
+def print_status(client):
+    print("")
+    for relay in client.relay_manager.relays.values():
+        connected_text = "🟢" if relay.connected else "🔴"
+        status_text = f"{connected_text} ⬆️ {relay.num_sent_events} ⬇️ {relay.num_received_events} ⚠️ {relay.error_counter} ⏱️ {relay.ping} ms - {relay.url.split('//')[1]}"
+        print(status_text)
+
+
+async def dm():
+    print("This is an example NIP-04 DM flow")
+    pk = input("Enter your privatekey to post from (enter nothing for a random one): ")
+
+    def callback(event: Event, decrypted_content):
+        """
+        Callback to trigger when a DM is received.
+        """
+        print(
+            f"\nFrom {event.public_key[:3]}..{event.public_key[-3:]}: {decrypted_content}"
+        )
+
+    client = NostrClient(private_key=pk)
+    if not pk:
+        print(f"Your private key: {client.private_key.bech32()}")
+
+    print(f"Your public key: {client.public_key.bech32()}")
+
+    t = threading.Thread(
+        target=client.get_dm, args=(client.public_key, callback), daemon=True
+    )
+    t.start()
+
+    pubkey_to_str = (
+        input("Enter other pubkey to DM to (enter nothing to DM yourself): ")
+        or client.public_key.hex()
+    )
+    if pubkey_to_str.startswith("npub"):
+        pubkey_to = PublicKey().from_npub(pubkey_to_str)
+    else:
+        pubkey_to = PublicKey(bytes.fromhex(pubkey_to_str))
+    print(f"Sending DMs to {pubkey_to.bech32()}")
+    while True:
+        print_status(client)
+        await asyncio.sleep(1)
+        msg = input("\nEnter message: ")
+        client.dm(msg, pubkey_to)
+
+
+async def post():
+    print("This posts and reads a nostr note")
+    pk = input("Enter your privatekey to post from (enter nothing for a random one): ")
+
+    def callback(event: Event):
+        """
+        Callback to trigger when post appers.
+        """
+        print(
+            f"\nFrom {event.public_key[:3]}..{event.public_key[-3:]}: {event.content}"
+        )
+
+    sender_client = NostrClient(private_key=pk)
+    # await asyncio.sleep(1)
+
+    pubkey_to_str = (
+        input(
+            "Enter other pubkey (enter nothing to read your own posts, enter * for all): "
+        )
+        or sender_client.public_key.hex()
+    )
+    if pubkey_to_str == "*":
+        pubkey_to = None
+    elif pubkey_to_str.startswith("npub"):
+        pubkey_to = PublicKey().from_npub(pubkey_to_str)
+    else:
+        pubkey_to = PublicKey(bytes.fromhex(pubkey_to_str))
+
+    print(f"Subscribing to posts by {pubkey_to.bech32() if pubkey_to else 'everyone'}")
+
+    filters = {
+        "since": int(
+            time.mktime(
+                (datetime.datetime.now() - datetime.timedelta(hours=1)).timetuple()
+            )
+        )
+    }
+
+    t = threading.Thread(
+        target=sender_client.get_post,
+        args=(
+            pubkey_to,
+            callback,
+            filters,
+        ),
+        daemon=True,
+    )
+    t.start()
+
+    while True:
+        print_status(sender_client)
+        await asyncio.sleep(1)
+        msg = input("\nEnter post: ")
+        sender_client.post(msg)
+
+
+if input("Enter '1' for DM, '2' for Posts (Default: 1): ") == "2":
+    # make a post and subscribe to posts
+    asyncio.run(post())
+else:
+    # write a DM and receive DMs
+    asyncio.run(dm())

nostr/client/cbc.py

@@ -0,0 +1,41 @@
+
+from Cryptodome import Random
+from Cryptodome.Cipher import AES
+
+plain_text = "This is the text to encrypts"
+
+# encrypted = "7mH9jq3K9xNfWqIyu9gNpUz8qBvGwsrDJ+ACExdV1DvGgY8q39dkxVKeXD7LWCDrPnoD/ZFHJMRMis8v9lwHfNgJut8EVTMuJJi8oTgJevOBXl+E+bJPwej9hY3k20rgCQistNRtGHUzdWyOv7S1tg==".encode()
+# iv = "GzDzqOVShWu3Pl2313FBpQ==".encode()
+
+key = bytes.fromhex("3aa925cb69eb613e2928f8a18279c78b1dca04541dfd064df2eda66b59880795")
+
+BLOCK_SIZE = 16
+
+class AESCipher(object):
+    """This class is compatible with crypto.createCipheriv('aes-256-cbc')
+
+    """
+    def __init__(self, key=None):
+        self.key = key
+
+    def pad(self, data):
+        length = BLOCK_SIZE - (len(data) % BLOCK_SIZE)
+        return data + (chr(length) * length).encode()
+
+    def unpad(self, data):
+        return data[: -(data[-1] if type(data[-1]) == int else ord(data[-1]))]
+
+    def encrypt(self, plain_text):
+        cipher = AES.new(self.key, AES.MODE_CBC)
+        b = plain_text.encode("UTF-8")
+        return cipher.iv, cipher.encrypt(self.pad(b))
+
+    def decrypt(self, iv, enc_text):
+        cipher = AES.new(self.key, AES.MODE_CBC, iv=iv)
+        return self.unpad(cipher.decrypt(enc_text).decode("UTF-8"))
+
+if __name__ == "__main__":
+    aes = AESCipher(key=key)
+    iv, enc_text = aes.encrypt(plain_text)
+    dec_text = aes.decrypt(iv, enc_text)
+    print(dec_text)

nostr/client/client.py

@@ -0,0 +1,167 @@
+from typing import *
+import ssl
+import time
+import json
+import os
+import base64
+
+from ..event import Event
+from ..relay_manager import RelayManager
+from ..message_type import ClientMessageType
+from ..key import PrivateKey, PublicKey
+
+from ..filter import Filter, Filters
+from ..event import Event, EventKind, EncryptedDirectMessage
+from ..relay_manager import RelayManager
+from ..message_type import ClientMessageType
+
+# from aes import AESCipher
+from . import cbc
+
+
+class NostrClient:
+    relays = [
+        # "wss://eagerporpoise9.lnbits.com/nostrclient/api/v1/relay",
+        "wss://localhost:5001/nostrclient/api/v1/relay",
+        # "wss://nostr-pub.wellorder.net",
+        # "wss://relay.damus.io",
+        # "wss://nostr.zebedee.cloud",
+        # "wss://relay.snort.social",
+        # "wss://nostr.fmt.wiz.biz",
+        # "wss://nos.lol",
+        # "wss://nostr.oxtr.dev",
+        # "wss://relay.current.fyi",
+        # "wss://relay.snort.social",
+    ]  # ["wss://nostr.oxtr.dev"]  # ["wss://relay.nostr.info"] "wss://nostr-pub.wellorder.net"  "ws://91.237.88.218:2700", "wss://nostrrr.bublina.eu.org", ""wss://nostr-relay.freeberty.net"", , "wss://nostr.oxtr.dev", "wss://relay.nostr.info", "wss://nostr-pub.wellorder.net" , "wss://relayer.fiatjaf.com", "wss://nodestr.fmt.wiz.biz/", "wss://no.str.cr"
+    relay_manager = RelayManager()
+    private_key: PrivateKey
+    public_key: PublicKey
+
+    def __init__(self, private_key: str = "", relays: List[str] = [], connect=True):
+        self.generate_keys(private_key)
+
+        if len(relays):
+            self.relays = relays
+        if connect:
+            self.connect()
+
+    def connect(self):
+        for relay in self.relays:
+            self.relay_manager.add_relay(relay)
+        self.relay_manager.open_connections(
+            {"cert_reqs": ssl.CERT_NONE}
+        )  # NOTE: This disables ssl certificate verification
+
+    def close(self):
+        self.relay_manager.close_connections()
+
+    def generate_keys(self, private_key: str = None):
+        if private_key.startswith("nsec"):
+            self.private_key = PrivateKey.from_nsec(private_key)
+        elif private_key:
+            self.private_key = PrivateKey(bytes.fromhex(private_key))
+        else:
+            self.private_key = PrivateKey()  # generate random key
+        self.public_key = self.private_key.public_key
+
+    def post(self, message: str):
+        event = Event(message, self.public_key.hex(), kind=EventKind.TEXT_NOTE)
+        self.private_key.sign_event(event)
+        event_json = event.to_message()
+        # print("Publishing message:")
+        # print(event_json)
+        self.relay_manager.publish_message(event_json)
+
+    def get_post(
+        self, sender_publickey: PublicKey = None, callback_func=None, filter_kwargs={}
+    ):
+        filter = Filter(
+            authors=[sender_publickey.hex()] if sender_publickey else None,
+            kinds=[EventKind.TEXT_NOTE],
+            **filter_kwargs,
+        )
+        filters = Filters([filter])
+        subscription_id = os.urandom(4).hex()
+        self.relay_manager.add_subscription(subscription_id, filters)
+
+        request = [ClientMessageType.REQUEST, subscription_id]
+        request.extend(filters.to_json_array())
+        message = json.dumps(request)
+        # print(message)
+        self.relay_manager.publish_message(message)
+
+        while True:
+            while self.relay_manager.message_pool.has_events():
+                event_msg = self.relay_manager.message_pool.get_event()
+                if callback_func:
+                    callback_func(event_msg.event)
+            time.sleep(0.1)
+
+    def dm(self, message: str, to_pubkey: PublicKey):
+        dm = EncryptedDirectMessage(
+            recipient_pubkey=to_pubkey.hex(), cleartext_content=message
+        )
+        self.private_key.sign_event(dm)
+        # print(dm)
+        self.relay_manager.publish_event(dm)
+
+    def get_dm(self, sender_publickey: PublicKey, callback_func=None, filter_kwargs={}):
+        filters = Filters(
+            [
+                Filter(
+                    kinds=[EventKind.ENCRYPTED_DIRECT_MESSAGE],
+                    pubkey_refs=[sender_publickey.hex()],
+                    **filter_kwargs,
+                )
+            ]
+        )
+        subscription_id = os.urandom(4).hex()
+        self.relay_manager.add_subscription(subscription_id, filters)
+
+        request = [ClientMessageType.REQUEST, subscription_id]
+        request.extend(filters.to_json_array())
+        message = json.dumps(request)
+        self.relay_manager.publish_message(message)
+        # print(message)
+        while True:
+            while self.relay_manager.message_pool.has_events():
+                event_msg = self.relay_manager.message_pool.get_event()
+                if "?iv=" in event_msg.event.content:
+                    try:
+                        shared_secret = self.private_key.compute_shared_secret(
+                            event_msg.event.public_key
+                        )
+                        aes = cbc.AESCipher(key=shared_secret)
+                        enc_text_b64, iv_b64 = event_msg.event.content.split("?iv=")
+                        iv = base64.decodebytes(iv_b64.encode("utf-8"))
+                        enc_text = base64.decodebytes(enc_text_b64.encode("utf-8"))
+                        dec_text = aes.decrypt(iv, enc_text)
+                        if callback_func:
+                            callback_func(event_msg.event, dec_text)
+                    except:
+                        pass
+                break
+            time.sleep(0.1)
+
+    def subscribe(
+        self,
+        callback_events_func=None,
+        callback_notices_func=None,
+        callback_eosenotices_func=None,
+    ):
+        while True:
+            while self.relay_manager.message_pool.has_events():
+                event_msg = self.relay_manager.message_pool.get_event()
+                print(event_msg.event.content)
+                if callback_events_func:
+                    callback_events_func(event_msg)
+            while self.relay_manager.message_pool.has_notices():
+                event_msg = self.relay_manager.message_pool.has_notices()
+                if callback_notices_func:
+                    callback_notices_func(event_msg)
+            while self.relay_manager.message_pool.has_eose_notices():
+                event_msg = self.relay_manager.message_pool.get_eose_notice()
+                if callback_eosenotices_func:
+                    callback_eosenotices_func(event_msg)
+
+            time.sleep(0.1)