def main():
k_m = KeyManager()
um = UTXOManager(k_m.my_address())
i_k_m = KeyManager()
u_k_m = KeyManager()
t1 = CoinbaseTransaction(k_m.my_address())
t2 = CoinbaseTransaction(k_m.my_address())
t3 = CoinbaseTransaction(k_m.my_address())
t4 = Transaction([TransactionInput(t1.to_dict(), 0)], [
TransactionOutput(u_k_m.my_address(), 10.0),
TransactionOutput(i_k_m.my_address(), 20.0)
])
transactions = []
transactions.append(t1.to_dict())
transactions.append(t2.to_dict())
transactions.append(t3.to_dict())
transactions.append(t4.to_dict())
um.extract_utxos(transactions)
balance = um.my_balance
print(balance)
def add_char():
new_key = input('API key: ')
new_vcode = input('Verification Code: ')
api = evelink.api.API(api_key=(new_key, new_vcode))
acc = evelink.account.Account(api)
try:
chars = acc.characters()
number = 0
num2char = {}
for charID in chars.result:
char = chars.result[charID]
print('{id}) {name} ({corp})'.format(id=number,
name=char['name'],
corp=char['corp']['name']))
num2char[number] = charID
number += 1
try:
charNumber = int(input('Select a Character: '))
email = input('Associated email address: ')
name = chars.result[num2char[charNumber]]['name']
km = KeyManager(key_store_path)
km.add(new_key, new_vcode, num2char[charNumber], name, email)
print('Added character {name} successfully'.format(name=name))
except ValueError:
print('wrong input')
exit(2)
except APIError:
exit(1)
print('Authentication failure.')
exit(0)
def accept_minion_key(minion_id):
try:
k = KeyManager()
k.accept_key(minion_id)
except:
raise
return
def auth_user_to_app(self):
keys = KeyManager(self.TWITTER_KEYS)
auth = tweepy.OAuthHandler(keys.CONSUMER_KEY, keys.CONSUMER_SECRET)
print(auth.get_authorization_url())
verifier = input('Verifier:').strip()
token = auth.get_access_token(verifier)
print(token)
def rm_char():
list_char()
try:
rm = int(input('which character should be deleted: '))
km = KeyManager(key_store_path)
km.remove(rm)
except (ValueError, IndexError):
print('wrong input')
exit(2)
def list_char():
km = KeyManager(key_store_path)
num = 0
if len(km.keys) == 0:
print('no keys, add one with the add command')
exit(3)
for key in km.keys:
print('{num}) {name}, API key: {apiK}, email: {email}'.format(
num=num, name=key[3], apiK=key[0], email=key[4]))
num += 1
def acc_autoconf(id, server_address):
"""
Auto configure the arduino ACC-Client.
:param id: Id of the arduino.
:param server_address: Domotics server IP address.
:return: Configured KeyManager.
"""
try:
# generate the http get request for the auto configuration
request = "http://" + server_address + "/acc?autoconf=request&id=" + id
# execute the http get request
response = urlopen(request).read()
# load the http response as json
data = json.loads(response)
# if the json response contains the right parameters
if 'key' in data and 'id' in data and 'server_address' in data:
# create the key manager with the parameters
return KeyManager(id=data['id'], key=data['key'], server_address=data['server_address'])
except:
pass
# if something goes wrong, create the key manager, with the id
return KeyManager(id=id)
def save_my_pem():
self.km = KeyManager()
my_pem = self.km.export_key_pair(p_phrase.get())
my_pem_hex = binascii.hexlify(my_pem).decode('ascii')
# とりあえずファイル名は固定
path = 'my_key_pair.pem'
f1 = open(path, 'a')
f1.write(my_pem_hex)
f1.close()
f.destroy()
self.um = UTXOManager(self.km.my_address())
self.um.my_balance = 0
self.update_balance()
def initApp(self):
"""
ClientCoreとの接続含めて必要な初期化処理はここで実行する
"""
print('SimpleBitcoin client is now activating ...: ')
self.km = KeyManager()
self.um = UTXOManager(self.km.my_address())
# テスト用途（本来はこんな処理しない）
t1 = CoinbaseTransaction(self.km.my_address())
t2 = CoinbaseTransaction(self.km.my_address())
t3 = CoinbaseTransaction(self.km.my_address())
transactions = []
transactions.append(t1.to_dict())
transactions.append(t2.to_dict())
transactions.append(t3.to_dict())
self.um.extract_utxos(transactions)
self.update_balance()
def __init__(self, name, handler=None):
NetworkPart.__init__(self)
self.name = name
self.messageSent = None
self.messageGot = None
self.responseSent = None
self.responseGot = None
self.keyManager = KeyManager()
if handler is None:
self.setCallbackHandler(BasicHandler())
else:
self.setCallbackHandler(handler)
self.associateCallback(Callback.KEY_USER, self.storeKeyUser)
self.associateCallback(Callback.USER_MESSAGE, self.readMessage)
self.associateCallback(Callback.USER_MESSAGE_STATUS,
self.messageStatus)
self.associateCallback(Callback.USER_RESPONSE, self.readResponse)
#print "instance_id: %s" % instance_id
continue
else:
minion_mgr = MinionManager(region)
minion_mgr.create_or_update_minion(instanceid=instance_id, modified=None, highstate_runner=None,
highstate_ran=None, status=unicode(status))
sqs_minion.delete_a_message(message)
print "removed sqs message about minion"
except Exception, e:
print "Error handling minion instances: %s" % e
raise
# Remove terminated minions keys from our salt master
try:
minion_mgr = MinionManager(region)
minions_terminated_list = minion_mgr.get_terminated()
k = KeyManager()
k.delete_keys(minions_terminated_list)
except Exception, e:
raise
time.sleep(POLL_CYCLE)
if __name__ == "__main__":
try:
main()
except Exception, e:
print "Problem occurred. %s" % e
def do_stuff():
global iteration, notify_store
km = KeyManager(key_store_path)
logging.info('starting scan')
s = smtplib.SMTP_SSL(credentials.smtp_server, credentials.smtp_port)
s.ehlo()
s.login(credentials.email_user, credentials.email_password)
logging.info('connected to mail server')
for key in km.keys:
kit = iteration[tuple(key)]
api = evelink.api.API(api_key=(key[0], key[1]))
char = evelink.char.Char(char_id=key[2], api=api)
res = char.notifications()
rec_name = key[3]
receiver = key[4]
new_results = {}
for r in res.result: # filter old notifications
if not notify_store.contains(rec_name, res.result[r]['id']):
new_results[r] = res.result[r]
if len(new_results) == 0:
kit += 1
if kit == 24:
subject = 'No new notifications for {name}'.format(
name=rec_name)
text = 'No new notifications within the last 24 hours for character {name}.'.format(
name=rec_name)
logging.info(
'24 hour check in for char {char}'.format(char=rec_name))
else:
logging.info('nothing new for {char} ({tries}/24)'.format(
char=rec_name, tries=kit))
iteration[tuple(key)] = kit
continue
else:
lines = []
for r in new_results:
noti = new_results[r]
if noti['read'] == 1:
notify_store.remove(rec_name, noti['id'])
continue # was already read in client and should not come again
lines.append('{time}: {type}'.format(
time=datetime.utcfromtimestamp(int(
noti['timestamp'])).isoformat().replace('T', ' '),
type=notificationIDmap.map_id_to_text(noti['type_id'])))
notify_store.add(rec_name, noti['id'])
if len(lines) == 0:
continue # every notification was already read, nothing new
subject = '{nonn} new notification(s) for {name}'.format(
name=rec_name, nonn=len(lines))
logging.info('{subj}'.format(subj=subject))
text = 'Character {name} has the following new notifications: \r\n'.format(
name=rec_name)
text += '\r\n'.join(lines)
iteration[tuple(
key
)] = 0 # reset iteration counter, either 24h have passed or new notifications
msg = '\r\n'.join([
'From: {email}'.format(email='EVE Notifications'),
'To: {recv}'.format(recv=receiver),
'Subject: {sub}'.format(sub=subject), '',
'{text}'.format(text=text)
])
sent = s.sendmail(credentials.email, [receiver], msg)
if len(sent) == 0:
logging.info(
'successfully sent mail to {recv}: {subj} - {text}'.format(
recv=receiver,
subj=subject,
text=text.replace('\r\n', '\\r\\n')))
else:
logging.warning('error with receiver {recv}: {error}'.format(
recv=receiver, error=str(sent)))
s.close()
logging.info('scan done, mail server connection closed')
format='%(asctime)s - %(name)s - %(levelname)s: %(message)s',
filename=args.log,
filemode='w',
level=logging.INFO)
if args.action == 'add':
add_char()
elif args.action == 'list':
list_char()
elif args.action == 'remove':
rm_char()
elif args.action == 'start':
km = KeyManager(key_store_path)
if len(km.keys) == 0:
print('no keys, add one with the add command')
exit(3)
for k in KeyManager(key_store_path).keys:
iteration[tuple(k)] = 0 # init 24 hour counter for every key
notify_store = StorageDictList(notify_store_path)
scheduler = BlockingScheduler(timezone=utc)
scheduler.add_job(do_stuff, 'interval', hours=1)
try:
print('starting scheduler...')
scheduler.start()
except (KeyboardInterrupt, SystemExit):
scheduler.shutdown(wait=False)
print('scheduler stopped')
def print_keys(req_pub_key, req_priv_key, prov_pub_key, prov_priv_key, conc_pub_key):
print('REQUESTOR_PRIVATE_KEY = ', req_priv_key)
print('REQUESTOR_PUBLIC_KEY = ', req_pub_key)
print('')
print('PROVIDER_PRIVATE_KEY = ', prov_priv_key)
print('PROVIDER_PUBLIC_KEY = ', prov_pub_key)
print('')
print('CONCENT_PUBLIC_KEY = ', conc_pub_key)
if __name__ == '__main__':
args = parse_arguments()
cluster_url = "{}/api/v1/{}/".format(args.cluster_url, args.endpoint)
key_manager = KeyManager()
requestor_public_key, requestor_private_key = key_manager.get_requestor_keys()
provider_public_key, provider_private_key = key_manager.get_provider_keys()
concent_public_key = key_manager.get_concent_public_key()
if args.print_keys:
print_keys(
requestor_public_key,
requestor_private_key,
provider_public_key,
provider_private_key,
concent_public_key,
)
message_handler = MessageHandler(
requestor_private_key,
def create_auth(self):
keys = KeyManager(self.TWITTER_KEYS)
auth = tweepy.OAuthHandler(keys.CONSUMER_KEY, keys.CONSUMER_SECRET)
auth.set_access_token(keys.ACCESS_KEY, keys.ACCESS_SECRET)
return auth
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
"""
# Test for pin thread
# -
# @author giuliobosco
# @version 1.0 (2019-04-21 - 2019-04-21)
import sys
sys.path.insert(0, '/usr/lib/python2.7/bridge')
from pin_thread import PinThread
from key_manager import KeyManager
from bridgeclient import BridgeClient
from time import sleep
bridge = BridgeClient()
key_manager = KeyManager('000000000000', '000000001234', '10.8.16.111:8080')
pin_thread = PinThread(key_manager=key_manager, pin='D6', bridge=bridge)
pin_thread.start()
sleep(10)
pin_thread.interrupt()
def __init__(self, b):
NetworkPart.__init__(self)
self.sharedKey = None
self.b = b
self.r = CyclicGroupDualArray(self.b)
s = CyclicGroupDualArray(self.b)
s1 = CyclicGroupDualArray(self.b)
self.S = {'FOR': s, 'RET': s1}
perm = range(0, b)
shuffle(perm)
permInverse = inversePermute(perm)
self.permutation = {'FOR': perm, 'RET': permInverse}
self.e = CyclicGroup.randomPair()
self.mixMessageComponents = {'FOR': None, 'RET': None}
self.preMixCallback = {
'FOR': Callback.PRE_FOR_MIX,
'RET': Callback.PRE_RET_MIX
}
self.realMixCallback = {
'FOR': Callback.REAL_FOR_MIX,
'RET': Callback.REAL_RET_MIX
}
self.mixCommitCallback = {
'FOR': Callback.REAL_FOR_MIX_COMMIT,
'RET': Callback.REAL_RET_MIX_COMMIT
}
self.prePostProcessCallback = {
'FOR': Callback.PRE_FOR_POSTPROCESS,
'RET': Callback.PRE_RET_POSTPROCESS
}
self.realPostProcessCallback = {
'FOR': Callback.REAL_FOR_POSTPROCESS,
'RET': Callback.REAL_RET_POSTPROCESS
}
self.decryptionShare = {'FOR': None, 'RET': None}
self.realMixCommitment = {'FOR': None, 'RET': None}
self.senders = None
self.keyManager = KeyManager()
self.associateCallback(Callback.KEY_SHARE, self.storeSharedKey, 1)
self.associateCallback(Callback.PRE_FOR_MIX, self.preForwardMix, 1)
self.associateCallback(Callback.PRE_FOR_POSTPROCESS,
self.preForwardPostProcess, 1)
self.associateCallback(Callback.PRE_RET_MIX, self.preReturnMix, 1)
self.associateCallback(Callback.PRE_RET_POSTPROCESS,
self.preReturnPostProcess, 1)
self.associateCallback(Callback.KEY_USER, self.sendUserKey)
self.associateCallback(Callback.REAL_FOR_PREPROCESS,
self.realForPreProcess)
self.associateCallback(Callback.REAL_FOR_MIX, self.realForMix)
self.associateCallback(Callback.REAL_FOR_MIX_COMMIT,
self.realForMixCommit)
self.associateCallback(Callback.REAL_RET_MIX, self.realRetMix)
self.associateCallback(Callback.REAL_RET_MIX_COMMIT,
self.realRetMixCommit)
import common.tms_logger as logger
from common.tms_yaml import py2yaml, yaml2py
import storage.tms_storage as storage
from data_tree.tms_data_tree import DataTree
from key_manager import KeyManager
# aesgcm = aes.init("GCM", b"AES256Key-32Characters1234567890")
# cipher_data, nonce = aesgcm.encrypt(b"Hello World")
# logger.info("Result = " + str(aesgcm.decrypt(cipher_data, nonce)))
key = b"AES256Key-32Characters1234567890"
s = storage.init("./kms.db", "crypto", key)
#s.save(b"123456789")
#data = s.load()
#logger.info("read data = " + str(data))
km = KeyManager(s)
#km.add_key('/', 'a1', b'this is my key')
print(km.get_key('/a1'))
