def test_encode_decode():
key1 = bitjws.PrivateKey()
pubkey1 = bitjws.pubkey_to_addr(key1.pubkey.serialize())
key2 = bitjws.PrivateKey()
pubkey2 = bitjws.pubkey_to_addr(key2.pubkey.serialize())
ser = bitjws.multisig_sign_serialize([key1, key2])
headers, payload = bitjws.multisig_validate_deserialize(ser)
rawpayload = json.loads(ser)['payload']
origpayload = bitjws.base64url_decode(rawpayload.encode('utf8'))
keys_found = {pubkey1: False, pubkey2: False}
assert len(headers) == 2
for h in headers:
assert len(h) == 3
assert h['typ'] == 'JWT'
assert h['alg'] == 'CUSTOM-BITCOIN-SIGN'
assert h['kid'] in keys_found
assert keys_found[h['kid']] == False
keys_found[h['kid']] = True
assert all(keys_found.values())
assert isinstance(payload.get('exp', ''), (float, int))
assert payload['aud'] is None
assert len(payload) == 2
assert payload == json.loads(origpayload.decode('utf8'))
def test_encode_decode():
key1 = bitjws.PrivateKey()
pubkey1 = bitjws.pubkey_to_addr(key1.pubkey.serialize())
key2 = bitjws.PrivateKey()
pubkey2 = bitjws.pubkey_to_addr(key2.pubkey.serialize())
ser = bitjws.multisig_sign_serialize([key1, key2])
headers, payload = bitjws.multisig_validate_deserialize(ser)
rawpayload = json.loads(ser)['payload']
origpayload = bitjws.base64url_decode(rawpayload.encode('utf8'))
keys_found = {pubkey1: False, pubkey2: False}
assert len(headers) == 2
for h in headers:
assert len(h) == 3
assert h['typ'] == 'JWT'
assert h['alg'] == 'CUSTOM-BITCOIN-SIGN'
assert h['kid'] in keys_found
assert keys_found[h['kid']] == False
keys_found[h['kid']] = True
assert all(keys_found.values())
assert isinstance(payload.get('exp', ''), (float, int))
assert payload['aud'] is None
assert len(payload) == 2
assert payload == json.loads(origpayload.decode('utf8'))
def _load_config(self, config):
if ENVCFG in os.environ:
logging.info("Loading config from {}".format(ENVCFG))
#self.config.from_envvar(ENVCFG)
data = json.load(open(os.getenv(ENVCFG)))
self.config.update(**data)
else:
logging.warn("{} not defined".format(ENVCFG))
if isinstance(config, dict):
self.config.update(**config)
if not self.config.get('api_signing_key'):
raise Exception("Invalid config: missing api_signing_key")
# Server key used to sign responses. The client can optionally
# check that the response was signed by a key it knows to belong
# to this server.
self._privkey = bitjws.PrivateKey(
bitjws.wif_to_privkey(self.config['api_signing_key']))
logging.info("Server key address: {}".format(
bitjws.pubkey_to_addr(self._privkey.pubkey.serialize())))
self._cosigner_server = self.config.get('cosigner_server')
if not self._cosigner_server:
logging.warning("cosigner_server not present in config, "
"cosigning will not be available.")
self._dbcfg = self.config.get('api_database')
if not self._dbcfg:
raise Exception("Invalid config: missing api_database")
if 'engine' not in self._dbcfg:
raise Exception("Invalid config for api_databae: missing 'engine'")
def test_user_can_only_get_own_coins():
"""Tests that user cannot get other users' coins throught the server"""
print "creating a new user"
privkey2 = bitjws.PrivateKey()
my_pubkey2 = privkey2.pubkey.serialize()
my_address2 = bitjws.pubkey_to_addr(my_pubkey2)
username2 = str(my_address2)[0:8]
client2 = BitJWSSwaggerClient.from_url(specurl, privkey=privkey2)
luser2 = client2.get_model('User')(username=username2)
user2 = client2.user.addUser(user=luser2).result()
assert user.id != user2.id
print "creating coins for both users"
lcoin = client.get_model('Coin')(metal='ub', mint='uranus')
client.coin.addCoin(coin=lcoin)
lcoin2 = client2.get_model('Coin')(metal='ub', mint='uranus')
client2.coin.addCoin(coin=lcoin2)
print "checking users cannot get each others's coins"
coins = client.coin.findCoin().result()
coins2 = client2.coin.findCoin().result()
def get_others_coins(user, coins):
for c in coins:
if c.user.id != user.id:
return True
return False
assert not get_others_coins(user, coins)
assert not get_others_coins(user2, coins2)
def test_encode_decode():
key = bitjws.PrivateKey()
ser = bitjws.sign_serialize(key)
header, payload = bitjws.validate_deserialize(ser)
rawheader, rawpayload = ser.rsplit('.', 1)[0].split('.')
origheader = bitjws.base64url_decode(rawheader.encode('utf8'))
origpayload = bitjws.base64url_decode(rawpayload.encode('utf8'))
assert header['typ'] == 'JWT'
assert header['alg'] == 'CUSTOM-BITCOIN-SIGN'
assert header['kid'] == bitjws.pubkey_to_addr(key.pubkey.serialize())
assert len(header) == 3
assert header == json.loads(origheader.decode('utf8'))
assert isinstance(payload.get('exp', ''), (float, int))
assert payload['aud'] is None
assert len(payload) == 2
assert payload == json.loads(origpayload.decode('utf8'))
# Assumption: it takes mores than 0 seconds to perform the above
# instructions but less than 1 second. 3600 is the default
# expiration time.
diff = 3600 - (payload['exp'] - time.time())
assert diff > 0 and diff < 1
def test_encode_decode():
key = bitjws.PrivateKey()
ser = bitjws.sign_serialize(key)
header, payload = bitjws.validate_deserialize(ser)
rawheader, rawpayload = ser.rsplit('.', 1)[0].split('.')
origheader = bitjws.base64url_decode(rawheader.encode('utf8'))
origpayload = bitjws.base64url_decode(rawpayload.encode('utf8'))
assert header['typ'] == 'JWT'
assert header['alg'] == 'CUSTOM-BITCOIN-SIGN'
assert header['kid'] == bitjws.pubkey_to_addr(key.pubkey.serialize())
assert len(header) == 3
assert header == json.loads(origheader.decode('utf8'))
assert isinstance(payload.get('exp', ''), (float, int))
assert payload['aud'] is None
assert len(payload) == 2
assert payload == json.loads(origpayload.decode('utf8'))
# Assumption: it takes mores than 0 seconds to perform the above
# instructions but less than 1 second. 3600 is the default
# expiration time.
diff = 3600 - (payload['exp'] - time.time())
assert diff > 0 and diff < 1
def test_register_user():
# register a new user
privkey2 = bitjws.PrivateKey()
my_pubkey2 = privkey2.pubkey.serialize()
my_address2 = bitjws.pubkey_to_addr(my_pubkey2)
username2 = str(my_address2)[0:8]
client2 = BitJWSSwaggerClient.from_url(specurl, privkey=privkey2)
luser2 = client2.get_model("User")(username=username2)
user2 = client2.user.addUser(user=luser2).result()
assert hasattr(user2, "id")
def test_register_user():
# register a new user
privkey2 = bitjws.PrivateKey()
my_pubkey2 = privkey2.pubkey.serialize()
my_address2 = bitjws.pubkey_to_addr(my_pubkey2)
username2 = str(my_address2)[0:8]
client2 = BitJWSSwaggerClient.from_url(specurl, privkey=privkey2)
luser2 = client2.get_model('User')(username=username2)
user2 = client2.user.addUser(user=luser2).result()
assert hasattr(user2, 'id')
def test_echo_request():
privkey = bitjws.PrivateKey()
pubkey = bitjws.pubkey_to_addr(privkey.pubkey.serialize())
echo_msg = {'hello': 'server'}
data = bitjws.sign_serialize(privkey, data=echo_msg, iat=time.time(), requrl="/echo")
fbj = FlaskBitjws(server.app)
app = server.app.test_client()
udata = json.dumps({'username': pubkey[0:8], 'kid': pubkey})
user = app.post('/user', data=udata)
echo = app.post('/echo', data=data, headers={'Content-Type': 'application/jose'})
h, p = bitjws.validate_deserialize(echo.get_data().decode('utf8'), requrl='/response')
assert 'alg' in h
assert h['alg'] == 'CUSTOM-BITCOIN-SIGN'
assert 'typ' in h
assert 'kid' in h
assert 'data' in p
assert p['data'] == echo_msg
def __init__(self, app, privkey=None,
loginmanager=None,
get_last_nonce=get_last_nonce,
get_user_by_key=get_user_by_key,
basepath=""):
"""
Initialize a flask-bitjws Application with optional LoginManager.
If you do not provide your own LoginManager one will be created.
Create or set the private key to use with this application.
:param str app: The flask application
:param str privkey: the bitjws private key to use for signing responses
:param flask.ext.login.LoginManager loginmanager: An optional LoginManager
:param function get_last_nonce: A function to overwrite this class's stub.
:param function get_user_by_key: A function to overwrite this class's stub.
:param str basepath: The public basepath this app is deployed on.
(only preceding slash required i.e. '/path')
"""
if privkey is not None and isinstance(privkey, str):
self._privkey = bitjws.PrivateKey(bitjws.wif_to_privkey(privkey))
elif privkey is not None and isinstance(privkey, bitjws.PrivateKey):
self._privkey = privkey
else:
self._privkey = bitjws.PrivateKey()
self.pubkey = bitjws.pubkey_to_addr(self._privkey.pubkey.serialize())
if loginmanager is None:
loginmanager = login.LoginManager()
loginmanager.anonymous_user = login.AnonymousUserMixin
loginmanager.init_app(app)
loginmanager.request_loader(load_user_from_request)
self.get_last_nonce = get_last_nonce
self.get_user_by_key = get_user_by_key
self.basepath = basepath
app.bitjws = self
def create_user():
privkey = bitjws.PrivateKey()
my_pubkey = privkey.pubkey.serialize()
my_address = bitjws.pubkey_to_addr(my_pubkey)
username = str(my_address)[0:8]
user = um.User(username=username)
ses.add(user)
try:
ses.commit()
except Exception as ie:
print ie
ses.rollback()
ses.flush()
userkey = um.UserKey(key=my_address, keytype='public', user_id=user.id,
last_nonce=0)
ses.add(userkey)
ses.add(wm.Balance(total=0, available=0, currency=CURRENCY, reference='open account', user_id=user.id))
try:
ses.commit()
except Exception as ie:
print ie
ses.rollback()
ses.flush()
return user
# Install requirements: pip install flask flask-login
import flask
from flask.ext import login
import bitjws
# Server key used to sign responses. The client can optionally
# check that the response was signed by a key it knows to belong
# to this server.
privkey = bitjws.PrivateKey()
print("Server WIF key: {}".format(bitjws.privkey_to_wif(privkey.private_key)))
print("Server key address: {}".format(
bitjws.pubkey_to_addr(privkey.pubkey.serialize())))
# Setup flask app with flask-login.
app = flask.Flask(__name__)
login_manager = login.LoginManager()
login_manager.init_app(app)
# Dummy User.
class User(login.UserMixin):
def __init__(self, address):
self.id = address
# Custom request authentication based on bitjws.
@login_manager.request_loader
def load_user_from_request(request):
header, payload = bitjws.validate_deserialize(request.data.decode('utf8'))
if header is None:
# Validation failed.
import os
import pytest
import time
from bravado_bitjws.client import BitJWSSwaggerClient
from desw import CFG, ses, eng, models
from desw.plugin import internal_credit, internal_address, internal_confirm_credit
from bravado.swagger_model import load_file
host = "0.0.0.0"
url = "http://0.0.0.0:8002/"
specurl = os.path.abspath('../desw/desw/static/swagger.json')
privkey = bitjws.PrivateKey()
my_pubkey = privkey.pubkey.serialize()
my_address = bitjws.pubkey_to_addr(my_pubkey)
username = str(my_address)[0:8]
client = BitJWSSwaggerClient.from_spec(load_file(specurl), origin_url=url)
luser = client.get_model('User')(username=username)
user = client.user.addUser(user=luser).result().user
privkey2 = bitjws.PrivateKey()
my_pubkey2 = privkey2.pubkey.serialize()
my_address2 = bitjws.pubkey_to_addr(my_pubkey2)
username2 = str(my_address2)[0:8]
client2 = BitJWSSwaggerClient.from_spec(load_file(specurl), origin_url=url)
luser2 = client2.get_model('User')(username=username2)
user2 = client2.user.addUser(user=luser2).result().user
def test_addresses():
import pytest
import bitjws
from bravado_bitjws.client import BitJWSSwaggerClient
privkey = bitjws.PrivateKey()
my_pubkey = privkey.pubkey.serialize()
my_address = bitjws.pubkey_to_addr(my_pubkey)
host = "0.0.0.0"
url = "http://0.0.0.0:8002/"
specurl = "%sstatic/swagger.json" % url
username = str(my_address)[0:8]
client = BitJWSSwaggerClient.from_url(specurl, privkey=privkey)
luser = client.get_model("User")(username=username)
user = client.user.addUser(user=luser).result()
def test_register_user():
# register a new user
privkey2 = bitjws.PrivateKey()
my_pubkey2 = privkey2.pubkey.serialize()
my_address2 = bitjws.pubkey_to_addr(my_pubkey2)
username2 = str(my_address2)[0:8]
client2 = BitJWSSwaggerClient.from_url(specurl, privkey=privkey2)
luser2 = client2.get_model("User")(username=username2)
import bitjws
from bravado_bitjws.client import BitJWSSwaggerClient
import pika
# Prepend the parent directory to the sys path.
CLIENT_DIR = ".."
if CLIENT_DIR not in sys.path:
sys.path.insert(0, CLIENT_DIR)
import pikaconfig
TEST_URL = os.environ.get('WSOCK_URL', 'ws://localhost:8123/websocket')
privkey = bitjws.PrivateKey()
pubhash = bitjws.pubkey_to_addr(privkey.pubkey.serialize())
url = 'http://0.0.0.0:8002/'
specurl = '%sstatic/swagger.json' % url
try:
bitjws_client = BitJWSSwaggerClient.from_url(specurl,
privkey=privkey, aud='/response')
username = str(pubhash)[0:8]
luser = bitjws_client.get_model('User')(username=username)
user = bitjws_client.user.addUser(user=luser).result()
except:
bitjws_client = None
print "Could not connet to BitJWS server... Continuing without it."
pass
def create_username_address():
privkey = bitjws.PrivateKey()
my_pubkey = privkey.pubkey.serialize()
my_address = bitjws.pubkey_to_addr(my_pubkey)
username = str(my_address)[0:8]
return username, my_address
