def password(account_name):
from beemgraphenebase.account import PasswordKey
import random
num = random.sample("stringascii_letters", 10)
strs = ''
password = strs.join(num)
owner_key = PasswordKey(account_name, password, role="owner")
owner_key=owner_key.get_private()
key = "P5" + (str(owner_key))[2:51]
return key
def generate_password(import_password, wif=1):
if wif > 0:
password = import_password
for _ in range(wif):
pk = PasswordKey("", password, role="")
password = str(pk.get_private())
password = '******' + password
else:
password = import_password
return password
def passwordkey_to_key(passwordkey, account, role, prefix="STM"):
""" Get a private key from an input that may be a key or a master
password.
:param str passwordkey: Key or master password to check/transform.
:param str account: Account name the key is for.
:param str role: Role of the key (posting, active, owner, memo)
:param str prefix: Network prefix (default: "STM")
"""
try:
# check if passwordkey is a valid private key
PrivateKey(passwordkey, prefix=prefix)
return passwordkey
except ValueError:
# PrivateKey() failed, provided string is not a private key
# -> treat it as a master password
pk = PasswordKey(account, passwordkey, role=role, prefix=prefix)
return str(pk.get_private())
def recover_account(account):
"""Recover ACCOUNT. This action has to be initiated/signed by the
account to be recovered.
"""
acc = Account(account)
if acc.get_owner_history() == []:
logger.error("@%s has an empty owner history - recovering "
"this account is not possible!" % (acc['name']))
return
# ask & verify the old owner key
old_priv_owner_key = getpass("Enter the old master password or owner "
"key for @%s: " % (acc['name']))
old_pk = passwordkey_to_key(old_priv_owner_key,
acc['name'],
role="owner",
prefix=acc.steem.prefix)
old_public_owner_key = format(old_pk.get_public(), acc.steem.prefix)
# get the new password to prepare all new keys
new_pwd = getpass("Enter the new master password for @%s: " %
(acc['name']))
key_auths = {}
for role in ['owner', 'active', 'posting', 'memo']:
pk = PasswordKey(acc['name'], new_pwd, role=role)
key_auths[role] = format(pk.get_public_key(), acc.steem.prefix)
if role == 'owner':
new_priv_owner_key = str(pk.get_private())
# Assemble the account recovery operation
recent_owner_authority = {
"key_auths": [[old_public_owner_key, 1]],
"account_auths": [],
"weight_threshold": 1,
"prefix": acc.steem.prefix
}
new_owner_authority = {
"key_auths": [[key_auths['owner'], 1]],
"account_auths": [],
"weight_threshold": 1,
"prefix": acc.steem.prefix
}
op = operations.Recover_account(
**{
'account_to_recover': acc['name'],
'new_owner_authority': new_owner_authority,
'recent_owner_authority': recent_owner_authority,
'extensions': [],
"prefix": acc.steem.prefix
})
# Send the recovery operations to the blockchain
tb = TransactionBuilder(steem_instance=acc.steem)
tb.appendOps([op])
tb.appendWif(new_priv_owner_key)
tb.appendWif(old_priv_owner_key)
tb.sign()
tb.broadcast()
logger.info("@%s recovered." % (acc['name']))
# Assemble the account update operation
op = operations.Account_update(
**{
"account": acc["name"],
'active': {
'account_auths': [],
'key_auths': [[key_auths['active'], 1]],
"address_auths": [],
'weight_threshold': 1,
'prefix': acc.steem.prefix
},
'posting': {
'account_auths': acc['posting']['account_auths'],
'key_auths': [[key_auths['posting'], 1]],
"address_auths": [],
'weight_threshold': 1,
'prefix': acc.steem.prefix
},
'memo_key': key_auths['memo'],
"json_metadata": acc['json_metadata'],
"prefix": acc.steem.prefix
})
# Send the recovery operations to the blockchain
tb = TransactionBuilder(steem_instance=acc.steem)
tb.appendOps([op])
tb.appendWif(new_priv_owner_key)
tb.sign()
tb.broadcast()
logger.info("SUCCESS: @%s's active, posting and memo keys updated." %
(acc['name']))
def suggest_keys(account, custom_password):
"""Suggest a set of new keys for ACCOUNT. This should be called by the
owner of the account to be recovered.
"""
acc = Account(account)
if acc.get_owner_history() == []:
logger.warning("@%s has an empty owner history - recovering "
"this account won't be possible!" % (acc['name']))
# Ask or generate a new master password
if custom_password:
new_password = getpass("Enter new master password for %s: " %
(acc['name']))
repMasterPwd = getpass("Repeat new master password for %s: " %
(acc['name']))
if new_password != repMasterPwd:
raise ValueError("The passwords do not match!")
else:
new_password = "******" + str(PrivateKey(prefix=acc.steem.prefix))
# Derive the new keys
owner = PasswordKey(acc['name'],
new_password,
role='owner',
prefix=acc.steem.prefix)
active = PasswordKey(acc['name'],
new_password,
role='active',
prefix=acc.steem.prefix)
posting = PasswordKey(acc['name'],
new_password,
role='posting',
prefix=acc.steem.prefix)
memo = PasswordKey(acc['name'],
new_password,
role='memo',
prefix=acc.steem.prefix)
# Print results
print("\n1.) Store the new master password and keys safely!")
if not custom_password:
t = PrettyTable([
'New PRIVATE keys', 'DO NOT PUBLISH OR FORWARD, '
'STORE SAFELY!'
])
t.add_row(['Account', acc['name']])
t.add_row(['New private master password', new_password])
t.add_row(['New private active key', active.get_private()])
t.add_row(['New private posting key', posting.get_private()])
t.add_row(['New private memo key', memo.get_private()])
print(t)
print("\n2.) Make sure you stored the new password and keys safely!")
print("\n3.) Forward the new PUBLIC owner key to your recovery account:")
t = PrettyTable(
['New PUBLIC owner key', 'Forward this to your '
'recovery partner'])
t.add_row(["Account", acc['name']])
t.add_row(
["New public owner key",
format(owner.get_public(), acc.steem.prefix)])
t.add_row(["Recovery partner", acc['recovery_account']])
print(t)
#!/usr/bin/env python3
from getpass import getpass
from beemgraphenebase.account import PasswordKey
from tabulate import tabulate
hive_id = input("Hive User ID: ")
brain_key = getpass(prompt="Master Password: "******"owner", "active", "posting", "memo"]
data = []
for role in roles:
keys = PasswordKey(hive_id, brain_key, role=role, prefix="STM")
priv_key = keys.get_private()
pub_key = keys.get_public()
data.append([role, str(pub_key), str(priv_key)])
print(tabulate(data, headers=["Role", "Public Key", "Private Key"]))
if format(pk_validity_check, stm.prefix) != new_owner_key:
raise ValueError("Invalid public owner key!")
#####################################################################
# Ask and verify the active key of the recovery account
#####################################################################
recovery_ak = getpass("Enter active key, owner key or master "
"password for @%s: " % (args.recovery_account))
try:
pk_check = PrivateKey(recovery_ak, prefix=stm.prefix)
except Exception:
# PrivateKey() failed - treat it as a master password
pk = PasswordKey(args.recovery_account, recovery_ak,
role="active", prefix=stm.prefix)
recovery_ak = str(pk.get_private())
#####################################################################
# Assemble the account recovery request operation
#####################################################################
new_owner_authority = {
'key_auths': [[new_owner_key, 1]],
'account_auths': [],
'weight_threshold': 1,
'prefix': stm.prefix
}
op = operations.Request_account_recovery(**{
'account_to_recover': args.account_to_recover,
'recovery_account': args.recovery_account,
prefix=stm.prefix)
memo = PasswordKey(account['name'],
new_password,
role='memo',
prefix=stm.prefix)
#####################################################################
# Print results
#####################################################################
print("\n1.) Store the new master password and keys safely!")
if not args.custom_password:
t = PrettyTable(
['New PRIVATE keys', 'DO NOT PUBLISH OR FORWARD, '
'STORE SAFELY!'])
t.add_row(['Account', account['name']])
t.add_row(['New private master password', new_password])
t.add_row(['New private active key', active.get_private()])
t.add_row(['New private posting key', posting.get_private()])
t.add_row(['New private memo key', memo.get_private()])
print(t)
print("\n2.) Make sure you stored the new password and keys safely!")
print("\n3.) Forward the new PUBLIC owner key to your recovery account:")
t = PrettyTable(
['New PUBLIC owner key', 'Forward this to your '
'recovery partner'])
t.add_row(["Account", account['name']])
t.add_row(["New public owner key", format(owner.get_public(), stm.prefix)])
print(t)
old_priv_owner_key,
role="owner",
prefix=stm.prefix)
old_priv_owner_key = str(old_pk.get_private())
old_public_owner_key = format(old_pk.get_public(), stm.prefix)
#####################################################################
# get the new password to prepare all new keys
#####################################################################
new_pwd = getpass("Enter the new master password for @%s: " % (acc['name']))
key_auths = {}
for role in ['owner', 'active', 'posting', 'memo']:
pk = PasswordKey(acc['name'], new_pwd, role=role)
key_auths[role] = format(pk.get_public_key(), stm.prefix)
if role == 'owner':
new_priv_owner_key = str(pk.get_private())
#####################################################################
# Assemble the account recovery operation
#####################################################################
recent_owner_authority = {
"key_auths": [[old_public_owner_key, 1]],
"account_auths": [],
"weight_threshold": 1,
"prefix": stm.prefix
}
new_owner_authority = {
"key_auths": [[key_auths['owner'], 1]],
"account_auths": [],
"weight_threshold": 1,
"prefix": stm.prefix
# script for a tutorial: https://steemit.com/utopian-io/@blockchainstudio/owner-key-vs-master-password-offline-private-key-derivation-from-master-password-public-key-derivation-from-private-key
try:
from beemgraphenebase.account import PasswordKey
except:
from steem.steem import Steem
from steembase.account import PasswordKey
import getpass
roles = ["posting", "active", "memo", "owner"]
print(
"Warning! This will show your private keys on the screen if you enter your master password correctly."
)
print(
"To show that key derivations can be done offline, it will not check whether the password is correct."
)
account = input("Enter account name: ")
password = getpass.getpass("Enter master password: "******"%s key" % role)
pk = PasswordKey(account, password, role=role)
print(" public: %s" % pk.get_public())
print(" private: %s" % pk.get_private())