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