• https://www.completenoobs.com/noobs/Editing_Find_Hive_Users_Memo_Key_and_Send_Encrypted_Message

=Intro=

Learning about hive by tinkering

• Find The Memo Public Key from username
• Encrypt a Message so only the private key holder of that public key can decrypt

Creating Container

• Creating a Container so we know reproducable (depends installed ... etc)

• create container
  lxc launch ubuntu:24.04 keys

• Login to container
  lxc exec keys bash

• switch to user ubuntu
  su - ubuntu

Update Container and Install Dependencies

• Update package lists
  sudo apt update && sudo apt upgrade -y

• Install essential packages
  sudo apt install -y python3 python3-pip python3-venv git build-essential

• Install development libraries needed for compilation
  sudo apt install -y libssl-dev libffi-dev python3-dev

• Verify Python installation
  python3 --version

pip3 --version

==Create Virtual Environment (Recommended) ==

• Create a virtual environment
  python3 -m venv hive_beem_env

• Activate the virtual environment
  source hive_beem_env/bin/activate

• Verify you're in the virtual environment (should show the path)

(hive_beem_env) ubuntu@hive:~$ 

Install Beem

• NOTE: Beem is installed in Virtual Environment to avoid error: externally-managed-environment

• Install beem from PyPI
  pip install beem

• Verify installation
  python -c "import beem; print(beem.version)"

=Find a Hive Users Public Keys=

• Create Script
  $EDITOR find-user-keys.py

#!/usr/bin/env python3
import argparse
import logging
from beem import Hive
from beem.account import Account
from beem.exceptions import AccountDoesNotExistsException
Set up logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

logger = logging.getLogger(name)
def get_public_keys(username, nodes=None):

"""Fetch public keys for a Hive account."""

if nodes is None:

nodes = [

"https://api.hive.blog",

"https://rpc.ecency.com",

"https://api.deathwing.me",

"https://fin.hive.3speak.co"

]
try:
    # Initialize Hive instance
    hive = Hive(node=nodes)
    logger.info(f"Using node: {hive.rpc.url}")
    
    # Get account
    logger.info(f"Fetching account: {username}")
    account = Account(username, blockchain_instance=hive)
    
    # Get public keys
    keys = {
        "posting": account["posting"]["key_auths"][0][0] if account["posting"]["key_auths"] else "None",
        "active": account["active"]["key_auths"][0][0] if account["active"]["key_auths"] else "None",
        "owner": account["owner"]["key_auths"][0][0] if account["owner"]["key_auths"] else "None",
        "memo": account["memo_key"] if account["memo_key"] else "None"
    }
    
    # Print keys
    print(f"\nPublic Keys for @{username}:")
    for key_type, key_value in keys.items():
        print(f"{key_type.capitalize()}: {key_value}")
    
    # Save to file
    with open(f"{username}_public_keys.txt", "w", encoding="utf-8") as f:
        f.write(f"Public Keys for @{username}:\n")
        for key_type, key_value in keys.items():
            f.write(f"{key_type.capitalize()}: {key_value}\n")
    print(f"Saved keys to {username}_public_keys.txt")
    
    return keys

except AccountDoesNotExistsException:
    logger.error(f"Account does not exist: {username}")
    print(f"Error: The account '{username}' does not exist on the Hive blockchain.")
except Exception as e:
    logger.error(f"Error fetching keys for {username}: {str(e)}", exc_info=True)
    print(f"Error fetching keys: {str(e)}")
    print("Possible issues: node connectivity or API limits.")

def main():

# Set up argument parser

parser = argparse.ArgumentParser(description="Fetch public keys for a Hive account.")

parser.add_argument("--username", required=True, help="Hive username (e.g., completenoobs)")

args = parser.parse_args()
# Fetch keys
get_public_keys(args.username)

if name == "main":

main()

• To use script
  python3 find-user-keys.py --username completenoobs
• OutPut:

(hive_beem_env) ubuntu@keys:~$ python3 find-user-keys.py --user completenoobs
2025-06-16 02:55:48,890 - INFO - Using node: https://api.hive.blog
2025-06-16 02:55:48,890 - INFO - Fetching account: completenoobs
Public Keys for @completenoobs:

Posting: STM52HfmA7gmnAjq8eQbAPgTxijsoVwm3T439dgeVqjC4baXUyJSV

Active: STM4zGfF1K9TbMoCcE2eLtTwrBwVybEhgu5yfBv99nhR6kjf5Hv97

Owner: STM8jjM8CowxH6ttosaUXCK5NufZQMga18KRD6vq1LrmTH4u4poQW

Memo: STM5u4bQRcCFfbGgg29TabvAmYsMdM6eGK8sj7sJDWPPpz6SwAums

Saved keys to completenoobs_public_keys.txt

* Will also create a text file container user keys in same directory script run:

=Encrypting and Decrypting=

• Install Missing Depends
  pip install cryptography

• Create Script
  $EDITOR crypt.py

#!/usr/bin/env python3
"""
Offline Hive Memo Encryption/Decryption
Encrypts to public key and decrypts with private key without network access
Compatible with Hive memo format
"""
import hashlib

import hmac

import struct

import base64

import os

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes

from cryptography.hazmat.backends import default_backend

from cryptography.hazmat.primitives import hashes

from cryptography.hazmat.primitives.asymmetric import ec

from cryptography.hazmat.primitives.serialization import Encoding, PrivateFormat, PublicFormat, NoEncryption
Base58 alphabet used by Bitcoin/Hive
BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
def base58_encode(data):

"""Encode bytes to base58"""

count = 0

for byte in data:

if byte == 0:

count += 1

else:

break
encoded = ''
num = int.from_bytes(data, 'big')
while num > 0:
    num, remainder = divmod(num, 58)
    encoded = BASE58_ALPHABET[remainder] + encoded

return '1' * count + encoded

def base58_decode(s):

"""Decode base58 to bytes"""

count = 0

for char in s:

if char == '1':

count += 1

else:

break
num = 0
for char in s:
    num = num * 58 + BASE58_ALPHABET.index(char)

decoded = num.to_bytes((num.bit_length() + 7) // 8, 'big')
return b'\x00' * count + decoded

def wif_to_private_key(wif):

"""Convert WIF format to private key bytes"""

decoded = base58_decode(wif)

# Remove version byte (0x80) and checksum (last 4 bytes)

private_key_bytes = decoded[1:-4]

return private_key_bytes
def private_key_from_wif(wif):

"""Generate private key object from WIF"""

private_key_bytes = wif_to_private_key(wif)

private_key = ec.derive_private_key(

int.from_bytes(private_key_bytes, 'big'),

ec.SECP256K1(),

default_backend()

)

return private_key
def stm_to_public_key(stm_key):

"""Convert STM format public key to cryptography public key object"""

# Remove STM prefix and decode

key_data = base58_decode(stm_key[3:])

# Remove checksum (last 4 bytes)

point_data = key_data[:-4]
# Parse compressed public key (33 bytes: 0x02/0x03 + 32 bytes)
if len(point_data) == 33:
    x = int.from_bytes(point_data[1:], 'big')
    y_is_even = point_data[0] == 0x02
    
    # Calculate y coordinate
    p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
    y_squared = (pow(x, 3, p) + 7) % p
    y = pow(y_squared, (p + 1) // 4, p)
    
    if y % 2 != (0 if y_is_even else 1):
        y = p - y
    
    public_key = ec.EllipticCurvePublicKey.from_encoded_point(
        ec.SECP256K1(),
        b'\x04' + x.to_bytes(32, 'big') + y.to_bytes(32, 'big')
    )
    return public_key

raise ValueError("Invalid public key format")

def generate_shared_secret(private_key, public_key):

"""Generate shared secret using ECDH"""

if isinstance(private_key, str):

private_key = public_key_from_wif(private_key).private_key()
shared_point = private_key.exchange(ec.ECDH(), public_key)
return shared_point

def encrypt_message(message, recipient_public_key, sender_private_key):

"""Encrypt message using Hive memo format"""

# Generate shared secret

if isinstance(sender_private_key, str):

sender_private_key_obj = private_key_from_wif(sender_private_key)

else:

sender_private_key_obj = sender_private_key
if isinstance(recipient_public_key, str):
    recipient_public_key_obj = stm_to_public_key(recipient_public_key)
else:
    recipient_public_key_obj = recipient_public_key

shared_secret = generate_shared_secret(sender_private_key_obj, recipient_public_key_obj)

# Generate nonce
nonce = os.urandom(8)

# Derive encryption key
key_material = shared_secret + nonce
encryption_key = hashlib.sha512(key_material).digest()[:32]

# Encrypt message
iv = os.urandom(16)
cipher = Cipher(algorithms.AES(encryption_key), modes.CBC(iv), backend=default_backend())
encryptor = cipher.encryptor()

# Pad message to 16-byte boundary
padded_message = message.encode('utf-8')
padding_length = 16 - (len(padded_message) % 16)
padded_message += bytes([padding_length] * padding_length)

ciphertext = encryptor.update(padded_message) + encryptor.finalize()

# Get sender's public key for the memo
sender_public_key = sender_private_key_obj.public_key()
sender_public_key_bytes = sender_public_key.public_numbers().x.to_bytes(32, 'big')

# Create memo format: nonce + sender_pubkey + iv + ciphertext
memo_data = nonce + sender_public_key_bytes + iv + ciphertext

# Encode as base64 and add # prefix
encoded_memo = '#' + base64.b64encode(memo_data).decode('utf-8')

return encoded_memo

def decrypt_message(encrypted_memo, recipient_private_key):

"""Decrypt message using Hive memo format"""

# Remove # prefix and decode base64

if not encrypted_memo.startswith('#'):

raise ValueError("Invalid memo format - should start with #")
memo_data = base64.b64decode(encrypted_memo[1:])

# Parse memo components
nonce = memo_data[:8]
sender_pubkey_x = memo_data[8:40]
iv = memo_data[40:56]
ciphertext = memo_data[56:]

# Reconstruct sender's public key (assuming even y coordinate)
sender_x = int.from_bytes(sender_pubkey_x, 'big')
p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
y_squared = (pow(sender_x, 3, p) + 7) % p
y = pow(y_squared, (p + 1) // 4, p)

# Try even y coordinate first
try:
    if y % 2 != 0:
        y = p - y
    
    sender_public_key = ec.EllipticCurvePublicKey.from_encoded_point(
        ec.SECP256K1(),
        b'\x04' + sender_x.to_bytes(32, 'big') + y.to_bytes(32, 'big')
    )
except:
    # Try odd y coordinate
    y = p - y
    sender_public_key = ec.EllipticCurvePublicKey.from_encoded_point(
        ec.SECP256K1(),
        b'\x04' + sender_x.to_bytes(32, 'big') + y.to_bytes(32, 'big')
    )

# Convert sender's public key to STM format for display
sender_public_numbers = sender_public_key.public_numbers()
x = sender_public_numbers.x.to_bytes(32, 'big')
y_is_even = sender_public_numbers.y % 2 == 0
compressed_pubkey = (b'\x02' if y_is_even else b'\x03') + x
checksum = hashlib.sha256(compressed_pubkey).digest()[:4]
sender_stm_pubkey = 'STM' + base58_encode(compressed_pubkey + checksum)

# Generate shared secret
if isinstance(recipient_private_key, str):
    recipient_private_key_obj = private_key_from_wif(recipient_private_key)
else:
    recipient_private_key_obj = recipient_private_key

shared_secret = generate_shared_secret(recipient_private_key_obj, sender_public_key)

# Derive decryption key
key_material = shared_secret + nonce
decryption_key = hashlib.sha512(key_material).digest()[:32]

# Decrypt message
cipher = Cipher(algorithms.AES(decryption_key), modes.CBC(iv), backend=default_backend())
decryptor = cipher.decryptor()

padded_message = decryptor.update(ciphertext) + decryptor.finalize()

# Remove padding
padding_length = padded_message[-1]
message = padded_message[:-padding_length].decode('utf-8')

return message, sender_stm_pubkey

def generate_hive_keys():

"""Generate a new Hive-compatible key pair"""

private_key = ec.generate_private_key(ec.SECP256K1(), default_backend())

private_key_bytes = private_key.private_numbers().private_value.to_bytes(32, 'big')
# Create WIF format
extended_key = b'\x80' + private_key_bytes
checksum = hashlib.sha256(hashlib.sha256(extended_key).digest()).digest()[:4]
wif = base58_encode(extended_key + checksum)

# Create STM format public key
public_key = private_key.public_key()
public_key_point = public_key.public_numbers()

# Compress public key
x = public_key_point.x.to_bytes(32, 'big')
y_is_even = public_key_point.y % 2 == 0
compressed_pubkey = (b'\x02' if y_is_even else b'\x03') + x

# Add checksum for STM format
checksum = hashlib.sha256(compressed_pubkey).digest()[:4]
stm_pubkey = 'STM' + base58_encode(compressed_pubkey + checksum)

return wif, stm_pubkey

def main():

print("=== Offline Hive Memo Tool ===")
while True:
    print("\nOptions:")
    print("1. Generate new key pair")
    print("2. Encrypt message")
    print("3. Decrypt message")
    print("4. Exit")
    
    choice = input("\nEnter choice (1-4): ").strip()
    
    if choice == '1':
        print("\nGenerating new Hive key pair...")
        private_key, public_key = generate_hive_keys()
        print(f"Private Key (WIF): {private_key}")
        print(f"Public Key (STM): {public_key}")
        
    elif choice == '2':
        try:
            message = input("\nEnter message to encrypt: ")
            recipient_pubkey = input("Enter recipient's public key (STM...): ").strip()
            sender_privkey = input("Enter your private key (5...): ").strip()
            filename = input("Enter output filename: ").strip()
            
            encrypted = encrypt_message(message, recipient_pubkey, sender_privkey)
            
            with open(filename, 'w') as f:
                f.write(encrypted)
            
            print(f"\nMessage encrypted and saved to {filename}")
            print(f"Encrypted memo: {encrypted}")
            
        except Exception as e:
            print(f"Encryption error: {e}")
    
    elif choice == '3':
        try:
            filename = input("\nEnter encrypted file path: ").strip()
            private_key = input("Enter your private key (5...): ").strip()
            
            with open(filename, 'r') as f:
                encrypted_memo = f.read().strip()
            
            decrypted_message, sender_pubkey = decrypt_message(encrypted_memo, private_key)
            print(f"\nDecrypted message: {decrypted_message}")
            print(f"Sender's public key: {sender_pubkey}")
            print(f"\n(You can reply by encrypting a message to: {sender_pubkey})")
            
        except Exception as e:
            print(f"Decryption error: {e}")
    
    elif choice == '4':
        print("Goodbye!")
        break
    
    else:
        print("Invalid choice. Please try again.")

if name == "main":

main()

• OutPut:

=== Offline Hive Memo Tool ===
Options:

Generate new key pair
Encrypt message
Decrypt message
Exit

Enter choice (1-4):

==Example Use ==

• In this example 2 key pairs where created, to send and receive

(hive_beem_env) ubuntu@keys:~$ python3 crypt.py 
=== Offline Hive Memo Tool ===
Options:

Generate new key pair
Encrypt message
Decrypt message
Exit

Enter choice (1-4): 1
Generating new Hive key pair...

Private Key (WIF): 5KR1behsskwnusyUMGZMNVdemVFUvoJTLkj4M7UhN3jpv7G5yK8

Public Key (STM): STM6VsVfhBdhs5pcX7CoTeoyWtxin2SPPFyMPcenbRQjRJLcjwaBK
Options:

Generate new key pair
Encrypt message
Decrypt message
Exit

Enter choice (1-4): 1
Generating new Hive key pair...

Private Key (WIF): 5JZqP9VBVL5tTqHCuAjPd4WuJDv84e56fA48wc6CnKtMq6Z4cVe

Public Key (STM): STM5aV2anXQonjiBtjSiF8K8g336aDviXQq9j2441hTgVdm3qD3BU
Options:

Generate new key pair
Encrypt message
Decrypt message
Exit

Enter choice (1-4): 4

Goodbye!

(hive_beem_env) ubuntu@keys:~$ python3 crypt.py

=== Offline Hive Memo Tool ===
Options:

Generate new key pair
Encrypt message
Decrypt message
Exit

Enter choice (1-4): 2
Enter message to encrypt: test message

Enter recipient's public key (STM...): STM5aV2anXQonjiBtjSiF8K8g336aDviXQq9j2441hTgVdm3qD3BU

Enter your private key (5...): 5KR1behsskwnusyUMGZMNVdemVFUvoJTLkj4M7UhN3jpv7G5yK8

Enter output filename: test.msg
Message encrypted and saved to test.msg

Encrypted memo: #ha05gnlySH/UCOEW78Gx6FFlqYSvylks99XfTfyzp7Pq1Zx/o0YDrvCBZIM9v6wiccjyNOkcwT45rzI5MXBIyGsoHDN6lC4D
Options:

Generate new key pair
Encrypt message
Decrypt message
Exit

Enter choice (1-4): 3
Enter encrypted file path: test.msg

Enter your private key (5...): 5JZqP9VBVL5tTqHCuAjPd4WuJDv84e56fA48wc6CnKtMq6Z4cVe
Decrypted message: test message

Sender's public key: STM6VsVfhBdhs5pcX7CoTeoyWtxin2SPPFyMPcenbRQjRJLcjwaBK
(You can reply by encrypting a message to: STM6VsVfhBdhs5pcX7CoTeoyWtxin2SPPFyMPcenbRQjRJLcjwaBK)
Options:

Generate new key pair
Encrypt message
Decrypt message
Exit

Enter choice (1-4): 2
Enter message to encrypt: so not doing much then?

Enter recipient's public key (STM...): STM6VsVfhBdhs5pcX7CoTeoyWtxin2SPPFyMPcenbRQjRJLcjwaBK

Enter your private key (5...): 5JZqP9VBVL5tTqHCuAjPd4WuJDv84e56fA48wc6CnKtMq6Z4cVe

Enter output filename: test2.msg
Message encrypted and saved to test2.msg

Encrypted memo: #f0SOHdMtUA5az+j9s3iwVbThCKvHCy1j3mLZTS45ymAYtAAhVv+6g9Bll1V0unDOIksVC2mdTduPor9IKM4DygfrQz1KSxsf3uC/za+Jxd6BIv4N5l5L1g==
Options:

Generate new key pair
Encrypt message
Decrypt message
Exit

Enter choice (1-4): 3
Enter encrypted file path: test2.msg

Enter your private key (5...): 5KR1behsskwnusyUMGZMNVdemVFUvoJTLkj4M7UhN3jpv7G5yK8
Decrypted message: so not doing much then?

Sender's public key: STM5aV2anXQonjiBtjSiF8K8g336aDviXQq9j2441hTgVdm3qD3BU
(You can reply by encrypting a message to: STM5aV2anXQonjiBtjSiF8K8g336aDviXQq9j2441hTgVdm3qD3BU)
Options:

Generate new key pair
Encrypt message
Decrypt message
Exit

Enter choice (1-4):

== Example of Script use 2 ==

• Below is some test keys generated for this demo
• This time it did not give same public key from signing private key - but still worked.

RECEIVING
Key Pair 1:
Generating new Hive key pair...
Private Key (WIF): 5JxAbGJ7XFcpAY3rW3pmzGapEkyrSf9wz14Lar3ZMvxUpA14uaR
Public Key (STM): STM5KtMabHkqWdwBJavkFRpHd4UkYSMQJiofW3vicw68t6y53YYpF
SENDING

Key Pair 2:

Generating new Hive key pair...

Private Key (WIF): 5HvNXDZYh5QFFikGnwv8cs7u2nF6eiUTKPScBfdy4QzvJWqKCLo

Public Key (STM): STM6a9JCL7LXKpKDYjaYiwFtdqydkh9aha5YrH7NoKm3wdkw4eUFg

=== Encryption and Decryption Example 2 ===

(hive_beem_env) ubuntu@keys:~$ python3 crypt.py 
=== Offline Hive Memo Tool ===
Options:

Generate new key pair
Encrypt message
Decrypt message
Exit

Enter choice (1-4): 2
Enter message to encrypt: yo whats up :) does this make sense to you.

Enter recipient's public key (STM...): STM5KtMabHkqWdwBJavkFRpHd4UkYSMQJiofW3vicw68t6y53YYpF

Enter your private key (5...): 5HvNXDZYh5QFFikGnwv8cs7u2nF6eiUTKPScBfdy4QzvJWqKCLo

Enter output filename: newtest.msg
Message encrypted and saved to newtest.msg

Encrypted memo: #syhpjq7Bae/dvF3/yeUdtk9leWooSemGYGSgFlxTXmDl9t4rnDoT1/YHo7HMnf+ZM3FPmMZmNZFeSUUAeWcP+m3g9L/7wvdWP0XXtTqEgoZZOl1BAqJTHIdHxQKDQ1++jLx2YZEkxKo=
Options:

Generate new key pair
Encrypt message
Decrypt message
Exit

Enter choice (1-4): 3
Enter encrypted file path: newtest.msg

Enter your private key (5...): 5JxAbGJ7XFcpAY3rW3pmzGapEkyrSf9wz14Lar3ZMvxUpA14uaR
Decrypted message: yo whats up :) does this make sense to you.

Sender's public key: STM6a9JCL7LXKpKDYjaYiwFtdqydkh9aha5YrH7NoKm3wdkuxXxXg
(You can reply by encrypting a message to: STM6a9JCL7LXKpKDYjaYiwFtdqydkh9aha5YrH7NoKm3wdkuxXxXg)
Options:

Generate new key pair
Encrypt message
Decrypt message
Exit

Enter choice (1-4): 2
Enter message to encrypt: reply to sender

Enter recipient's public key (STM...): STM6a9JCL7LXKpKDYjaYiwFtdqydkh9aha5YrH7NoKm3wdkuxXxXg

Enter your private key (5...): 5JxAbGJ7XFcpAY3rW3pmzGapEkyrSf9wz14Lar3ZMvxUpA14uaR

Enter output filename: reply.msg
Message encrypted and saved to reply.msg

Encrypted memo: #x06sC2YmlHQ5qoKbtCsiibPc7YGejYH1mqxsX01cMQ0UhSo6gKLCWM65AjL8dl80Jdhb6iuJlrlCrlZgdZkO8at0vBGTtLin
Options:

Generate new key pair
Encrypt message
Decrypt message
Exit

Enter choice (1-4): 3
Enter encrypted file path: reply.msg

Enter your private key (5...): 5HvNXDZYh5QFFikGnwv8cs7u2nF6eiUTKPScBfdy4QzvJWqKCLo
Decrypted message: reply to sender

Sender's public key: STM5KtMabHkqWdwBJavkFRpHd4UkYSMQJiofW3vicw68t6y7eTR76
(You can reply by encrypting a message to: STM5KtMabHkqWdwBJavkFRpHd4UkYSMQJiofW3vicw68t6y7eTR76)
Options:

Generate new key pair
Encrypt message
Decrypt message
Exit

Enter choice (1-4):