def cert_issuer_main(args=None):
from cert_issuer import config
parsed_config = config.get_config()
from cert_issuer import issue_certificates, trx_utils
trx_utils.set_cost_constants(parsed_config.tx_fee,
parsed_config.dust_threshold,
parsed_config.satoshi_per_byte)
issue_certificates.main(parsed_config)
def cert_issuer_main(args=None):
from cert_issuer import config
parsed_config = config.get_config()
from cert_issuer import issue_certificates
pr = cProfile.Profile()
pr.enable()
issue_certificates.main(parsed_config)
pr.disable()
# after your program ends
pr.print_stats(sort="tottime")
pr.dump_stats('profile.pstat')
def issue_certificates(export_path):
try:
parsed_config = config.get_config(os.path.abspath('../configuration/cert_issuer_conf.ini'))
tx_id = isu.main(parsed_config)
if tx_id:
logging.info('Transaction id is %s', tx_id)
else:
logging.error('Certificate issuing failed')
exit(1)
except Exception as ex:
logging.error(ex, exc_info=True)
exit(1)
def check_internet_on():
"""If internet off and USB plugged in, returns true. Else, continues to wait..."""
if config.get_config().skip_wifi_check:
logging.warning(
'app is configured to skip the wifi check when the USB is plugged in. Read the documentation to'
' ensure this is what you want, since this is less secure')
return True
while 1:
if internet_on() is True and not os.path.exists(secrets_file_path):
break
else:
print("Turn on your internet and unplug your USB to continue...")
time.sleep(10)
return True
def setUp(self):
config.get_config().skip_wifi_check = True
mock = MagicMock()
mock.uid = '34we3434'
mock.name = 'Some Name'
mock.pubkey = '123452'
mock.unsigned_certificate_file_name = 'test/unsigned.json'
mock.signed_certificate_file_name = 'test/signed.json'
mock.certificate_hash_file_name = 'test/hashed.txt'
mock.unsigned_tx_file_name = 'test/unsigned_tx.txt'
mock.unsent_tx_file_name = 'test/unsent_tx.txt'
mock.sent_tx_file_name = 'test/sent_tx.txt'
self.mock_config = mock
import time
import shutil
import sys
import glob2
import requests
from cert_issuer import config
unhexlify = binascii.unhexlify
hexlify = binascii.hexlify
if sys.version > '3':
unhexlify = lambda h: binascii.unhexlify(h.encode('utf8'))
hexlify = lambda b: binascii.hexlify(b).decode('utf8')
secrets_file_path = os.path.join(
config.get_config().usb_name, config.get_config().key_file)
def internet_off_for_scope(func):
def func_wrapper(*args, **kwargs):
check_internet_off()
result = func(*args, **kwargs)
check_internet_on()
return func_wrapper
def import_key():
with open(secrets_file_path) as key_file:
key = key_file.read().strip()
return key
transaction_cost - balance, issuing_address)
logging.error(error_message)
raise InsufficientFundsError(error_message)
# issue the certificates on the blockchain
logging.info('Issuing the certificates on the blockchain')
issuer.issue_on_blockchain(revocation_address=revocation_address)
blockcerts_tmp_dir = os.path.join(work_dir,
helpers.BLOCKCHAIN_CERTIFICATES_DIR)
if not os.path.exists(blockcerts_dir):
os.makedirs(blockcerts_dir)
for item in os.listdir(blockcerts_tmp_dir):
s = os.path.join(blockcerts_tmp_dir, item)
d = os.path.join(blockcerts_dir, item)
shutil.copy2(s, d)
logging.info('Your Blockchain Certificates are in %s', blockcerts_dir)
return blockcerts_dir
if __name__ == '__main__':
from cert_issuer import config
try:
parsed_config = config.get_config()
main(parsed_config)
except Exception as ex:
logging.error(ex, exc_info=True)
exit(1)
from cert_issuer import helpers
from cert_issuer.errors import UnverifiedTransactionError
from cert_issuer.helpers import internet_off_for_scope
from cert_issuer.models import TransactionCosts
COIN = 100000000 # satoshis in 1 btc
BYTES_PER_INPUT = 148 # assuming compressed public key
BYTES_PER_OUTPUT = 34
FIXED_EXTRA_BYTES = 10
OP_RETURN_BYTE_COUNT = 43 # our op_return output values always have the same length because they are SHA-256 hashes
cost_constants = config.get_constants()
RECOMMENDED_FEE = cost_constants.recommended_fee_per_transaction * COIN
MIN_PER_OUTPUT = cost_constants.min_per_output * COIN
SATOSHI_PER_BYTE = cost_constants.satoshi_per_byte
ALLOWABLE_WIF_PREFIXES = wif_prefix_for_netcode(config.get_config().netcode)
def create_trx(op_return_val, issuing_transaction_cost,
issuing_address, tx_outs, tx_input):
"""
:param op_return_val:
:param issuing_transaction_cost:
:param issuing_address:
:param tx_outs:
:param tx_input:
:return:
"""
cert_out = CMutableTxOut(0, CScript([OP_RETURN, op_return_val]))
tx_ins = [CTxIn(COutPoint(tx_input.tx_hash, tx_input.tx_out_index))]
app_config.signed_certs_file_part,
batch_id)
logging.info('Archiving sent transactions.')
helpers.archive_files(app_config.sent_txs_file_pattern,
app_config.archive_path,
app_config.txs_file_part,
batch_id)
logging.info('Archiving receipts.')
helpers.archive_files(app_config.receipts_file_pattern,
app_config.archive_path,
app_config.receipts_file_part,
batch_id)
logging.info('Archiving blockchain certificates.')
helpers.archive_files(app_config.blockchain_certificates_file_pattern,
app_config.archive_path,
app_config.blockchain_certificates_file_part,
batch_id)
archive_folder = os.path.join(app_config.archive_path, batch_id)
logging.info('Your Blockchain Certificates are in %s', archive_folder)
if __name__ == '__main__':
from cert_issuer import config
parsed_config = config.get_config()
main(parsed_config)
from pycoin.tx import Spendable
from cert_issuer import config
from cert_issuer.errors import ConnectorError
from cert_issuer.helpers import hexlify
from cert_issuer.helpers import unhexlify
try:
from urllib2 import urlopen, HTTPError
from urllib import urlencode
except ImportError:
from urllib.request import urlopen, HTTPError
from urllib.parse import urlencode
CONFIG_NETCODE = config.get_config().netcode
def try_get(url):
"""throw error if call fails"""
response = requests.get(url)
if int(response.status_code) != 200:
error_message = 'Error! status_code={}, error={}'.format(
response.status_code, response.json()['error'])
logging.error(error_message)
raise ConnectorError(error_message)
return response
def to_hex(transaction):
s = io.BytesIO()
transaction.stream(s)
def cert_issuer_main(args=None):
from cert_issuer import config
parsed_config = config.get_config()
from cert_issuer import issue_certificates
issue_certificates.main(parsed_config)
from pycoin.services.providers import service_provider_methods
from pycoin.tx import Spendable
from cert_issuer import config
from cert_issuer.errors import ConnectorError
from cert_issuer.helpers import hexlify
from cert_issuer.helpers import unhexlify
try:
from urllib2 import urlopen, HTTPError
from urllib import urlencode
except ImportError:
from urllib.request import urlopen, HTTPError
from urllib.parse import urlencode
CONFIG_NETCODE = config.get_config().netcode
def try_get(url):
"""throw error if call fails"""
response = requests.get(url)
if int(response.status_code) != 200:
error_message = 'Error! status_code={}, error={}'.format(
response.status_code,
response.json()['error'])
logging.error(error_message)
raise ConnectorError(error_message)
return response
def to_hex(transaction):
def issue_certificates(pubkey):
config_logger()
print()
logging.info('Trying to acquire file lock ...')
bypass = False
file = open(get_latest_transaction_file_dir(), 'r+')
fcntl.flock(file.fileno(), fcntl.LOCK_EX)
logging.info('Lock acquired ...')
tx_id = ''
successful = False
latest_transaction = file.readline()
chain_latest = ''
count = 0
if latest_transaction == '':
bypass = True
if bypass:
logging.info('The latest transaction check is bypassed ...')
else:
logging.info('Waiting the latest transaction to be confirmed ...')
while get_confirmation(latest_transaction, TOKEN) == 0:
logging.info('No confirmation yet. Will retry ...')
count += 1
if count >= 1000: # timeout
file.close()
raise Exception('Waiting timeout.')
request_sleep(TOKEN)
count = 0
while True:
count += 1
chain_latest = get_latest_transaction(pubkey, TOKEN)
if chain_latest != 'retry':
break
if count >= 1000:
file.close()
raise Exception('Waiting timeout.')
request_sleep(TOKEN)
logging.info('Passed')
if chain_latest in latest_transaction or bypass:
if not bypass:
logging.info('Latest transaction authenticity check passed ...')
try:
parsed_config = config.get_config(get_issuer_conf_dir(TOKEN))
tx_id = isu.main(parsed_config)
if tx_id:
logging.info('Transaction id is %s', tx_id)
file.seek(0)
file.write(tx_id)
successful = True
else:
logging.error('Certificate issuing failed')
file.close()
except Exception as ex:
logging.error(ex, exc_info=True)
file.close()
return [tx_id, successful]
else:
logging.error(
'Latest transaction authenticity check failed ... The public key is possibly stolen by someone else, please change a public key.'
)
file.close()
return [tx_id, successful, file]
import shutil
import sys
import time
import glob2
import requests
from cert_issuer import config, models
unhexlify = binascii.unhexlify
hexlify = binascii.hexlify
if sys.version > '3':
unhexlify = lambda h: binascii.unhexlify(h.encode('utf8'))
hexlify = lambda b: binascii.hexlify(b).decode('utf8')
secrets_file_path = os.path.join(config.get_config().usb_name,
config.get_config().key_file)
def internet_off_for_scope(func):
"""
Wraps func with check that internet is off, then on after the call to func
:param func:
:return:
"""
def func_wrapper(*args, **kwargs):
check_internet_off()
result = func(*args, **kwargs)
check_internet_on()
return result
