def do_execute(self, state):
uid = state.certificate_json['assertion']['uid']
signature = state.certificate_json['signature']
if state.signing_key is None or uid is None or signature is None:
return False
message = BitcoinMessage(uid)
return VerifyMessage(state.signing_key, message, signature)
def verify_signature(uid, signed_certificate_file_name, issuing_address):
"""
Verify the certificate signature matches the expected. Double-check the uid field in the certificate and use
VerifyMessage to confirm that the signature in the certificate matches the issuing_address.
Raises error is verification fails.
:param uid:
:param signed_certificate_file_name:
:param issuing_address:
:return:
"""
# Throws an error if invalid
logging.info('verifying signature for certificate with uid=%s:', uid)
with open(signed_certificate_file_name) as in_file:
signed_cert = in_file.read()
signed_cert_json = json.loads(signed_cert)
to_verify = signed_cert_json['assertion']['uid']
signature = signed_cert_json['signature']
message = BitcoinMessage(to_verify)
verified = VerifyMessage(issuing_address, message, signature)
if not verified:
error_message = 'There was a problem with the signature for certificate uid={}'.format(
signed_cert_json['assertion']['uid'])
raise UnverifiedSignatureError(error_message)
logging.info('verified signature')
def verify_message(address, message, signature):
try:
return VerifyMessage(address=address,
message=BitcoinMessage(message),
sig=signature)
except Exception as ex:
return False
def sign_and_verify(private_key, message, address):
key = CBitcoinSecret(private_key)
signature = SignMessage(key=key, message=BitcoinMessage(message))
assert VerifyMessage(address=address,
message=BitcoinMessage(message),
sig=signature)
return signature
async def recover_missing_transaction(self, txn_id, exclude_ids=[]):
return False
if await self.config.mongo.async_db.failed_recoveries.find_one({'txn_id': txn_id}):
return False
self.app_log.warning("recovering missing transaction input: {}".format(txn_id))
address = str(P2PKHBitcoinAddress.from_pubkey(bytes.fromhex(self.public_key)))
missing_txns = self.config.mongo.async_db.blocks.aggregate([
{
'$unwind': '$transactions'
},
{
'$project': {
'transaction': '$transactions',
'index': '$index'
}
}
], allowDiskUse=True)
async for missing_txn in missing_txns:
self.app_log.warning('recovery searching block index: {}'.format(missing_txn['index']))
try:
result = verify_signature(base64.b64decode(txn_id), missing_txn['transaction']['hash'].encode(),
bytes.fromhex(self.public_key))
if result:
block_index = await self.find_unspent_missing_index(missing_txn['transaction']['hash'], exclude_ids)
if block_index:
await self.replace_missing_transaction_input(
block_index,
missing_txn['transaction']['hash'],
txn_id
)
return True
else:
if len(base64.b64decode(txn_id)) != 65:
continue
result = VerifyMessage(
address,
BitcoinMessage(missing_txn['transaction']['hash'], magic=''),
txn_id
)
if result:
block_index = await self.find_unspent_missing_index(missing_txn['transaction']['hash'], exclude_ids)
if block_index:
await self.replace_missing_transaction_input(
block_index,
missing_txn['transaction']['hash'],
txn_id
)
return True
except:
continue
await self.config.mongo.async_db.failed_recoveries.update_one({
'txn_id': txn_id
},
{
'$set': {
'txn_id': txn_id
}
}, upsert=True)
return False
def test_verify_message_simple(self):
address = "1F26pNMrywyZJdr22jErtKcjF8R3Ttt55G"
message = address
signature = "H85WKpqtNZDrajOnYDgUY+abh0KCAcOsAIOQwx2PftAbLEPRA7mzXA/CjXRxzz0MC225pR/hx02Vf2Ag2x33kU4="
message = BitcoinMessage(message)
self.assertTrue(VerifyMessage(address, message, signature))
def verify(self):
getcontext().prec = 8
if int(self.version) != int(CHAIN.get_version_for_height(self.index)):
raise Exception("Wrong version for block height", self.version, CHAIN.get_version_for_height(self.index))
txns = self.get_transaction_hashes()
verify_merkle_root = self.get_merkle_root(txns)
if verify_merkle_root != self.merkle_root:
raise Exception("Invalid block merkle root")
header = self.generate_header()
hashtest = self.generate_hash_from_header(self.index, header, str(self.nonce))
# print("header", header, "nonce", self.nonce, "hashtest", hashtest)
if self.hash != hashtest:
getLogger("tornado.application").warning("Verify error hashtest {} header {} nonce {}".format(hashtest, header, self.nonce))
raise Exception('Invalid block hash')
address = P2PKHBitcoinAddress.from_pubkey(bytes.fromhex(self.public_key))
try:
# print("address", address, "sig", self.signature, "pubkey", self.public_key)
result = verify_signature(base64.b64decode(self.signature), self.hash.encode('utf-8'), bytes.fromhex(self.public_key))
if not result:
raise Exception("block signature1 is invalid")
except:
try:
result = VerifyMessage(address, BitcoinMessage(self.hash.encode('utf-8'), magic=''), self.signature)
if not result:
raise
except:
raise Exception("block signature2 is invalid")
# verify reward
coinbase_sum = 0
for txn in self.transactions:
if int(self.index) > CHAIN.CHECK_TIME_FROM and (int(txn.time) > int(self.time) + CHAIN.TIME_TOLERANCE):
#yadacoin.core.config.CONFIG.mongo.db.miner_transactions.remove({'id': txn.transaction_signature}, multi=True)
#raise Exception("Block embeds txn too far in the future")
pass
if txn.coinbase:
for output in txn.outputs:
coinbase_sum += float(output.value)
fee_sum = 0.0
for txn in self.transactions:
if not txn.coinbase:
fee_sum += float(txn.fee)
reward = CHAIN.get_block_reward(self.index)
#if Decimal(str(fee_sum)[:10]) != Decimal(str(coinbase_sum)[:10]) - Decimal(str(reward)[:10]):
"""
KO for block 13949
0.02099999 50.021 50.0
Integrate block error 1 ('Coinbase output total does not equal block reward + transaction fees', 0.020999999999999998, 0.021000000000000796)
"""
if quantize_eight(fee_sum) != quantize_eight(coinbase_sum - reward):
print(fee_sum, coinbase_sum, reward)
raise Exception("Coinbase output total does not equal block reward + transaction fees", fee_sum, (coinbase_sum - reward))
def verify(self):
getcontext().prec = 8
if int(self.version) != int(BU.get_version_for_height(self.index)):
raise BaseException("Wrong version for block height", self.version,
BU.get_version_for_height(self.index))
try:
txns = self.get_transaction_hashes()
self.set_merkle_root(txns)
if self.verify_merkle_root != self.merkle_root:
raise BaseException("Invalid block")
except:
raise
try:
header = BlockFactory.generate_header(self)
hashtest = BlockFactory.generate_hash_from_header(
header, str(self.nonce))
if self.hash != hashtest:
raise BaseException('Invalid block')
except:
raise
address = P2PKHBitcoinAddress.from_pubkey(
self.public_key.decode('hex'))
try:
result = verify_signature(base64.b64decode(self.signature),
self.hash, self.public_key.decode('hex'))
if not result:
raise Exception("block signature is invalid")
except:
try:
result = VerifyMessage(address,
BitcoinMessage(self.hash, magic=''),
self.signature)
if not result:
raise
except:
raise BaseException("block signature is invalid")
# verify reward
coinbase_sum = 0
for txn in self.transactions:
if txn.coinbase:
for output in txn.outputs:
coinbase_sum += float(output.value)
fee_sum = 0.0
for txn in self.transactions:
if not txn.coinbase:
fee_sum += float(txn.fee)
reward = BU.get_block_reward(self.config, self.mongo, self)
if Decimal(str(fee_sum)[:10]) != (Decimal(str(coinbase_sum)[:10]) -
Decimal(str(reward)[:10])):
raise BaseException(
"Coinbase output total does not equal block reward + transaction fees",
fee_sum, (coinbase_sum - reward))
def verifyMessage():
data = request.get_json()
addr = data["addr"]
msg = BitcoinMessage(data["msg"])
sig = data["sig"]
if VerifyMessage(addr, msg, sig):
return "verified"
else:
return "unverified"
def sign(self, message):
message = BitcoinMessage(message)
signature = SignMessage(self.key, message).decode('ascii')
print("Address: %s" % self.key)
print("Message: %s" % message)
print("Signature: %s" % signature)
assert VerifyMessage(self.address, message, signature)
return signature
def check_author(address, signed_json):
uid = signed_json['assertion']['uid']
message = BitcoinMessage(uid)
if signed_json.get('signature', None):
signature = signed_json['signature']
logging.debug('Found signature for uid=%s; verifying message', uid)
return VerifyMessage(address, message, signature)
logging.warning('Missing signature for uid=%s', uid)
return False
def do_verify_signature(address, signed_cert):
signed_cert_json = json.loads(signed_cert)
to_verify = signed_cert_json['assertion']['uid']
message = BitcoinMessage(to_verify)
signature = signed_cert_json['signature']
verified = VerifyMessage(address, message, signature)
if not verified:
error_message = 'There was a problem with the signature for certificate uid={}'.format(
signed_cert_json['assertion']['uid'])
raise UnverifiedSignatureError(error_message)
def check_incoming_job_crypto(job):
job_id = job['job'].pop('id')
if job_id == sha256(json.dumps(job).encode('utf-8')).hexdigest():
validity = job.pop('validity')
if VerifyMessage(validity['signature_address'],
BitcoinMessage(json.dumps(job)),
validity['signature']):
return True
else:
return False
def delegate_submit():
if request.method == 'GET':
return render_template('delegate_submit.html')
message = ''
signature = ''
if 'message' in request.form: message = request.form['message']
if 'signature' in request.form: signature = request.form['signature']
if message == "" or signature == "":
status = 'Message/Signature is missing'
return render_template('delegate_submit.html', status=status)
try:
message_object = json.loads(message)
except:
print("errored.")
status = 'message is not properly formatted JSON'
return render_template('delegate_submit.html', status=status)
try:
source = message_object['source']
delegate = message_object['delegate']
except:
if not 'source' in message_object:
status = 'Source field is missing.'
if not 'delegate' in message_object:
status = 'Delegate field is missing.'
return render_template('delegate_submit.html', status=status)
data = BitcoinMessage(message)
verified = VerifyMessage(source, data, signature)
if not verified:
status = 'Verification failed.'
return render_template('delegate_submit.html', status=status)
tuple = (source, delegate)
conn = sqlite3.connect('pepevote.db')
c = conn.cursor()
c.execute("INSERT OR REPLACE INTO delegates(source, delegate) VALUES(?,?)",
tuple)
conn.commit()
conn.close()
print('Delegation processed successfully.')
status = 'Delegation processed successfully.'
return render_template('delegate_submit.html', status=status)
def test_sign_message_simple(self):
key = CBitcoinSecret(
"L4vB5fomsK8L95wQ7GFzvErYGht49JsCPJyJMHpB4xGM6xgi2jvG")
address = "1F26pNMrywyZJdr22jErtKcjF8R3Ttt55G"
message = address
message = BitcoinMessage(message)
signature = SignMessage(key, message)
self.assertTrue(signature)
self.assertTrue(VerifyMessage(address, message, signature))
def verify_message(address, message, signature):
"""
Verify message was signed by the address
:param address: signing address
:param message: message to check
:param signature: signature being tested
:return:
"""
bitcoin_message = BitcoinMessage(message)
verified = VerifyMessage(address, bitcoin_message, signature)
return verified
def print_verbose(signature, key, msg):
secret = CBitcoinSecret(key)
address = P2PKHBitcoinAddress.from_pubkey(secret.pub)
message = BitcoinMessage(msg)
print('Address: %s' % address)
print('Message: %s' % msg)
print('Signature: %s' % signature)
print('Verified: %s' % VerifyMessage(address, message, signature))
print('\nTo verify using bitcoin core:')
print('\n`bitcoin-cli verifymessage %s \'%s\' \'%s\'`\n' %
(address, signature.decode('ascii'), msg))
def test_sign_message_vectors(self):
for vector in load_test_vectors('signmessage.json'):
key = CBitcoinSecret(vector['wif'])
message = BitcoinMessage(vector['address'])
signature = SignMessage(key, message)
self.assertTrue(signature,
"Failed to sign for [%s]" % vector['address'])
self.assertTrue(
VerifyMessage(vector['address'], message, vector['signature']),
"Failed to verify signature for [%s]" % vector['address'])
def do_execute(self):
if self.signing_key is None or self.content_to_verify is None or self.signature_value is None:
return False
message = BitcoinMessage(self.content_to_verify)
try:
lock.acquire()
# obtain lock while modifying global state
bitcoin.SelectParams(self.chain.name)
return VerifyMessage(self.signing_key, message, self.signature_value)
finally:
lock.release()
def verify(self):
verify_hash = self.generate_hash()
address = P2PKHBitcoinAddress.from_pubkey(
self.public_key.decode('hex'))
if verify_hash != self.hash:
raise InvalidTransactionException("transaction is invalid")
try:
result = verify_signature(
base64.b64decode(self.transaction_signature), self.hash,
self.public_key.decode('hex'))
if not result:
raise
except:
try:
result = VerifyMessage(address,
BitcoinMessage(self.hash, magic=''),
self.transaction_signature)
if not result:
raise
except:
raise InvalidTransactionSignatureException(
"transaction signature did not verify")
# verify spend
total_input = 0
for txn in self.inputs:
txn_input = Transaction.from_dict(BU.get_transaction_by_id(txn.id))
for output in txn_input.outputs:
if str(output.to) == str(address):
total_input += float(output.value)
if self.coinbase:
return
total_output = 0
for txn in self.outputs:
total_output += float(txn.value)
total = float(total_output) + float(self.fee)
if str(total_input) != str(total):
raise BaseException(
"inputs and outputs sum must match %s, %s, %s, %s" %
(total_input, float(total_output), float(self.fee), total))
def verify(signed_json, options, chain_name='mainnet'):
# options['expandContext': {'@vocab': 'https://fallback.org/'}]
# compact to security context
res = jsonld.compact(signed_json,
SECURITY_CONTEXT_URL,
options={'documentLoader': cached_document_loader})
signature = res['signature']['signatureValue']
del res['signature']
normalized = normalize_jsonld(res)
to_hash = _getDataToHash(normalized, options=options)
message = BitcoinMessage(to_hash)
signing_key = options.creator[len(PUBKEY_PREFIX):]
# TODO: obtain lock while modifying global state
bitcoin.SelectParams(chain_name)
return VerifyMessage(signing_key, message, signature)
def do_execute(self):
if self.signing_key is None:
logging.error(
'EmbeddedSignatureChecker failed - signing key is none')
return False
if self.content_to_verify is None:
logging.error(
'EmbeddedSignatureChecker failed - content to verify is none')
return False
if self.signature_value is None:
logging.error(
'EmbeddedSignatureChecker failed - signature value is none')
return False
message = BitcoinMessage(self.content_to_verify)
try:
lock.acquire()
# obtain lock while modifying global state
bitcoin.SelectParams(chain_to_bitcoin_network(self.chain))
return VerifyMessage(self.signing_key, message,
self.signature_value)
finally:
lock.release()
def verify(address, message, signature):
message = BitcoinMessage(message)
return VerifyMessage(address, message, signature)
def verifySignature(address, signature, m):
message = BitcoinMessage(m)
return VerifyMessage(address, message, signature)
def verify(self):
from fastgraph import FastGraph
verify_hash = self.generate_hash()
address = P2PKHBitcoinAddress.from_pubkey(
self.public_key.decode('hex'))
if verify_hash != self.hash:
raise InvalidTransactionException("transaction is invalid")
try:
result = verify_signature(
base64.b64decode(self.transaction_signature), self.hash,
self.public_key.decode('hex'))
if not result:
raise Exception()
except:
try:
result = VerifyMessage(address,
BitcoinMessage(self.hash, magic=''),
self.transaction_signature)
if not result:
raise
except:
raise InvalidTransactionSignatureException(
"transaction signature did not verify")
# verify spend
total_input = 0
for txn in self.inputs:
input_txn = BU.get_transaction_by_id(self.config,
self.mongo,
txn.id,
include_fastgraph=isinstance(
self, FastGraph))
if not input_txn:
raise InvalidTransactionException(
"Input not found on blockchain.")
txn_input = Transaction.from_dict(self.config, self.mongo,
self.block_height, input_txn)
found = False
for output in txn_input.outputs:
if hasattr(txn, 'public_key') and hasattr(txn, 'signature'):
ext_address = P2PKHBitcoinAddress.from_pubkey(
txn.public_key.decode('hex'))
if str(output.to) == str(ext_address):
found = True
try:
result = verify_signature(
base64.b64decode(txn.signature), txn.id,
txn.public_key.decode('hex'))
if not result:
raise Exception()
except:
try:
result = VerifyMessage(
ext_address,
BitcoinMessage(txn.id, magic=''),
txn.signature)
if not result:
raise
except:
raise InvalidTransactionSignatureException(
"external input transaction signature did not verify"
)
elif str(output.to) == str(address):
found = True
total_input += float(output.value)
if not found:
if hasattr(txn, 'public_key') and hasattr(txn, 'signature'):
raise InvalidTransactionException(
"external input signing information did not match any recipients of the input transaction"
)
else:
raise InvalidTransactionException(
"using inputs from a transaction where you were not one of the recipients."
)
if self.coinbase:
return
total_output = 0
for txn in self.outputs:
total_output += float(txn.value)
total = float(total_output) + float(self.fee)
if "{0:.8f}".format(total_input) != "{0:.8f}".format(total):
raise BaseException(
"inputs and outputs sum must match %s, %s, %s, %s" %
(total_input, float(total_output), float(self.fee), total))
async def verify(self):
verify_hash = await self.generate_hash()
address = P2PKHBitcoinAddress.from_pubkey(
bytes.fromhex(self.public_key))
if verify_hash != self.hash:
raise InvalidTransactionException("transaction is invalid")
try:
result = verify_signature(
base64.b64decode(self.transaction_signature),
self.hash.encode('utf-8'), bytes.fromhex(self.public_key))
if not result:
print("t verify1")
raise Exception()
except:
try:
result = VerifyMessage(address,
BitcoinMessage(self.hash, magic=''),
self.transaction_signature)
if not result:
print("t verify2")
raise
except:
print("t verify3")
raise InvalidTransactionSignatureException(
"transaction signature did not verify")
if len(self.relationship) > 20480:
raise MaxRelationshipSizeExceeded(
'Relationship field cannot be greater than 2048 bytes')
# verify spend
total_input = 0
exclude_recovered_ids = []
async for txn in self.get_inputs(self.inputs):
input_txn = self.config.BU.get_transaction_by_id(txn.id)
if input_txn:
txn_input = Transaction.from_dict(input_txn)
if not input_txn:
if self.extra_blocks:
txn_input = await self.find_in_extra_blocks(txn)
if not txn_input:
result = await self.recover_missing_transaction(
txn.id, exclude_recovered_ids)
exclude_recovered_ids.append(exclude_recovered_ids)
raise MissingInputTransactionException(
"Input not found on blockchain: {}".format(txn.id))
found = False
for output in txn_input.outputs:
if isinstance(txn, ExternalInput):
ext_address = P2PKHBitcoinAddress.from_pubkey(
bytes.fromhex(txn_input.public_key))
int_address = P2PKHBitcoinAddress.from_pubkey(
bytes.fromhex(txn.public_key))
if str(output.to) == str(ext_address) and str(
int_address) == str(txn.address):
try:
result = verify_signature(
base64.b64decode(txn.signature),
txn.id.encode('utf-8'),
bytes.fromhex(txn_input.public_key))
if not result:
print("t verify4")
raise Exception()
except:
try:
result = VerifyMessage(
ext_address,
BitcoinMessage(txn.id, magic=''),
txn.signature)
if not result:
print("t verify5")
raise
except:
raise InvalidTransactionSignatureException(
"external input transaction signature did not verify"
)
found = True
total_input += float(output.value)
elif str(output.to) == str(address):
found = True
total_input += float(output.value)
if not found:
if isinstance(txn, ExternalInput):
raise InvalidTransactionException(
"external input signing information did not match any recipients of the input transaction"
)
else:
raise InvalidTransactionException(
"using inputs from a transaction where you were not one of the recipients."
)
if self.coinbase:
return
total_output = 0
for txn in self.outputs:
total_output += float(txn.value)
total = float(total_output) + float(self.fee)
if fix_float1(total_input) != fix_float1(total) and fix_float2(
total_input) != fix_float2(total):
raise TotalValueMismatchException(
"inputs and outputs sum must match %s, %s, %s, %s" %
(total_input, float(total_output), float(self.fee), total))
def submit_message():
message = ''
signature = ''
if 'message' in request.form: message = request.form['message']
if 'signature' in request.form: signature = request.form['signature']
if message == "" or signature == "":
registration_error = 'Message/Signature is missing'
return render_template('create_submission.html',
registration_error=registration_error)
else:
# TODO: Change 'image hash' to 'hash' for terseness
# TODO: Change status to error for readability?
# First, check if all relevant fields have been provided to the signed message.
# If you don't do this, things die with malformed input.
try:
message_object = json.loads(message)
except:
print("errored.")
registration_error = 'message is not properly formatted JSON'
return render_template('create_submission.html',
registration_error=registration_error)
try:
address = message_object['address']
asset = message_object['asset']
hash = message_object['image_hash']
block = message_object['block']
except:
if not 'address' in message_object:
registration_error = 'Address field is missing.'
if not 'asset' in message_object:
registration_error = 'Asset field is missing.'
if not 'image_hash' in message_object:
registration_error = 'Hash field is missing.'
return render_template('create_submission.html',
registration_error=registration_error,
message=message)
if not 'block' in message_object:
registration_error = 'Block field is missing.'
return render_template('create_submission.html',
registration_error=registration_error,
hash=hash,
message=message)
data = BitcoinMessage(message)
verified = VerifyMessage(address, data, signature)
if not verified:
registration_error = 'Verification failed.'
return render_template('create_submission.html',
registration_error=registration_error,
message=message,
hash=hash)
else:
conn = sqlite3.connect('pepevote.db')
c = conn.cursor()
# Check if this is a duplicate entry
c.execute(
'SELECT * FROM verified_messages WHERE hash=? OR asset=?',
(hash, asset))
entry = c.fetchone()
conn.close()
if entry:
registration_error = 'This asset or image has already been submitted this week.'
return render_template('create_submission.html',
registration_error=registration_error,
hash=hash,
message=message)
else: # Entry is not a duplicate
# Check if address actually owns the asset in question
if not owns_asset(address, asset):
registration_error = 'The provided address does not have the provided asset.'
return render_template(
'create_submission.html',
registration_error=registration_error,
hash=hash,
message=message)
# Check if the burn fee is paid
paid = False
candidates = get_candidates(512000, 520000)
for candidate in candidates:
if hash == candidate:
paid = True
# TODO: Check if anyone has ever used this hash before
if not paid:
registration_error = 'Burn fee has not been paid.'
return render_template(
'create_submission.html',
registration_error=registration_error,
message=message,
hash=hash)
# TODO: Check if the asset is a duplicate of an existing one
# Check if hash matches an uploaded image
match = False
dir = 'uploads'
submissions = os.listdir(dir)
candidates = []
for submission in submissions:
if not submission == "temp":
candidates.append(os.path.join(dir, submission))
for candidate in candidates:
candidate_hash = sha256_checksum(candidate)
print(candidate)
print(candidate_hash)
if hash == candidate_hash:
match = True
submission_path = candidate
if not match:
registration_error = 'No uploaded image has the provided hash.'
return render_template(
'create_submission.html',
registration_error=registration_error,
hash=hash,
message=message)
location = os.path.join('static', 'submitted',
submission_path[8:])
os.rename(submission_path, location)
conn = sqlite3.connect('pepevote.db')
c = conn.cursor()
tuple = (address, asset, hash, block, signature, location)
c.execute(
"INSERT INTO verified_messages(address, asset, hash, block, signature, image) VALUES(?, ?, ?, ?, ?, ?)",
tuple)
conn.commit()
conn.close()
success = 'Verification succeeded, your art has been registered.'
try:
return render_template('create_submission.html',
success=success,
hash=hash,
message=message)
except:
return render_template('create_submission.html')
def submit_vote():
if request.method == 'GET':
return render_template('submit_vote.html')
else:
signature = ''
vote_string = ''
if 'signature' in request.form: signature = request.form['signature']
if 'vote_string' in request.form:
vote_string = request.form['vote_string']
if vote_string == "" or signature == "":
status = 'Signature is missing.'
return render_template('submit_vote.html',
vote_string=vote_string,
status=status)
else:
# TODO: Change 'image hash' to 'hash' for terseness
# TODO: Change status to error for readability?
# First, check if all relevant fields have been provided to the signed message.
# If you don't do this, things die with malformed input.
try:
message_object = json.loads(vote_string)
except:
print("errored.")
status = 'message is not properly formatted JSON'
return render_template('submit_vote.html',
vote_string=vote_string,
status=status)
try:
address = message_object['address']
block = message_object['block']
votes = message_object['votes']
except:
if not 'address' in message_object:
status = 'Address field is missing.'
if not 'votes' in message_object:
status = 'Votes field is missing.'
if not 'block' in message_object:
status = 'Block field is missing.'
return render_template('submit_vote.html',
vote_string=vote_string,
status=status)
data = BitcoinMessage(vote_string)
try:
verified = VerifyMessage(address, data, signature)
except:
status = 'Verification failed - signature is malformed.'
return render_template('submit_vote.html',
status=status,
vote_string=vote_string)
if not verified:
status = 'Verification failed.'
return render_template('submit_vote.html',
status=status,
vote_string=vote_string)
else:
conn = sqlite3.connect('pepevote.db')
c = conn.cursor()
# Check if this is a duplicate entry
c.execute('SELECT * FROM votes WHERE address=?', (address, ))
entry = c.fetchone()
conn.close()
# (address text PRIMARY KEY, block text, votes text, signature text)''')
if entry is not None:
# Check block height to see if message is reused
(_, old_block, _, _) = entry
if block <= old_block:
print("Reusing old message")
status = 'Error: reused old vote'
return render_template('submit_vote.html',
status=status,
vote_string=vote_string)
conn = sqlite3.connect('pepevote.db')
c = conn.cursor()
tuple = (address, block, str(votes), signature)
c.execute(
"INSERT OR REPLACE INTO votes(address, block, votes, signature) VALUES(?, ?, ?, ?)",
tuple)
conn.commit()
conn.close()
print('Vote submitted successfully')
status = 'Vote submitted successfully.'
return render_template('submit_vote.html',
vote_string=vote_string,
status=status)
# It is subject to the license terms in the LICENSE file found in the top-level
# directory of this distribution.
#
# No part of python-bitcoinlib, including this file, may be copied, modified,
# propagated, or distributed except according to the terms contained in the
# LICENSE file.
from __future__ import absolute_import, division, print_function, unicode_literals
from bitcoin.wallet import CBitcoinSecret, P2PKHBitcoinAddress
from bitcoin.signmessage import BitcoinMessage, VerifyMessage, SignMessage
key = CBitcoinSecret("L4vB5fomsK8L95wQ7GFzvErYGht49JsCPJyJMHpB4xGM6xgi2jvG")
address = P2PKHBitcoinAddress.from_pubkey(
key.pub) # "1F26pNMrywyZJdr22jErtKcjF8R3Ttt55G"
message = "Hey I just met you, and this is crazy, but I'll verify my address, maybe ..."
message = BitcoinMessage(message)
signature = SignMessage(key, message)
print(key, address)
print("Address: %s" % address)
print("Message: %s", message)
print("\nSignature: %s" % signature)
print("\nVerified: %s" % VerifyMessage(address, message, signature))
print("\nTo verify using bitcoin core;")
print("`bitcoin-cli verifymessage %s \"%s\" \"%s\"`" %
(address, signature.decode('ascii'), message))
def verifySignature(address, signature, message):
msg = BitcoinMessage(message)
return VerifyMessage(address, msg, signature)