def __init__(self):
bankconfig = OnlineBankConfig()
self.bank_addr = bankconfig.get_parameter("CLIENT", "bank_addr")
self.bank_port = int(bankconfig.get_parameter("CLIENT", "bank_port"))
# bank_stack = bankconfig.get_parameter("CLIENT", "stack", "default")
self.bank_username = bankconfig.get_parameter("CLIENT", "username")
self.certPath = os.path.join(bankconfig.path(), BANK_CERT_FILE_NAME)
self.bank_cert = loadCertFromFile(self.certPath)
self.bank_client = None
def test_basic():
def printPoints(p):
for bp in p:
print(bp)
filename, cert, key = sys.argv[1:]
cert = loadCertFromFile(cert)
key = loadPrivateKeyFromPemFile(key)
passwd = getpass.getpass()
test_start(filename, cert, key, passwd, printPoints)
simulate_shutdown()
test_reload(filename, cert, passwd, printPoints)
def main():
from playground.common.logging import EnablePresetLogging, PRESET_DEBUG
EnablePresetLogging(PRESET_DEBUG)
args = sys.argv[1:]
if len(args) != 4:
print("Incorrect number of arguments (got %s, expected 4)" % len(args))
print(
"USAGE:\n\tpython3 bank_functional1.py [Bank Cert Path] [User Login Name]\n\t\t[Client/Requester Bank Account Name] [Server/Merchant Bank Account Name]"
)
return
bankcert = loadCertFromFile(args[0])
username = args[1]
pw = getpass.getpass("Enter client/requester's bank password: "******"print('this is a test')"
fee = 1
#debugPrint("Creating NullServerWallet")
#serverWallet = NullServerWallet()
debugPrint("Creating PayingServerWallet")
serverWallet = PayingServerWallet(bankcert, merchantaccount)
debugPrint("Creating SimplePayingServerAuth")
serverAuth = SimplePayingServerAuth(fee)
debugPrint("Creating DefaultMobileCodeEngine")
serverEngine = DefaultMobileCodeEngine()
# debugPrint("Creating NullClientWallet")
# clientWallet = NullClientWallet()
debugPrint("Creating PayingClientWallet")
clientWallet = PayingClientWallet(bankstackfactory, username, pw,
payeraccount, merchantaccount)
def serverFactory():
debugPrint("Factory creating MobileCodeServer")
return MobileCodeServer(serverWallet, serverAuth, serverEngine)
debugPrint("Creating MobileCodeClient")
client = MobileCodeClient("default", "localhost", 1, samplecode,
SimplePayingClientAuth(), clientWallet)
coro = playground.getConnector().create_playground_server(serverFactory, 1)
loop = get_event_loop()
server = loop.run_until_complete(coro)
print("Server started")
loop.call_later(0, RunCodeAndPrintResult, client)
loop.run_forever()
import asyncio, sys
import playground
import escape_room_006 as er
from autograder_ex8_packets import AutogradeStartTest, AutogradeTestStatus, AutogradeResultRequest, AutogradeResultResponse
#from gamepacket import GameCommandPacket, GameResponsePacket
from gamepacket import *
import playground.common.logging as pgLog
from playground.network.packet import PacketType
##############################
from CipherUtil import loadCertFromFile
from BankCore import LedgerLineStorage, LedgerLine
from OnlineBank import BankClientProtocol, OnlineBankConfig
import getpass, sys, os
##############################
certPath = os.path.join("bank.cert")
bank_cert = loadCertFromFile(certPath)
bank_addr = '20194.0.0.19000'
bank_port = 777
# Setup logging right away
pgLog.EnablePresetLogging(pgLog.PRESET_VERBOSE)
SERVER_PORT = 3088
AG_IP = '192.168.200.52'
AG_PORT = 19008
def verify(bank_client, receipt_bytes, signature_bytes, dst, amount, memo):
if not bank_client.verify(receipt_bytes, signature_bytes):
raise Exception("Bad receipt. Not correctly signed by bank")
ledger_line = LedgerLineStorage.deserialize(receipt_bytes)
def main():
from OnlineBank import BankClientProtocol, BANK_FIXED_PLAYGROUND_ADDR, BANK_FIXED_PLAYGROUND_PORT
from CipherUtil import loadCertFromFile
#logctx = LoggingContext()
#logctx.nodeId = "parallelTSP_"+myAddr.toString()
# set this up as a configuration option
#logctx.doPacketTracing = True
#playground.playgroundlog.startLogging(logctx)
# Having placeHolders for asyncio
loop = asyncio.get_event_loop()
loop.set_debug(enabled=True)
ptspArgs = {}
#from playground.common.logging import EnablePresetLogging, PRESET_VERBOSE, PRESET_DEBUG
#EnablePresetLogging(PRESET_VERBOSE)
import OnlineBank
OnlineBank.DEBUG = 0
args= sys.argv[1:]
i = 0
for arg in args:
if arg.startswith("-"):
k,v = arg.split("=")
ptspArgs[k]=v
else:
ptspArgs[i] = arg
i+=1
stack = ptspArgs.get("-stack","default")
bankAddress = ptspArgs.get("-bankaddr", BANK_FIXED_PLAYGROUND_ADDR)
bankPort = ptspArgs.get("-bankport", BANK_FIXED_PLAYGROUND_PORT)
tracker = MobileCodeServerTracker()
tracker.startScan()
bankcert = loadCertFromFile(ptspArgs[0])
payeraccount = ptspArgs[2]
username = args[1]
pw = getpass.getpass("Enter bank password for {}: ".format(username))
bankstackfactory = lambda: BankClientProtocol(bankcert, username, pw)
wallet = PayingClientWallet(stack, bankstackfactory, username, pw, payeraccount,
bankAddress, bankPort)
clientAuth = SimplePayingClientAuth()
PTSP = ParallelTSP(tracker, clientAuth, wallet, n=50)
def initShell():
uiFactory = ParallelTSPCLI(PTSP)
uiFactory.registerExitListener(lambda reason: loop.call_later(2.0, loop.stop))
a = AdvancedStdio(uiFactory)
# loop.set_debug(enabled=True)
loop.call_soon(initShell)
# TODO - Will switchAddr be changed to "localhost" ?
# stack can be "default" or user provided stack from ~/.playgroun/connector
#parallelMaster = MobileCodeClient(stack, switchAddr, port, samplecode, NullClientAuth(), NullClientWallet())
#coro = playground.getConnector(stack).create_playground_connection(lambda: TwistedStdioReplacement.StandardIO(ParallelTSPCLI(configOptions, parallelMaster)),switchAddr, port)
#transport, protocol = loop.run_until_complete(coro)
loop.run_forever()
tracker.stopScan()
loop.close()
i = 0
for arg in args:
if arg.startswith("-"):
k, v = arg.split("=")
serverArgs[k] = v
else:
serverArgs[i] = arg
i += 1
bankcertPath = serverArgs[0]
paytoAccount = serverArgs[1]
stack = serverArgs.get("-stack", "default")
port = int(serverArgs.get("-port", "1"))
bankcert = loadCertFromFile(bankcertPath)
#serverWallet = NullServerWallet()
#serverAuth = NullServerAuth()
serverWallet = PayingServerWallet(bankcert, paytoAccount)
serverEngine = DefaultMobileCodeEngine()
serverAuth = SimplePayingServerAuth(paytoAccount,
5) # hardcoded 5 bitpoints per job
serverAuth.traits[serverAuth.CONNECTOR_ATTRIBUTE] = stack
serverAuth.traits[serverAuth.TIMEOUT_ATTRIBUTE] = 600 # 10 minutes.
serverFactory = lambda: MobileCodeServer(serverWallet, serverAuth,
serverEngine)
coro = playground.getConnector(stack).create_playground_server(
serverFactory, port)
loop = get_event_loop()
def main(args):
if args[0] == "create":
cert, key, filename = args[1:4]
cert = loadCertFromFile(cert)
key = loadPrivateKeyFromPemFile(key)
passwd = getpass.getpass("Create mint password: "******"Re-enter mint password: "******"Passwords do not match")
PrintingPress.CreateBankVault(filename, cert, key, passwd)
elif args[0] == "mint":
if len(args) == 1 or args[1].lower() in ["--help", "-h", "help"]:
sys.exit("mint <amount> <cert> <filename> [<output_dir>]\n" +
" amount can be of the form <amount>:<denomination>")
amount, cert, filename = args[1:4]
if len(args) > 4:
outputDir = args[4]
else:
outputDir = None
cert = loadCertFromFile(cert)
if ":" in amount:
amount, denominations = amount.split(":")
else:
denominations = amount
amount = int(amount)
denominations = int(denominations)
passwd = getpass.getpass("Mint password: "******"Minting %d of %d bitpoints" %
((total + denominations), amount))
mint.mintBitPoints(denominations, serializer)
total += denominations
elif args[0] == "info":
filename = args[1]
if len(args) > 2:
sampleSize = args[2]
else:
sampleSize = None
bitpoints = []
with open(filename, "rb") as f:
bitpoints = BitPoint.deserializeAll(f)
print("Deserialized", len(bitpoints), "bitpoints")
if sampleSize == None:
sample = []
elif sampleSize.lower() == "all":
sample = bitpoints
else:
start, stop = sampleSize.split(":")
start = int(start.strip())
stop = int(stop.strip())
sample = bitpoints[start:stop]
for bp in sample:
print(bp)
elif args[0] == "validate":
filename, issuingCert = args[1:3]
bitpoints = []
with open(filename, "rb") as f:
bitpoints = BitPoint.deserializeAll(f)
cert = loadCertFromFile(issuingCert)
verifier = BitPointVerifier(cert)
numValid = 0
for bp in bitpoints:
isValid, reason = verifier.verify(bp)
if isValid:
numValid += 1
else:
print(bp.serialNumber(), "is NOT valid:", reason)
print("Valid bitpoints: %s/%s" % (numValid, len(bitpoints)))
