class NewSession:
"""Create a session for connecting to repl.it. The session is good because
then one connection to repl.it is needed for all scrapes and not a new
connection per scrape."""
def __init__(self, proxies={}):
# Create new session
self.request_session = requests.Session()
self.proxies = proxies
# Use header that makes it seem less like a bot
self.headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36",
"Accept-Language": "en-US,en;q=0.8",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"}
# repl base is A-Z0-9a-z
repl_it_string = string.ascii_uppercase + string.digits + string.ascii_lowercase
self.repl_it_base = BaseConverter(repl_it_string)
def decode(self, number):
"Decode repl.it code id to a base 10 number"
return int(self.repl_it_base.decode(number))
def encode(self, number):
"Encode base 10 number to repl.it code id"
return self.repl_it_base.encode(number)
def get_repl_save(self, code_id):
"Save repl.it by code id"
repl_html = self.get_repl_it_html(code_id)
return self.get_data_from_html(repl_html, code_id)
def get_repl_it_html(self, code_id):
"Get html for code id"
url = 'https://repl.it/{}'.format(code_id)
return self.request_session.get(url, proxies=self.proxies, headers=self.headers).text
def get_data_from_html(self, repl_html, code_id):
"Get all data from the html"
# All the data we need is in the HTML
soup = BeautifulSoup(repl_html, 'html.parser')
try:
editor_data = [x.text for x in soup.findAll('script') if 'REPLIT_DATA' in x.text][0]
except IndexError:
data = {}
data['session_id'] = code_id
for x in ['language', 'time_created',
'time_updated', 'owner', 'title', 'editor_text']:
data[x] = '404'
return data
editor_data_json = re.findall('{.*}', editor_data)[0]
data = json.loads(editor_data_json)
del data['console_dump'] # Not needed
# String is HTML escaped so we need to unescape it
data['editor_text'] = html.unescape(data['editor_text'])
return data
def __init__(self, proxies={}):
# Create new session
self.request_session = requests.Session()
self.proxies = proxies
# Use header that makes it seem less like a bot
self.headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36",
"Accept-Language": "en-US,en;q=0.8",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"}
# repl base is A-Z0-9a-z
repl_it_string = string.ascii_uppercase + string.digits + string.ascii_lowercase
self.repl_it_base = BaseConverter(repl_it_string)
def get_uid():
interfaces = netifaces.interfaces()
interfaces.sort()
i = interfaces[0]
s = "abcdefghijklmnopqrstuvwxyz"
u = "ABCDEFGHJKLMNPQRSTUVWXYZ"
d = "0123456789"
bc = BaseConverter(d+s+u)
hashid = hashlib.sha1(i.encode("utf-8")).hexdigest()
hashid = hashid.upper()
raw = base16.decode(hashid)
uid = bc.encode(raw)
return uid
class IdConverter(object):
"""
Generates an id based on an integer.
Essentially it's a small hashing algorithm that allows us to
give unique ids that aren't too long.
"""
def __init__(
self,
state: int = 0,
prefix: str = "",
length: int = 4,
alphabet: str = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ',
) -> None:
"""
"""
self.state = state
self.prefix = prefix
self.length = length
self.alphabet = alphabet
from baseconv import BaseConverter
self.converter = BaseConverter(alphabet)
return
def encode(self, number: int) -> str:
"""
"""
template = "{pre}{{p:{first}>{length}}}".format(
pre=self.prefix,
first=self.converter.digits[0],
length=self.length,
)
return template.format(p=self.converter.encode(number))
def decode(self, pattern: str) -> int:
"""
"""
pattern = pattern[len(self.prefix):]
return int(self.converter.decode(pattern))
def __next__(self):
string = self.encode(self.state)
self.state += 1
return string
def __iter__(self):
return self
def __init__(
self,
state: int = 0,
prefix: str = "",
length: int = 4,
alphabet: str = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ',
) -> None:
""" Create a new id converter with a given state and alphabet. """
self.state = state
self.prefix = prefix
self.length = length
self.alphabet = alphabet
from baseconv import BaseConverter
self.converter = BaseConverter(alphabet)
return
def find_prime(f, base, res):
conv = BaseConverter(('').join(map(str, [tmp for tmp in range(0, base)])))
f = int(conv.decode(f))
if base == 10:
factor = get_prime_factor(f)
if factor:
res.append(factor)
return True
else:
return False
factor = get_prime_factor(f)
if factor:
res.append(factor)
return find_prime(conv.encode(f), base + 1, res)
else:
return False
def is_jam_coin(f, base, primes, res):
conv = BaseConverter(('').join(map(str, [tmp for tmp in range(0, base)])))
f = int(conv.decode(f))
if base == 10:
factor = find_prime_fact(f, primes)
if factor:
res.append(factor)
return True
else:
return False
factor = find_prime_fact(f, primes)
if factor:
res.append(factor)
return is_jam_coin(conv.encode(f), base + 1, primes, res)
else:
return False
def is_jam_coin(f, base, primes, res):
conv = BaseConverter(('').join(map(str, [ tmp for tmp in range(0, base) ])))
f = int(conv.decode(f))
if base == 10:
factor = find_prime_fact(f, primes)
if factor:
res.append(factor)
return True
else:
return False
factor = find_prime_fact(f, primes)
if factor:
res.append(factor)
return is_jam_coin(conv.encode(f), base+1, primes, res)
else:
return False
def generate_RSA():
fh = open('/etc/eko/prikey.pickle', 'wb')
p = pickle.Pickler(fh)
key = RSA.generate(512, os.urandom)
p.dump(key)
fh.close()
baseconv = BaseConverter('0123456789abcdef')
fh2 = open('/etc/eko/pubkey.text', 'w')
fh2.write('Public Key e Parameter\n')
fh2.write(baseconv.from_decimal(key.publickey().e))
fh2.write('\nPublic key n Parameter\n')
fh2.write(baseconv.from_decimal(key.publickey().n))
fh2.close()
print "New Key Generated!"
print "-"*20
print "pubkey.e : %s" % key.publickey().e
print ""
print "pubkey.n : %s" % key.publickey().n
print "-"*20
return key
class NumSystemConvertor(object):
crypto_chars = ('abcdefghkmnpqrstwxyz' 'ABCDEFGHKMNPQRSTWXYZ' '23456789')
engine = BaseConverter(crypto_chars)
@classmethod
def encode(cls, dec_num):
return cls.engine.encode(dec_num)
@classmethod
def decode(cls, val):
return cls.engine.decode(val)
def main():
for t in range(int(input())):
print('Case #%d:' % (t + 1))
n, j = map(int, input().split(' '))
#print(('').join(map(str, [ tmp for tmp in range(0, x) ])))
#conv = BaseConverter(('').join(map(str, [ tmp for tmp in range(0, x) ])))
#s = ('%s1' % (('').join(map(str, [0 for tmp in range(0, n-2)]))))
b2 = BaseConverter('01')
f = b2.encode(pow(2, n - 1) + 1)
f = pow(2, n - 1) + 1
found = 0
while found < j:
res = []
if find_prime(b2.encode(f), 2, res):
print('%s %d %d %d %d %d %d %d %d %d' %
(b2.encode(f), res[0], res[1], res[2], res[3], res[4],
res[5], res[6], res[7], res[8]))
found += 1
f += 2
def main():
for t in range(int(input())):
print('Case #%d:' % (t + 1))
n, j = map(int, input().split(' '))
#print(('').join(map(str, [ tmp for tmp in range(0, x) ])))
#conv = BaseConverter(('').join(map(str, [ tmp for tmp in range(0, x) ])))
#s = ('%s1' % (('').join(map(str, [0 for tmp in range(0, n-2)]))))
b2 = BaseConverter('01')
f = b2.encode(pow(2, n-1) + 1)
f = pow(2, n-1) + 1
found = 0
primes = prime_list(1000)
while found < j:
res = []
if is_jam_coin(b2.encode(f), 2, primes, res):
print('%s %d %d %d %d %d %d %d %d %d' % (b2.encode(f), res[0], res[1], res[2], res[3], res[4], res[5], res[6], res[7], res[8]))
found += 1
f += 2
def send_heartbeat(url, key):
json_msg = {}
json_msg['method'] = 'heartbeat'
json_msg['id'] = 4
params = {}
params['kiosk-id'] = DIEID
if UPTIME < 60:
# under a minute
uptimestr = "%.2f seconds" % UPTIME
elif UPTIME < 60*60:
# under a hour
uptimestr = "%.2f minutes" % (UPTIME/(60.0))
elif UPTIME < 60*60*24*3:
# under 3 days
uptimestr = "%.2f hours" % (UPTIME/(60.0*60.0))
else:
# over 3 days
uptimestr = "%.2f days" % (UPTIME/(60.0*60.0*24.0))
params['uptime'] = uptimestr
params['sw-version'] = '1.0.0'
params['time'] = datetime.utcnow()
json_msg['params'] = params
jsstr = json.dumps(json_msg)
hash = MD5.new(jsstr).digest()
baseconverter = BaseConverter('0123456789abcdef')
sign_16encode = baseconverter.from_decimal(key.sign(hash, "")[0])
#print "encoded: %s" % sign_16encode
#print "signature: %d" % key.sign(hash, "")[0]
#print "hash: %s" % "".join(["%02x " % ord(x) for x in hash])
headers = {'X-eko-signature': sign_16encode}
print jsstr
#test decoding
x = key.publickey().verify(hash, (baseconverter.to_decimal(sign_16encode),))
req = urllib2.Request(url, jsstr, headers)
response = urllib2.urlopen(req)
the_page = response.read()
print the_page
def get_messages(url, key):
json_msg = {}
json_msg['method'] = 'get_messages'
json_msg['id'] = 4
json_msg['params'] = {'kiosk-id': DIEID}
jsstr = json.dumps(json_msg)
hash = MD5.new(jsstr).digest()
baseconverter = BaseConverter('0123456789abcdef')
sign_16encode = baseconverter.from_decimal(key.sign(hash, "")[0])
#print "encoded: %s" % sign_16encode
#print "signature: %d" % key.sign(hash, "")[0]
#print "hash: %s" % "".join(["%02x " % ord(x) for x in hash])
headers = {'X-eko-signature': sign_16encode}
print jsstr
#test decoding
x = key.publickey().verify(hash, (baseconverter.to_decimal(sign_16encode),))
req = urllib2.Request(url, jsstr, headers)
response = urllib2.urlopen(req)
the_page = response.read()
print the_page
class IdEncoder(object):
_base26 = BaseConverter('1#$MYBKRAVJNLGT95C6S4DU8PXQHIW3E2F7Z')
_base26r = BaseConverter('5GBHX$Z3A1MEQCT#NSYKIR48U7FJ692VPDWL')
@classmethod
def encode(cls, n):
return cls._base26.encode(n)+cls._base26r.encode(n)
@classmethod
def decode(cls, n):
n = n.upper()
m = len(n)/2
try:
id1 = cls._base26.decode(n[:m])
except (IndexError, ValueError):
return
try:
id2 = cls._base26r.decode(n[m:])
except (IndexError, ValueError):
return
if id1 == id2:
return id1
class BoopyBoop():
def __init__(self, words=None, settings=None):
if words == None:
#criteria:
#not abstract, but concrete. must be able to sense it directly
#not about people, but about things that are not people
#about 100 of them: currently 35
self.words = ["pen","pencil","water","air","steam","wind","land","rock","steel","house","cat","school","plant","sun","star","tree","farm","sea","paper","chair","music","river","car","book","room","fish","mountain","horse","wood","bird","dog","song","door","ship","fire","bow","spoon","fork","roof","apple","cloth","wheat","boat","gold","drum","flute","ball","cube","triangle","square","hill","orange","grape","iron","brush","azure","periwinkle","burnet","diamond","goldenrod","maroon","ochre","saffron","pepper","croissant","bearclaw","pie","cake","bag","cookie","donut","quiche","custard","salt","carrot","spinach","broccoli","asparagus","wool","egg","butter","rice","dark","light","hut","shack","castle","pyramid","igloo","salon","ranch","pagoda","abbey","tavern","stadium","factory","bank","manor","stables","vineyard","porch","well","closet","corridor","fireplace","tie","belt","gloves","tea","coffee","soda","macaroni","gyro","almonds","waffles","hamburger","bookcase","mattress","tuba","saxophone","accordion","metronome","banjo","kazoo","dulcimer","viola","harp","oboe","cave","duck","tomato","bananas","lettuce","cabbage","onions","elm","palm","maple","arrow","pickax","doll","balloon","vase","typewriter","desk","chalk","galleon","frigate","gondola","dinghy","canoe","train","buggy","firetruck","harbor","pond","brook","waterfall","sleet","snow","fog"]
print [x for x, y in collections.Counter(self.words).items() if y > 1]
assert len(list(set(self.words))) == len(self.words)
else:
self.words = words
if settings == None:
self.settings = MONGO_OBJ_ID_SETTINGS
else:
self.settings = settings
self.len_words = len(self.words)
self.base_conv = BaseConverter(self.settings["alphabet"])
def id_to_string(self, id_string):
id_num = int(id_string, base=len(self.settings["alphabet"]))
words = []
print "id_to_string id_num: ", id_num
while id_num > 0:
word_idx = id_num % self.len_words
id_num = id_num // self.len_words
print "curr id_num: ", id_num
words.append(self.words[word_idx])
return words
def string_to_id(self, word_arr):
id_num = 0
word_arr.reverse()
for idx, word in enumerate(word_arr):
id_num += self.words.index(word)
print "curr_id_num: ", id_num
if idx < (len(word_arr) - 1):
id_num *= self.len_words
print "string_to_id id_num: ", id_num
return self.base_conv.encode(id_num)
if __name__ == "__main__":
"""
This is a test: use it as an example of usage
"""
boop = BoopyBoop()
boop_res = boop.id_to_string("507f1f77bcf86cd799439011")
print boop_res
print len(boop_res)
print boop.len_words
print boop.string_to_id(boop_res)
import sys
import rethinkdb as r
from . import db
from . import login_manager, bcrypt
from baseconv import BaseConverter
from flask_login import UserMixin
from random import SystemRandom
characters = 'abcdefghkmnpqrstwxyz'
digits = '23456789'
base = characters + characters.upper() + digits
number_converter = BaseConverter(base)
def id_generator():
return SystemRandom().randint(1, sys.maxsize)
def gen_short_id(long_id):
return number_converter.encode(long_id)
def get_long_id(short_id):
return number_converter.decode(short_id)
class DataBase:
def __init__(self, db):
case_end)
print f, '-->', outpath
output = open(os.path.join(cur_dir, outpath), 'w')
break
start = time.time()
# -------------------------------------------------------
from baseconv import BaseConverter
convs = [None, None]
for i in range(2, 11):
s = "".join(str(j) for j in range(i))
print s
convs.append(BaseConverter(s))
def jams(n):
vals = []
for i in range(2, 11):
vals.append(int(convs[i].decode(n)))
return vals
def is_prime(num):
for j in range(2, int(math.sqrt(num) + 1)):
if (num % j) == 0:
return j
return 0
from collections import namedtuple
from baseconv import BaseConverter
from icq.constant import ImageType, VideoType, AudioType
BASE62_ICQ_CONVERTER = BaseConverter(
"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
def decode_file_id(file_id):
type_ = file_id[0]
for t in (ImageType, VideoType, AudioType):
try:
type_ = t(type_)
break
except ValueError:
pass
else:
raise ValueError("Unknown file type '{}'!".format(type_))
cls = type(type_)
width = height = length = None
if cls in (ImageType, VideoType):
width = int(BASE62_ICQ_CONVERTER.decode(file_id[1:3]))
height = int(BASE62_ICQ_CONVERTER.decode(file_id[3:5]))
elif cls is AudioType:
length = int(BASE62_ICQ_CONVERTER.decode(file_id[3:5]))
return namedtuple("DecodedFileID",
("type", "width", "height", "length"))(type_, width,
from random import SystemRandom
from baseconv import BaseConverter
import sys
import re
from peewee import IntegrityError
import os
import json
from datetime import datetime, timedelta
import settings
from database import db, Dump
GOOD_CHARS = 'abcdefghkmnpqrstwxyz'
GOOD_DIGITS = '23456789'
CRYPTO_CHARS = GOOD_CHARS + GOOD_CHARS.upper() + GOOD_DIGITS
NUM_SYSTEM_CONVERTOR = BaseConverter(CRYPTO_CHARS)
APP = Bottle()
TIMEOUT_MAP = {
'm10': timedelta(minutes=10),
'h1': timedelta(hours=1),
'd1': timedelta(days=1),
'd7': timedelta(days=7),
'd30': timedelta(days=30),
}
def create_dump(data, expires):
gen = SystemRandom()
for x in range(10):
new_id = gen.randint(1, sys.maxsize)
try:
def post(self):
logging.debug('Running File Upload Handler')
bconv = BaseConverter('0123456789abcdef')
dieid = self.request.get('kiosk-id')
if not dieid:
self.error(403)
self.response.write('No device id provided.\n')
logger.warn('Device attempted contact without die id from ip %s.' % self.request.remote_addr)
return
logging.info("File upload incoming from kiosk : %s" % dieid)
kiosk = Kiosk.kiosk_from_dieid(dieid)
if not kiosk:
self.error(400)
self.response.write('Kiosk is unregistered on system.\n')
logging.warn('Unregistered kiosk on ip %s with dieid %s.' % (self.request.remote_addr, dieid))
return
logging.debug("Encoded sig: %s." % self.request.headers['X-eko-signature'])
# look for the signature
try:
signature = bconv.to_decimal(self.request.headers['X-eko-signature'])
logging.debug("Decoded sig: %s." % str(signature))
challenge = self.request.headers['X-eko-challenge']
logging.debug("Challenge: %s." % challenge)
# signature should be uuid we sent kiosk signed with the public key
verify = self._verify_client(kiosk, signature, challenge)
except:
logging.exception("Authentication signature not found.\n")
verify = False
# auth failed
if not verify:
logging.error("Kiosk id %s did not pass id check." % dieid)
self.response.write('Unable to verify identity of kiosk.\n')
return
# a uuid that identifies this data packet on the remote device
client_ref = self.request.headers['X-eko-challenge']
if not client_ref:
logging.error("No client reference provided.")
self.response.write('Client Error: No reference provided.')
return
# the type of data being sent (logs, readings, etc...)
type = self.request.get('type')
# version of the client
software_version = self.request.get('software_version')
# manifest
try:
manifest = self.get_uploads(field_name='manifest')[0]
logging.debug("Manifest uploaded, size: %s" % str(manifest.size))
except:
logging.exception("Manifest missing from upload data.")
self.response.write('Manifest Not Found\n')
# payload
try:
payload = self.get_uploads(field_name='payload')[0]
except:
logging.exception("Payload missing from upload data.")
self.response.write('Payload Not Found\n')
sync = SyncSession.get_by_clientref(client_ref)
if not sync:
logging.error("Upload attempt without requesting sync session.")
self.response.write('Upload request improperly handled.')
return
sync.kiosk = kiosk
sync.data_type = type
sync.payload_size = 0
# payload size + manifest size
if payload:
sync.payload_size += payload.size
if manifest:
sync.payload_size += manifest.size
sync.payload = payload
sync.manifest = manifest
sync.software_version = software_version
#sync.client_ip = self.request.remote_addr
sync.end_date = datetime.utcnow()
try:
sync.put()
logging.debug("Sync packet succesfully added to datastore")
self.response.write('Success\n')
except:
logging.exception("Adding sync packet failed.")
self.response.write('Failure\n')
return
from baseconv import BaseConverter
import random
primary_numbers = []
secondary_numbers = []
outputs = []
for i in xrange(25):
ternary_string1 = ""
for j in xrange(random.randint(50, 100)):
ternary_string1 += str(random.randint(0, 2))
ternary_string2 = ""
for j in xrange(random.randint(50, 100)):
ternary_string2 += str(random.randint(0, 2))
base3 = BaseConverter("012")
decimal_string1 = base3.decode(ternary_string1)
decimal_string2 = base3.decode(ternary_string2)
decimal_output = int(decimal_string1) - int(decimal_string2)
ternary_output = base3.encode(str(decimal_output))
input = ternary_string1 + "#" + ternary_string2
expected_output = ternary_output
print "Input:"
print input
print "Expected Output:"
print expected_output
print
from baseconv import BaseConverter
import random
primary_numbers = []
secondary_numbers = []
outputs = []
for i in xrange(25):
ternary_string1 = ""
for j in xrange(random.randint(50, 100)):
ternary_string1 += str(random.randint(0,2))
ternary_string2 = ""
for j in xrange(random.randint(50, 100)):
ternary_string2 += str(random.randint(0,2))
base3 = BaseConverter("012")
decimal_string1 = base3.decode(ternary_string1)
decimal_string2 = base3.decode(ternary_string2)
decimal_output = int(decimal_string1) - int(decimal_string2)
ternary_output = base3.encode(str(decimal_output))
input = ternary_string1 + "#" + ternary_string2
expected_output = ternary_output
print "Input:"
print input
print "Expected Output:"
print expected_output
print
def base6(self, num):
"""Retorna uma representação em base 6 do número em um array"""
n = int(num)
base6 = BaseConverter('012345')
return base6.encode(n)
from baseconv import BaseConverter
x = 0.01
encoder_base = BaseConverter('USD')
filter_ranges = [
{
'range': (-100, -3 * x),
'label': 'D'
},
{
'range': (-3 * x, -2 * x),
'label': 'D'
},
{
'range': (-2 * x, -x),
'label': 'D'
},
{
'range': (-x, x),
'label': 'S'
},
{
'range': (x, 2 * x),
'label': 'U'
},
{
'range': (2 * x, 3 * x),
'label': 'U'
},
{
def _base_converter_init(alphabet):
"""."""
from baseconv import BaseConverter
converter = BaseConverter(alphabet)
return converter
from baseconv import BaseConverter
from Crypto.Hash import MD5
from Crypto.PublicKey import RSA
from datetime import datetime
import time
import pickle
import os
baseconv = BaseConverter('0123456789abcdef')
def load_RSA():
if os.path.isfile('/etc/eko/prikey.pickle'):
fh = open('/etc/eko/prikey.pickle', 'rb')
p = pickle.Unpickler(fh)
key = p.load()
fh.close()
print('*** Found /etc/eko/prikey.pickle ***')
return key
else:
print('*** Generating new key ***')
return generate_RSA()
def generate_RSA():
fh = open('/etc/eko/prikey.pickle', 'wb')
class JSONRPCMethods(object):
"""
.. py:class:: JSONRPCMethods(request)
Contains methods accessible by the JSON RPC.
:param request: The WebOb request object.
"""
def __init__(self, request):
self.request = request
self.bconv = BaseConverter('0123456789abcdef')
def _extract_signature_hdr(self):
"""
.. py:func:: _extract_signature_hdr()
Extracts the signature from the request header and calculates the request hash.
:rtype (hash, (signature,)): A tuple containing the hash and signature.
"""
hash = MD5.new(self.request.body).digest()
try:
signature = self.bconv.to_decimal(self.request.headers['X-eko-signature'])
except KeyError:
logging.critical("Client message did not provide verification signature")
# useful for debugging RSA issues
logging.debug("signature long : %d ::: " % signature)
logging.debug("hdr: %s" % self.request.headers['X-eko-signature'])
logging.debug("hash: %s" % "".join(["%02x " % ord(x) for x in hash]))
return (hash, (signature,))
def _get_public_key(self, kiosk):
"""
.. py:func:: _get_public_key(kiosk)
Returns the public key for this kiosk, either from memcache or the datastore.
:param kiosk: The kiosk object.
:rtype RSAobj: A public key object.
"""
# check memcache
pubkey = memcache.get(kiosk.dieid, namespace='rsa-publickeys')
if pubkey is not None:
return pubkey
else:
# get encoded public key from database
pubkey_n = self.bconv.to_decimal(kiosk.pubkey_n)
pubkey_e = self.bconv.to_decimal(kiosk.pubkey_e)
#create the public key
try:
pubkey = RSA.construct((pubkey_n, pubkey_e))
except:
logging.critical("Could not create public key for kiosk")
return None
if not memcache.add(kiosk.dieid, pubkey, namespace='rsa-publickeys'):
logging.error("Unable to save rsa key to memcache.")
return pubkey
def get_messages(self, method, id, **kwargs):
"""
.. py:func:: get_messages(method, id, **kwargs)
Returns all server messages that are pending for the kiosk.
:param method: The name of the requested json method (should be equal to 'get_messages')
:param id: Unused
:param **kwargs: Keyword arguments to the function. Should have non-unicode keys.
:rtype dict: The response object.
Expects the following in kwargs:
kiosk-id : The unique kiosk identifier
Expects the following headers:
X-eko-signature: RSA signed hash of request body.
"""
dieid = kwargs['kiosk-id']
logging.debug('device with id : %s is requesting incoming messages.' % dieid)
# grab kiosk, internally utilises memcache
kiosk = Kiosk.kiosk_from_dieid(dieid)
if not kiosk:
logging.warn('Unrecognised kiosk attempted to fetch server messages (IP: %s, dieid %s).' % (self.request.remote_addr, dieid))
return self._standard_error_response(method, id, 'Not recognised', 20, 'Kiosk not registered with system.')
logging.info('Receiving message fetch request from kiosk %s at IP %s' % (kiosk.name, self.request.remote_addr))
hash, signature = self._extract_signature_hdr()
if not signature[0]:
# prepare error response
return self._standard_error_response(method, id, 'Signature Absent', 10, 'Verification signature not present.')
pubkey = self._get_public_key(kiosk)
if not pubkey:
return self._standard_error_response(method, id, 'Signature Fail', 11, 'Unable to create public key from config.')
if pubkey and signature[0]:
if pubkey.verify(hash, signature):
#message is authentic
messages = self._get_server_messages(kiosk)
data = {}
data['result'] = messages
data['error'] = None
data['id'] = id
return data
else:
return self._standard_error_response(method, id, 'Signature Incorrect', 12, 'Verification signature failed check.')
def _get_server_messages(self, kiosk):
"""
.. py:func:: _get_server_messages(kiosk)
Returns server messages that haven't yet been downloaded by a kiosk.
:param kiosk: The kiosk object which owns the messages.
"""
messages = kiosk.servermessage_set.filter('retrieved =', False).fetch(10)
response = []
for message in messages:
dict = {}
dict['msg'] = message.message
dict['msg_type'] = message.msg_type
dict['date'] = message.date
message.retrieved = True
message.retrieved_date = datetime.utcnow()
message.put()
response.append(dict)
return response
def _standard_error_response(self, func, id, ename, ecode, edesc):
"""Creates a json object in the format of an error"""
resp = {}
error_dict = {}
error_dict['name'] = ename
error_dict['code'] = ecode
error_dict['message'] = edesc
resp['method'] = func
resp['result'] = None
resp['id'] = id
resp['error'] = error_dict
return resp
def heartbeat(self, method, id, **kwargs):
"""
.. py:func:: heartbeat(method, id, **kwargs)
Registers a kiosks IP address, software version and uptime in the datastore.
:param method: The name of the requested json method (should be equal to 'heartbeat')
:param id: Unused
:param **kwargs: Keyword arguments to the function. Should have non-unicode keys.
:rtype dict: The response object.
Expects the following in kwargs:
kiosk-id : The unique kiosk identifier
uptime: A string representing the time elapsed since the script executed.
sw_version: Version of the datalogger software running on the device.
time: The UTC time on the datalogger.
Expects the following headers:
X-eko-signature: RSA signed hash of request body.
"""
# extract arguments
dieid = kwargs['kiosk-id']
logging.debug('Device with id : %s has a pulse from %s.' % (dieid, self.request.remote_addr))
uptime = kwargs['uptime']
sw_version = kwargs['sw-version']
local_inetadr = kwargs['rwanda-ip']
time = kwargs['time']
# find the kiosk from the kiosk id
kiosk = Kiosk.kiosk_from_dieid(dieid)
if not kiosk:
logging.warn('Unrecognised kiosk attempted %s (IP: %s, sw_version: %s, dieid: %s).' % (method, self.request.remote_addr, sw_version, dieid))
return self._standard_error_response(method, id, 'Not recognised', 20, 'Kiosk not registered with system.')
# log this event
logging.info('Receiving kiosk heartbeat from kiosk %s at IP %s' % (kiosk.name, self.request.remote_addr))
hash, signature = self._extract_signature_hdr()
if not signature[0]:
# prepare error response
return self._standard_error_response(method, id, 'Signature Absent', 10, 'Verification signature not present.')
pubkey = self._get_public_key(kiosk)
if not pubkey:
return self._standard_error_response(method, id, 'Signature Fail', 11, 'Unable to create public key from config.')
if pubkey and signature:
if pubkey.verify(hash, signature):
#message is authentic
self._create_heartbeat(kiosk, uptime, sw_version, time, self.request.remote_addr, local_inetadr)
data = {}
data['result'] = 'Success'
data['error'] = None
data['id'] = id
return data
else:
return self._standard_error_response(method, id, 'Signature Incorrect', 12, 'Verification signature failed check.')
# registers the heartbeat in the data store
def _create_heartbeat(self, kiosk, uptime, sw_version, time, ip, local_inetadr):
"""
.. py:func:: _create_heartbeat(kiosk, uptime, sw_version, time, ip)
Creates a heartbeat record in the datastore.
"""
h = Heartbeat()
h.client_ip = ip
h.client_intip = local_inetadr
h.client_uptime = uptime
h.kiosk = kiosk
h.software_version = sw_version
if isinstance(time, datetime):
h.client_time = time
else:
h.client_time = datetime.utcnow()
logging.warn("Client sent me a non datetime object in the request!")
h.server_time = datetime.utcnow()
oldh = memcache.get(kiosk.dieid, namespace='latest-beats')
# if we have cached a kiosk which has the same IP as this request, just update the cache
if oldh:
if oldh.client_ip != h.client_ip:
# if the IP has changed, add to the db
if not oldh.is_saved():
# old h is the last hb at that address
oldh.put()
h.put()
elif h.bad_skew():
# if the skew is worth noting, add to the db
logging.debug("Commiting to db for bad skew!")
h.put()
else:
# we dont have anything cached, so add anyway
h.put()
memcache.set(kiosk.dieid, h, namespace='latest-beats')
logging.debug("Heartbeat registered from %s@%s" % (kiosk.name, ip))
return
def post_messages(self, method, id, **kwargs):
"""
.. py:func:: post_messages(method, id, **kwargs)
Registers a message from a kiosk in the datastore.
:param method: The name of the requested json method (should be equal to 'post_messages')
:param id: Unused
:param **kwargs: Keyword arguments to the function. Should have non-unicode keys.
:rtype dict: The response object.
Expects the following in kwargs:
kiosk-id : The unique kiosk identifier
message: A text message.
origin: The origin of the message (subsystem).
date: The UTC time on the datalogger that the message originated.
[session-ref] : An optional reference to a upload session.
Expects the following headers:
X-eko-signature: RSA signed hash of request body.
"""
# extract arguments
dieid = kwargs['kiosk-id']
logging.debug('Device with id : %s has a pulse from %s.' % (dieid, self.request.remote_addr))
messages = kwargs['messages']
# find the kiosk from the kiosk id
logging.debug('device with id : %s has a pulse.' % dieid)
kiosk = Kiosk.kiosk_from_dieid(dieid)
if not kiosk:
logging.warn('Unrecognised kiosk attempted %s (IP: %s, dieid: %s).' % (method, self.request.remote_addr, dieid))
return self._standard_error_response(method, id, 'Not recognised', 20, 'Kiosk not registered with system.')
# log this event
logging.info('Receiving %d kiosk messages from kiosk %s at IP %s' % (len(messages), kiosk.name, self.request.remote_addr))
hash, signature = self._extract_signature_hdr()
if not signature[0]:
# prepare error response
return self._standard_error_response(method, id, 'Signature Absent', 10, 'Verification signature not present.')
pubkey = self._get_public_key(kiosk)
if not pubkey:
return self._standard_error_response(method, id, 'Signature Fail', 11, 'Unable to create public key from config.')
if pubkey and signature:
if pubkey.verify(hash, signature):
#message is authentic
for message in messages:
self._create_clientmsg(kiosk, message, self.request.remote_addr)
data = {}
data['result'] = 'Success'
data['error'] = None
data['id'] = id
return data
else:
return self._standard_error_response(method, id, 'Signature Incorrect', 12, 'Verification signature failed check.')
# registers the heartbeat in the data store
def _create_clientmsg(self, kiosk, message, ip):
"""
.. py:func:: _create_clientmsg(kiosk, message)
Creates a kisok message record in the datastore.
"""
h = KioskMessage()
h.ip = ip
h.date = datetime.utcnow()
h.kiosk = kiosk
if 'session-ref' in message.keys():
session_uuid = message['session-ref']
else:
session_uuid = None
if 'message' in message.keys():
if message['message'] is not None:
h.message = message['message']
else:
logging.error("No message in kiosk msg from %s" % kiosk.dieid)
if 'origin' in message.keys():
if message['origin'] is not None:
h.origin = message['origin']
else:
logging.error("No origin for kiosk msg from %s" % kiosk.dieid)
if 'origin-date' in message.keys():
if message['origin-date'] is not None:
if isinstance(message['origin-date'], datetime):
h.origin_date = message['origin-date']
else:
try:
h.origin_date = datetime.strptime(message['origin-date'], '%Y-%m-%dT%H:%M:%S')
except ValueError:
logging.exception("Cannot treat %s as datetime." % message['origin-date'])
else:
logging.error("No origin date for kiosk msg from %s" % kiosk.dieid)
if session_uuid is not None:
sess = db.GqlQuery("SELECT __key__ FROM SyncSession WHERE client_ref = :1", session_uuid).get()
if sess:
h.session_ref = sess
h.put()
logging.info("Kiosk Message registered from %s@%s" % (kiosk.name, ip))
return
from baseconv import BaseConverter
string =['2d', '33', '2g', '1i', '2c', '31', '4f', '20', '1p', '3e', '1o',
'3n', '3e', '1l', '3e', '3i', '1p', '46', '1p', '40', '3n', '1l', '3e', '1p',
'45', '49', '1m', '3e', '1o', '3n', '3e', '3h', '3g', '47', '3k', '3e', '1n',
'21', '4h'];
full = '0123456789abcdefghijklmnopqrstuvxwyz'
size = len(full)
zero = 0
for i in string:
if ord(i[1]) > zero:
zero = ord(i[1])
for i in range((full.find(chr(zero)) + 1), size):
base = BaseConverter(full[0:i])
result = []
for j in string:
result.append(int(base.decode(j)))
text = ''.join(chr(c) for c in result)
print text
def __init__(self, request):
self.request = request
self.bconv = BaseConverter('0123456789abcdef')
from baseconv import BaseConverter, BASE16_ALPHABET
from uuid import UUID, uuid4
BASE = 16
HEX_DOUBLE_WORD_LENGTH = 8
HEX_DOUBLE_WORD_UPPER_BYTE = slice(-HEX_DOUBLE_WORD_LENGTH,
-(HEX_DOUBLE_WORD_LENGTH - 2))
MAX_DOUBLE_WORD = (1 << 31)
OLD_BIT_FLAG = 0x80
NEW_BIT_FLAG_MASK = OLD_BIT_FLAG - 1
BASE16 = BaseConverter(BASE16_ALPHABET.lower())
class UUIDGenerator():
uuid = None
def __init__(self):
while True:
uuid = uuid4()
replacer = BASE16.encode(
int(BASE16.decode(str(uuid)[HEX_DOUBLE_WORD_UPPER_BYTE]))
& NEW_BIT_FLAG_MASK)
if int(replacer, BASE) >= 16:
break
self.uuid = UUID(
str(uuid)[:-(HEX_DOUBLE_WORD_LENGTH)] + replacer +
str(uuid)[-(HEX_DOUBLE_WORD_LENGTH - 2):])
@staticmethod
def new_version(uuid):
return not bool(
# https://github.com/semente/python-baseconv
from baseconv import base2, base16, base36, base56, base58, base62, base64, BaseConverter
import pyperclip
import time
# from my img2.py
PROGRAM_NAME = "quickDecode"
PROGRAM_NAME_SHORT = "kwdec"
BAD = "Inconvertable :("
ASCII = ''.join(chr(x) for x in range(256))
ASCII_base = BaseConverter(ASCII, sign='ё') # umlaut e is for failsafe
# https://stackoverflow.com/a/3368991
def find_between(s, first, last):
try:
start = s.index(first) + len(first)
end = s.index(last, start)
return s[start:end]
except ValueError:
return ""
def find_between_r(s, first, last):
try:
start = s.rindex(first) + len(first)
def solve_challenge(challenge):
baseconv = BaseConverter('0123456789abcdef')
key = load_RSA()
signature = key.sign(challenge, "")
sig_encoded = baseconv.from_decimal(signature[0])
return sig_encoded
