def _udp_thread(self): """ UDP thread, reads data from the server and handles it. """ while not self.udp_stop: try: data, src = self.sock.recvfrom(1024) #print(data.decode('latin-1')) _token = data[1:3] _type = data[3] if _type == PUSH_ACK: self._log("Push ack") elif _type == PULL_ACK: self._log("Pull ack") elif _type == PULL_RESP: self.dwnb += 1 ack_error = TX_ERR_NONE tx_pk = ujson.loads(data[4:]) if "tmst" in data: tmst = tx_pk["txpk"]["tmst"] t_us = tmst - utime.ticks_cpu() - 15000 if t_us < 0: t_us += 0xFFFFFFFF if t_us < 20000000: self.uplink_alarm = Timer.Alarm( handler=lambda x: self._send_down_link( ubinascii.a2b_base64(tx_pk["txpk"][ "data"]), tx_pk["txpk"]["tmst"] - 50, tx_pk["txpk"]["datr"], int(tx_pk["txpk"]["freq"] * 1000) * 1000), us=t_us) else: ack_error = TX_ERR_TOO_LATE self._log('Downlink timestamp error!, t_us: {}', t_us) else: self.uplink_alarm = Timer.Alarm( handler=lambda x: self._send_down_link_class_c( ubinascii.a2b_base64(tx_pk["txpk"]["data"]), tx_pk["txpk"]["datr"], int(tx_pk["txpk"]["freq"] * 1000) * 1000), us=50) self._ack_pull_rsp(_token, ack_error) self._log("Pull rsp") except usocket.timeout: pass except OSError as ex: if ex.errno != errno.EAGAIN: self._log('UDP recv OSError Exception: {}', ex) except Exception as ex: self._log('UDP recv Exception: {}', ex) # wait before trying to receive again utime.sleep_ms(UDP_THREAD_CYCLE_MS) # we are to close the socket self.sock.close() self.udp_stop = False self._log('UDP thread stopped')
def start(self, boot=True): if not self.sta_if.isconnected(): print('Tentando conectar...', end="") self.sta_if.active(True) i = 0 while i < len(self.config) and not self.sta_if.isconnected(): self.connection( ubinascii.a2b_base64(ubinascii.unhexlify( self.config[i][0])), ubinascii.a2b_base64(ubinascii.unhexlify( self.config[i][1]))) print(".", end="") time.sleep_ms(200) i += 1 if not self.sta_if.isconnected() and boot: self.sta_if.active(False) print('Rede não conectada') d = dnsquery.start() self.connection(d[b's'].decode(), d[b'p'].decode()) if self.sta_if.isconnected(): self.config[self.lconf] = [ ubinascii.hexlify(ubinascii.b2a_base64(d[b's'])[:-1]), ubinascii.hexlify(ubinascii.b2a_base64(d[b'p'])[:-1]) ] f = open('config.json', 'w') f.write(ujson.dumps(self.config)) f.close() machine.reset() else: time.sleep(1) machine.reset() return self.sta_if
def __decrypt_img(self, json_payload): # decrypt key and IV using our RSA private key, then decrypt the image using AES dec_key = a2b_base64( rsa_decrypt(a2b_base64(json_payload['k']), self.private_key)) dec_iv = a2b_base64( rsa_decrypt(a2b_base64(json_payload['i']), self.private_key)) decryptor = aes(dec_key, 2, dec_iv) dec = decryptor.decrypt(a2b_base64(json_payload['d'])) # server uses DEFLATE to keep sizes down return inflate(dec)
def admin(req, resp): if req.method == "POST": if b"Authorization" in req.headers: yield from start_response(resp) yield from resp.awrite(http_head) yield from resp.awrite('{}{}<br>{}'.format(div_cl_header, href_adm_panel, div_end)) collect() #Очищаем RAM yield from req.read_form_data() form = req.form if 'temp' and 'power' in list(form.keys()): setting_update(temph=form['temp'], pwr=form['power']) elif 'work_mode' and 'time_off' and 'time_on' in list(form.keys()): setting_update(timeon=form['time_on'], timeoff=form['time_off'], mod=form['work_mode']) elif 'ntp' and 'time' and 'daylight' and 'date' and 'tzone' in list( form.keys()): update_config(tz=form['tzone'], dts=form['daylight'], rw='w') datetime_update(form['ntp'], form['date'], form['time']) elif 'wifi' and 'ssid' and 'pasw' in list(form.keys()): update_config(mode=form['wifi'], ssid=form['ssid'], pssw=form['pasw'], rw='w') elif 'login' and 'repassw' and 'passw' in list(form.keys()): setroot(form['login'], form['passw']) yield from resp.awrite('{}{}{}'.format(div_cl_info, 'Setting OK!', div_end)) else: if b"Authorization" not in req.headers: yield from resp.awrite( 'HTTP/1.0 401 NA\r\n' 'WWW-Authenticate: Basic realm="Picoweb Realm"\r\n' '\r\n') return auth = req.headers[b"Authorization"].split(None, 1)[1] auth = a2b_base64(auth).decode() username, passwd = auth.split(":", 1) if setpasswd(username.lower(), passwd) == read_write_root(): yield from start_response(resp) yield from resp.awrite(http_head) yield from resp.awrite('{}{}<br>{}'.format(div_cl_header, href_adm_panel, div_end)) yield from resp.awrite(div_cl_admin) yield from resp.awrite('{}<br>'.format(temp_power)) yield from resp.awrite('{}<br>'.format(mode_time)) yield from resp.awrite('{}<br>'.format(date_set)) yield from resp.awrite('{}<br>'.format(wifi_form)) yield from resp.awrite('{}<br>'.format(passw_form)) yield from resp.awrite(div_end) else: yield from start_response(resp) yield from resp.awrite(http_head) yield from resp.awrite('{}{}{}'.format(div_cl_header, span_err_pasw, div_end)) yield from resp.awrite(http_footer) collect() # Очищаем RAM
def on_receive_mqtt(self, topic, message): if topic != "mcer4294967296/data": return # stuff over mqtt will be encrypted try: encrypted = ubinascii.a2b_base64(message) decrypted = self.cipher.decrypt(encrypted) except: return if decrypted.startswith("YOLO::override"): order = decrypted.split("::")[2] if order == "lock": self.lock() elif order == "unlock": self.unlock() self.override = True elif decrypted.startswith("YOLO::unoverride"): self.override = False elif decrypted.startswith("YOLO::dist"): dist = decrypted.split("::")[2] if dist > self.dist_thresh: # if owner is pretty far away, we increase the poll interval # because it won't result in anything anyways. self.lock() self.poll_interval = 30 else: # if owner is coming back home, we don't unlock the door because # maybe he wants to take a cigarette somewhere first. # but we decrease the interval so that we can detect more quickly. self.poll_interval = 5 else: return
def serve(): bme = bme280.BME280(i2c=i2c) # create the onewire object ds = ds18x20.DS18X20(onewire.OneWire(Pin(2))) # the ds18b20 is on GPIO4 # mqtt client client_id = CONFIG['MQTT_CLIENT_ID_PREFIX'] + ubinascii.hexlify( machine.unique_id()).decode('utf-8') password = ubinascii.a2b_base64(CONFIG['MQTT_PASSWORD']) client = MQTTClient(client_id, CONFIG['MQTT_BROKER'], user=CONFIG['MQTT_USER'], password=password, port=CONFIG['MQTT_PORT']) client.connect() print("'%s' is connected to '%s'" % (client_id, CONFIG['MQTT_BROKER'])) while True: temp = bme.temperature hum = bme.humidity pres = bme.pressure temps = ds18b20.read_temperatures(ds) # publish the values client.publish("%s.temp_c" % client_id, temp) client.publish("%s.humidity_rh" % client_id, hum) client.publish("%s.pressure_hpa" % client_id, pres) for serial_nbr, temp in temps.items(): client.publish("%s.%s.temp_c" % (client_id, serial_nbr), '%0.5f' % temp) sleep(300)
def upload(file_name): suc = False with open(file_name, "wb") as f: while True: d = _read_timeout(3) if not d or d[0] != "#": sys.stdout.write("#2") break cnt = int(d[1:3]) if cnt == 0: suc = True break d = _read_timeout(cnt) if d: try: f.write(a2b_base64(d)) except OSError as e: sys.stdout.write("#5") sys.print_exception(e) break else: sys.stdout.write("#1") else: sys.stdout.write("#3") break sys.stdout.write("#0" if suc else "#4")
async def handle_input(self, data, peer): cmd = data.decode('utf-8').strip('\n') if self.connections[peer]['upload']: if cmd == 'done': print('Done upload.') self.connections[peer]['upload'] = False self.connections[peer]['upload_file'].close() self.connections[peer]['upload_file'] = '' elif self.connections[peer]['upload_file'] == '': filename = cmd print('Filename: {}'.format(filename)) if not (filename == 'boot.py' or filename == 'main.py'): print('Opened {}'.format(filename)) self.connections[peer]['upload_file'] = open(filename,'w+') await self.connections[peer]['writer'].awrite('Ok. Begin upload.\n') else: print('Wrote data.') self.connections[peer]['upload_file'].write(a2b_base64(data).decode('utf-8')) elif cmd in self.funcs: await self.funcs[cmd](peer) elif cmd.lower().startswith('simon says'): await self.connections[peer]['writer'].awrite('Simon didn\'t say that.\n') await self.connections[peer]['writer'].drain() elif cmd.lower().startswith('update_led'): self.duty_led = int(cmd.split(' ')[1].strip('\n')) else: await self.connections[peer]['writer'].awrite('Simon says ' + cmd + '\n') await self.connections[peer]['writer'].drain()
def handle_command_send(js): if type(js) is not dict: return None data = js['data'] b = binascii.a2b_base64(data) lora.send(b) return None
def _decodeBase64(self, data): s = data if isinstance(s, str): s = bytes(data, "utf-8") msg = s.replace(b"-", b"+").replace(b"_", b"/") return ubinascii.a2b_base64(msg)
def load_users(self): files = os.listdir() if not self.users_conf_name in files: with open(self.users_conf_name, "w") as f: info = {"users": [], "features": []} f.write(json.dumps(info)) return [], [] with open(self.users_conf_name) as f: conf = f.read() users = [] try: conf = json.loads(conf) features = [] for i, fea in enumerate(conf['features']): fea = ubinascii.a2b_base64(fea) if fea: #TODO: length users.append(conf['users'][i]) features.append(fea) print("decoded feature:", fea) else: print("user {}'s feature not valid".format( conf['users'][i])) except Exception: print("parse config file error") return [], [] return users, features
def parse_transaction(b64_tx, success_callback=None, error_callback=None): # we will go to main afterwards show_main() try: raw = a2b_base64(b64_tx) tx = psbt.PSBT.parse(raw) except: gui.error("Failed at transaction parsing") if error_callback is not None: error_callback("invalid argument") return # blue wallet trick - if the fingerprint is 0 we use our fingerprint for scope in [tx.inputs, tx.outputs]: for el in scope: for der in el.bip32_derivations: if el.bip32_derivations[ der].fingerprint == b'\x00\x00\x00\x00': el.bip32_derivations[ der].fingerprint = keystore.fingerprint try: data = keystore.check_psbt(tx) except Exception as e: gui.error("Problem with the transaction: %r" % e) if error_callback is not None: error_callback("invalid argument") return title = "Spending %u\nfrom %s" % (data["spending"], data["wallet"].name) popups.prompt_tx(title, data, ok=cb_with_args(sign_psbt, wallet=data["wallet"], tx=tx, success_callback=success_callback), cancel=cb_with_args(error_callback, "user cancel"))
def plays(files, display, sx=0, sy=0, qt=0): f = open(files, "rb") inf = f.readline() info = inf.decode() try: x, y, times, fps = json.loads(info) except Exception as e: print("Wrong File") return False ce = time.ticks_ms() for i in range(times * fps): t = time.ticks_ms() c = f.readline() q = ubinascii.a2b_base64(c) showN(q, display, x, y, sx, sy) if i % 10: time.sleep_ms(round(1000 / fps) - time.ticks_ms() + t) else: time.sleep_ms(round(1000 / fps) - time.ticks_ms() + t - qt) rec = time.ticks_ms() - ce print(rec) rex = (times * 1000 - rec) * 10 / (fps * times) print("QT:", rex) display.fill(0) display.show() return 'fin'
def GenerateAzureSasToken(uri, key, expiryTimestamp, policy_name=None): from ubinascii import a2b_base64, b2a_base64 def _quote(s): r = '' for c in str(s): if (c >= 'a' and c <= 'z') or \ (c >= '0' and c <= '9') or \ (c >= 'A' and c <= 'Z') or \ (c in '.-_') : r += c else: r += '%%%02X' % ord(c) return r uri = _quote(uri) sign_key = b'%s\n%d' % (uri, int(expiryTimestamp)) key = a2b_base64(key) hmac = HMACSha256(key, sign_key) signature = _quote(b2a_base64(hmac).decode().strip()) token = 'sr=' + uri + '&' + 'sig=' + signature + '&' + 'se=' + str( expiryTimestamp) if policy_name: token += '&' + 'skn=' + policy_name return 'SharedAccessSignature ' + token
def serve(): bme = bme280.BME280(i2c=i2c) client_id = CONFIG['MQTT_CLIENT_ID_PREFIX'] + ubinascii.hexlify( machine.unique_id()).decode('utf-8') password = ubinascii.a2b_base64(CONFIG['MQTT_PASSWORD']) client = MQTTClient(client_id, CONFIG['MQTT_BROKER'], user=CONFIG['MQTT_USER'], password=password, port=CONFIG['MQTT_PORT']) client.connect() print("'%s' is connected to '%s'" % (client_id, CONFIG['MQTT_BROKER'])) while True: temp = bme.temperature hum = bme.humidity pres = bme.pressure # uncomment for temperature in Fahrenheit #temp = (bme.read_temperature()/100) * (9/5) + 32 #temp = str(round(temp, 2)) + 'F' # publish the values client.publish("%s.temperature_c" % client_id, temp) client.publish("%s.humidity_rh" % client_id, hum) client.publish("%s.pressure_hpa" % client_id, pres) sleep(300)
def auth(req, resp): auth = req.headers.get(b"Authorization") if not auth: log.warning('no auth found') yield from resp.awrite( 'HTTP/1.0 401 NA\r\n' 'WWW-Authenticate: Basic realm="SyncSign Web Realm"\r\n' '\r\n') return auth = auth.split(None, 1)[1] auth = ubinascii.a2b_base64(auth).decode() req.username, req.passwd = auth.split(":", 1) # verify credential try: if req.username == DEFAULT_USERNAME and req.passwd == DEFAULT_PASSWD: yield from func(req, resp) else: log.warning('not match') raise ValueError( 'Invalid configuration, or unauthorized access is prohibited.' ) except Exception as e: # if first run log.exception(e, 'error occured.') yield from picoweb.start_response( resp, content_type="text/html", status="401", headers=None) # 403 cannot continue with a bad password input yield from resp.awrite("Unauthorized access is prohibited.")
def mqtt_boot_subscribe(topic, msg): print(str(topic)) print(msg) global waitConfig try: msgDict = ujson.loads(msg) print(msgDict) # print(initconfig) # if str(topic)==initconfig["board"]["id"]: print("searching for action") if msgDict["msg"]["action"] == "bootstrap": print("Bootstrap") config = ujson.loads(ubinascii.a2b_base64(msgDict["msg"]["value"])) print(config) save_init_file(config) update_boot_wifi() # load_init_file() waitConfig = False if msgDict["msg"]["action"] == "id": print("ID") initconfig["board"]["name"] = msgDict["msg"]["value"] except BaseException as e: print("An exception occurred during boot") import sys sys.print_exception(e) sleep(30) machine.reset()
def decode_value(cls, prevout, text): # base64 decode, xor w/ hash, decode as uint64 xor = pack('<Q', prevout.hash & ((1 << 64) - 1)) val = a2b_base64(text + '=') assert len(val) == 8 val = bytes(i ^ j for i, j in zip(xor, val)) return unpack('<Q', val)[0]
def write(self, payload): if not isinstance(payload, bytes): payload = payload.encode('UTF-8') payload = binascii.a2b_base64(payload) self.hasher.update(payload) self.fd.write(payload) self.bwrite += len(payload) return self.bwrite
def decode(input, output): """Decode a file; input and output are binary files.""" while True: line = input.readline() if not line: break s = binascii.a2b_base64(line) output.write(s)
def decode(input, output): """Decode a file; input and output are binary files.""" while True: line = input.readline() if not line: break s = binascii.a2b_base64(line) output.write(s)
def b64decode(s, altchars=None, validate=False): s = _bytes_from_decode_data(s) if altchars is not None: altchars = _bytes_from_decode_data(altchars) assert len(altchars) == 2, repr(altchars) s = s.translate(bytes.maketrans(altchars, b'+/')) if validate and not re.match(b'^[A-Za-z0-9+/]*={0,2}$', s): raise ubinascii.Error('Non-base64 digit found') return ubinascii.a2b_base64(s)
def fromString(strData): rawText = ubinascii.a2b_base64(strData) tuple = json.loads(rawText) content, target, sender, sendCount, isACK, hasBeenAcced, isSelfInformation = tuple message = Message(content, target, sender, sendCount, isACK, hasBeenAcced, isSelfInformation) return message
def test_vectors(self): jf = 'test-vectors/appendix_a.json' try: testfile = open(jf, 'r') except: print('Error: cannot open ' + jf + '.') raise try: tv = ujson.load(testfile) except: print('Error: cannot load ' + jf + ' using ujson.load().') raise anyerr = False for row in tv: rhex = row.get('hex') if 'decoded' in row: decoded = row['decoded'] if (type(decoded) is float): status = _check_float(row, decoded) else: status = _check(row, decoded) if (status): anyerr = True continue elif 'diagnostic' in row: diag = row['diagnostic'] checkf = _DIAGNOSTIC_TESTS.get(diag) if checkf is not None: status = _check_foo(row, checkf) if (status): anyerr = True continue # variously verbose log of what we're not testing: cbdata = ubinascii.a2b_base64(row['cbor']) try: pd = loads(cbdata) except: if rhex and (rhex in _EXPECT_EXCEPTION): pass else: print('Failed to load hex=' + str(rhex) + ' diag=' + str(row.get('diagnostic') + '.')) pd = '' cd = None print('Skipping hex=' + str(rhex) + ' diag=' + str(row.get('diagnostic')) + ' py=' + str(pd) + ' c=' + str(cd) + '.') testfile.close() assert not anyerr
def _check_foo(row, checkf): anyerr = False cbdata = ubinascii.a2b_base64(row['cbor']) cb = loads(cbdata) if not checkf(cb): anyerr = True print('Expected {0!r} got {1!r}. Failed to decode CBOR {2}.\n'.format( cb, checkf, ubinascii.hexlify(cbdata))) return anyerr
def calc_local_pincode(psbt_sha, hmac_secret): # Given a b64 encoded secret (shared from CC over USB) and the PSBT # being authorized, cook up 6 digits for local PIN code from ubinascii import a2b_base64 key = a2b_base64(hmac_secret) assert len(psbt_sha) == 32 digest = hmac_sha256(key, psbt_sha) num = ustruct.unpack('>I', digest[-4:])[0] & 0x7fffffff return '%06d' % (num % 1000000)
def _check(row, decoded): anyerr = False cbdata = ubinascii.a2b_base64(row['cbor']) cb = loads(cbdata) if cb != decoded: anyerr = True print('Expected {0!r} got {1!r}. Failed to decode CBOR {2}.\n'.format( cb, decoded, ubinascii.hexlify(cbdata))) return anyerr
def fromString(strData): rawText = ubinascii.a2b_base64(strData) tuple = json.loads(rawText) name, mac, mlEID, firmware, clientsConnectedAtMySite = tuple decoration = NetworkNodeDecoration(name, mac, mlEID, firmware, clientsConnectedAtMySite) return decoration
def _compute_key(self, key, payload): try: secret = ubinascii.a2b_base64(key) except: self._logger.info("ERROR: broken base64 secret => `" + key + "`") sys.exit() ret = ubinascii.b2a_base64(hmac(secret, msg=payload.encode( 'utf8'), digestmod=hashlib.sha256).digest()).decode('utf-8') ret = ret[:-1] return ret
def sub_cb(topic, msg): print((topic, msg)) print((msg)) j = msg m = j.decode() o = json.loads(m) t = (o['payload_raw']) print(t) ts = (str(ubinascii.a2b_base64(t).decode())) print(ts) lcd_scrol.mess(ts)
def parse_transaction(b64_tx, success_callback=None, error_callback=None): # we will go to main afterwards show_main() try: raw = a2b_base64(b64_tx) tx = psbt.PSBT.parse(raw) except: gui.error("Failed at transaction parsing") if error_callback is not None: error_callback("invalid argument") return # blue wallet trick - if the fingerprint is 0 we use our fingerprint for scope in [tx.inputs, tx.outputs]: for el in scope: for der in el.bip32_derivations: if el.bip32_derivations[der].fingerprint == b'\x00\x00\x00\x00': el.bip32_derivations[der].fingerprint = keystore.fingerprint try: data = keystore.check_psbt(tx) except Exception as e: gui.error("Problem with the transaction: %r" % e) if error_callback is not None: error_callback("invalid argument") return # check for address gap limit gap_limit = False w = data["wallet"] wallet_key = b"\xfc\xca\x01" + data["wallet"].fingerprint for el in tx.inputs + tx.outputs: if el.bip32_derivations: # full PSBT for der in el.bip32_derivations: drv = el.bip32_derivations[der].derivation if drv[-1] > w.gap_limit + (w.last_chg_idx if drv[-2] else w.last_rcv_idx): gap_limit = True elif wallet_key in el.unknown: # compressed PSBT idxs = el.unknown[wallet_key] chg = int.from_bytes(idxs[0:4], 'little') idx = int.from_bytes(idxs[4:8], 'little') if idx > w.gap_limit + (w.last_chg_idx if chg else w.last_rcv_idx): gap_limit = True if gap_limit: data["warning"] = ("#ff0000 Possible gap limit exceeded with some#\n" "#ff0000 addresses. Your funds may get locked. #\n " "#ff0000 Proceed at your own risk!#") title = "Spending %u\nfrom %s" % (data["spending"], data["wallet"].name) popups.prompt_tx(title, data, ok=cb_with_args(sign_psbt, wallet=data["wallet"], tx=tx, success_callback=success_callback), cancel=cb_with_args(error_callback, "user cancel") )
def _udp_thread(self): """ UDP thread, reads data from the server and handles it. """ while not self.udp_stop: try: data, src = self.sock.recvfrom(1024) _token = data[1:3] _type = data[3] if _type == PUSH_ACK: self._log("Push ack") elif _type == PULL_ACK: self._log("Pull ack") elif _type == PULL_RESP: self.dwnb += 1 ack_error = TX_ERR_NONE tx_pk = ujson.loads(data[4:]) tmst = tx_pk["txpk"]["tmst"] t_us = tmst - utime.ticks_us() - 12500 if t_us < 0: t_us += 0xFFFFFFFF if t_us < 20000000: self.uplink_alarm = Timer.Alarm( handler=lambda x: self._send_down_link( ubinascii.a2b_base64(tx_pk["txpk"]["data"]), tx_pk["txpk"]["tmst"] - 50, tx_pk["txpk"]["datr"], int(tx_pk["txpk"]["freq"] * 1000000) ), us=t_us ) else: ack_error = TX_ERR_TOO_LATE self._log('Downlink timestamp error!, t_us: {}', t_us) self._ack_pull_rsp(_token, ack_error) self._log("Pull rsp") except usocket.timeout: pass except OSError as ex: if ex.errno != errno.EAGAIN: self._log('UDP recv OSError Exception: {}', ex) except Exception as ex: self._log('UDP recv Exception: {}', ex) # wait before trying to receive again utime.sleep_ms(UDP_THREAD_CYCLE_MS) # we are to close the socket self.sock.close() self.udp_stop = False self._log('UDP thread stopped')
def auth(req, resp): auth = req.headers.get(b"Authorization") if not auth: yield from resp.awrite( 'HTTP/1.0 401 NA\r\n' 'WWW-Authenticate: Basic realm="Picoweb Realm"\r\n' '\r\n' ) return auth = auth.split(None, 1)[1] auth = ubinascii.a2b_base64(auth).decode() req.username, req.passwd = auth.split(":", 1) yield from func(req, resp)
def index(req, resp): if b"Authorization" not in req.headers: yield from resp.awrite( 'HTTP/1.0 401 NA\r\n' 'WWW-Authenticate: Basic realm="Picoweb Realm"\r\n' '\r\n' ) return auth = req.headers[b"Authorization"].split(None, 1)[1] auth = ubinascii.a2b_base64(auth).decode() username, passwd = auth.split(":", 1) yield from picoweb.start_response(resp) yield from resp.awrite("You logged in with username: %s, password: %s" % (username, passwd))
def is_authorized(self, authorization): import ubinascii try: tmp = authorization.split() if tmp[0].lower() == "basic": str = ubinascii.a2b_base64(tmp[1].strip().encode()).decode() ra = str.split(':') auth_result = ra[0] == self._config['user'] and ra[1] == self._config['password'] return auth_result, ra[0] else: raise BadRequestException( "Unsupported authorization method: {}".format(tmp[0])) except Exception as e: raise BadRequestException(e)
def b64decode(s, altchars=None, validate=False): """Decode a Base64 encoded byte string. s is the byte string to decode. Optional altchars must be a string of length 2 which specifies the alternative alphabet used instead of the '+' and '/' characters. The decoded string is returned. A binascii.Error is raised if s is incorrectly padded. If validate is False (the default), non-base64-alphabet characters are discarded prior to the padding check. If validate is True, non-base64-alphabet characters in the input result in a binascii.Error. """ s = _bytes_from_decode_data(s) if altchars is not None: altchars = _bytes_from_decode_data(altchars) assert len(altchars) == 2, repr(altchars) s = s.translate(bytes.maketrans(altchars, b'+/')) if validate and not re.match(b'^[A-Za-z0-9+/]*={0,2}$', s): raise binascii.Error('Non-base64 digit found') return binascii.a2b_base64(s)
def getValue(self): # BASE64 decode the data !!!! converted = a2b_base64(self.data['binaryMeterValue']) return converted
def decodebytes(s): """Decode a bytestring of base-64 data into a bytestring.""" if not isinstance(s, bytes_types): raise TypeError("expected bytes, not %s" % s.__class__.__name__) return binascii.a2b_base64(s)
try: import ubinascii as binascii except ImportError: import binascii print(binascii.a2b_base64(b"")) print(binascii.a2b_base64(b"Zg==")) print(binascii.a2b_base64(b"Zm8=")) print(binascii.a2b_base64(b"Zm9v")) print(binascii.a2b_base64(b"Zm9vYg==")) print(binascii.a2b_base64(b"Zm9vYmE=")) print(binascii.a2b_base64(b"Zm9vYmFy")) print(binascii.a2b_base64(b"AAECAwQFBgc=")) print(binascii.a2b_base64(b"CAkKCwwNDg8=")) print(binascii.a2b_base64(b"f4D/")) print(binascii.a2b_base64(b"f4D+")) # convert '+' print(binascii.a2b_base64(b"MTIzNEFCQ0RhYmNk")) try: print(binascii.a2b_base64(b"abc")) except ValueError: print("ValueError") try: print(binascii.a2b_base64(b"abcde=")) except ValueError: print("ValueError") try: print(binascii.a2b_base64(b"ab*d")) except ValueError: print("ValueError")
rtc.ntp_sync('fr.pool.ntp.org') bt = Bluetooth() try: bt.start_scan(-1) except: bt.stop_scan() bt.start_scan(-1) while True: try: adv = bt.get_adv() if adv: data = str(adv.data, "utf-8") data = str(data.split("#")[1][:8], "utf-8") data = ubinascii.a2b_base64(data) temperature = extractTemperature(data) humidity = extractHumidity(data) pressure = extractPressure(data) id = str(ubinascii.hexlify(adv.mac), "utf-8") content = '{"temperature": %s, "humidity": %s, "pressure" : %s, "mac": %s, "timestamp": "%s"}' % ( temperature, humidity, pressure, id, rtc.now()) print(content) sendData.send(host='http://192.168.1.15', port=1338, data=content) pycom.rgbled(0x007f00) # green time.sleep(0.1) pycom.rgbled(0) try: bt.stop_scan() except:
try: try: import ubinascii as binascii except ImportError: import binascii except ImportError: print("SKIP") raise SystemExit print(binascii.a2b_base64(b'')) print(binascii.a2b_base64(b'Zg==')) print(binascii.a2b_base64(b'Zm8=')) print(binascii.a2b_base64(b'Zm9v')) print(binascii.a2b_base64(b'Zm9vYg==')) print(binascii.a2b_base64(b'Zm9vYmE=')) print(binascii.a2b_base64(b'Zm9vYmFy')) print(binascii.a2b_base64(b'AAECAwQFBgc=')) print(binascii.a2b_base64(b'CAkKCwwNDg8=')) print(binascii.a2b_base64(b'f4D/')) print(binascii.a2b_base64(b'f4D+')) # convert '+' print(binascii.a2b_base64(b'MTIzNEFCQ0RhYmNk')) # Ignore invalid characters and pad sequences print(binascii.a2b_base64(b'Zm9v\n')) print(binascii.a2b_base64(b'Zm\x009v\n')) print(binascii.a2b_base64(b'Zm9v==')) print(binascii.a2b_base64(b'Zm9v===')) print(binascii.a2b_base64(b'Zm9v===YmFy')) try: