def recieveData(): sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW) sock.setblocking(False) time0 = time.time() while (time.time() - time0 < RECIEVING_WAIT_TIME): data = sock.recv(16 + struct.calcsize(DATA_FORMAT)) if data: tmp_cipher = AES(NODE_KEY, AES.MODE_CFB, data[:16]) data = tmp_cipher.decrypt(data[16:]) if len(data) == struct.calcsize(DATA_FORMAT): id, node, data_seq, temp, hum, soil = struct.unpack( DATA_FORMAT, data) if id == ID: sendData(temp, hum, soil) msg = struct.pack(DATA_ACK_FORMAT, node, data_seq) IV = getrandbits(128) CIPHER = AES(KEY, AES.MODE_CFB, IV) msg = IV + CIPHER.encrypt(msg) sock.send(msg) else: LOG.warning('Message not mine: {} {} {} {} {}'.format( id, node, data_seq, temp, hum, soil)) elif len(data) == struct.calcsize(SETUP_FORMAT): id, node, data_seq = struct.unpack(SETUP_FORMAT, data) msg = struct.pack(SETUP_ACK_FORMAT, node, ID, data_seq) IV = getrandbits(128) CIPHER = AES(KEY, AES.MODE_CFB, IV) msg = IV + CIPHER.encrypt(msg) sock.send(msg) time.sleep_ms(50)
def crypt(self, data): iv = crypto.getrandbits( 128) # hardware generated random IV (never reuse it) cipher = AES(self.key, AES.MODE_CFB, iv) msg = iv + cipher.encrypt(data) print(msg) return msg
def sendData(data, seq): sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW) sock.settimeout(SETUP_ACK_TIMEOUT) msg = struct.pack(DATA_FORMAT, GATEWAY, ID, seq, data[0], data[1], data[2]) IV = getrandbits(128) CIPHER = AES(KEY, AES.MODE_CFB, IV) msg = IV + CIPHER.encrypt(msg) wait_for_ack = True errors_count = 0 while wait_for_ack and errors_count < DATA_ACK_RETRIES: sock.send(msg) LOG.debug('Data sended: {} as temp, {} as hum, {} as soil hum'.format( data[0], data[1], data[2])) try: ack = sock.recv(16 + struct.calcsize(DATA_ACK_FORMAT)) if len(ack): tmp_cipher = AES(GATEWAY_KEY, AES.MODE_CFB, ack[:16]) ack = tmp_cipher.decrypt(ack[16:]) id, ack_seq = struct.unpack(DATA_ACK_FORMAT, ack) if id == ID and ack_seq == seq: wait_for_ack = False LOG.info('Message sended successfully.') else: LOG.warning('Recieved message not mine: {} {}'.format( id, ack_seq)) except TimeoutError: errors_count += 1 if errors_count == DATA_ACK_RETRIES: LOG.error('Message couldn\'t be sended. Switching off.') sock.close() sys.exit(-1) else: time.sleep(5) time.sleep(2) sock.close()
def getGateway(seq=0): sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW) sock.settimeout(SETUP_ACK_TIMEOUT) msg = struct.pack(SETUP_FORMAT, BROADCAST, ID, seq) IV = getrandbits(128) CIPHER = AES(KEY, AES.MODE_CFB, IV) msg = IV + CIPHER.encrypt(msg) wait_for_ack = True errors_count = 0 while wait_for_ack and errors_count < SETUP_ACK_RETRIES: sock.send(msg) try: ack = sock.recv(16 + struct.calcsize(SETUP_ACK_FORMAT)) if len(ack): tmp_cipher = AES(GATEWAY_KEY, AES.MODE_CFB, ack[:16]) ack = tmp_cipher.decrypt(ack[16:]) id, gateway, ack_seq = struct.unpack(SETUP_ACK_FORMAT, ack) if id == ID and ack_seq == seq: wait_for_ack = False else: LOG.warning('Recieved message not mine: {} {} {}'.format( id, gateway, ack_seq)) except TimeoutError: errors_count += 1 if errors_count == SETUP_ACK_RETRIES: LOG.error('Message couldn\'t be sended. Switching off.') sock.close() sys.exit(-1) else: time.sleep(5) time.sleep(2) sock.close() LOG.info('My gateway is {0}'.format(gateway)) return gateway
def _send_with_session(self, to, session, msg_type, data): print("_send:", to._unit_addr, msg_type, session, to._counter_send, data) if session == None: raise Exception('No session') plain = bytearray() plain.append(to._unit_addr) plain.append(self._unit_addr) plain.append(msg_type) plain.extend(session) plain.extend(struct.pack('>H', to._counter_send)) if data: plain.append(len(data)) plain.extend(data) else: plain.append(0) plain.extend(CRC.crc16(plain)) pads = (16 - (len(plain) % 16)) % 16 plain.extend(pads * '=') print("sending:", plain) iv = crypto.getrandbits(32)[:2] aes = AES(self._crypto_key, AES.MODE_CBC, iv * 8) self._sock.send(self._site_id + iv + aes.encrypt(plain)) to._counter_send = (to._counter_send + 1) % 0x10000 if to._counter_send == 0: print("Reset after counter overflow") to._reset_trial = 0 to._reset_next = time.ticks_ms()
def decrypt(self, data): iv = crypto.getrandbits( 128) # hardware generated random IV (never reuse it) cipher = AES(self.key, AES.MODE_CFB, data[:16]) # on the decryption side original = cipher.decrypt(data[16:]) print(original) return original
def sendData(self, misg): self.s.setblocking(True) iv = crypto.getrandbits( 128) # hardware generated random IV (never reuse it) cipher = AES(self.key, AES.MODE_CFB, iv) msg = iv + cipher.encrypt(misg) self.s.send(msg) self.s.setblocking(False)
def _encrypt(self, id, message): gc.collect() try: iv = crypto.getrandbits(128) cipher = AES(self._module['metrics'][id]['key'].encode('utf-8'), AES.MODE_CFB, iv) return b2a_base64(iv + cipher.encrypt(message.encode('utf-8'))).decode('utf-8') except: print("ERROR encrypting message for metric: " + str(id) + " of sensor " + str(self._module['name']) + ". Cannot proceed!") return None
def random_from_crypto(): platform_info = get_platform_info() if platform_info.vendor == MicroPythonPlatform.Pycom: # https://forum.pycom.io/topic/1378/solved-how-to-get-random-number-in-a-range/6 # https://github.com/micropython/micropython-lib/blob/master/random/random.py import crypto r = crypto.getrandbits(32) else: import urandom r = urandom.getrandbits(32) return ((r[0] << 24) + (r[1] << 16) + (r[2] << 8) + r[3]) / 4294967295.0
def sendData(self,msg,rtc,f): f=open('msg_sent_middle2.txt','a') f.write("{}/{}/{} {}:{}:{} msg {} stats {}\n".format(rtc.now()[2],rtc.now()[1],rtc.now()[0],rtc.now()[3],rtc.now()[4],rtc.now()[5],msg,self.lora.stats())) f.close() self.s.setblocking(True) iv = crypto.getrandbits(128) # hardware generated random IV (never reuse it) cipher = AES(self.key, AES.MODE_CFB, iv) misg_crc=msg+" "+str(self.calculate_crc(msg)) msg = iv + cipher.encrypt(misg_crc) self.s.send(msg) self.s.setblocking(False)
def _reset(self, alarm=None): now = time.ticks_ms() for addr, node in self._nodes.items(): if node._reset_next != None and time.ticks_diff( node._reset_next, now) >= 0: print("_reset", node._unit_addr) node._reset_next = time.ticks_add( now, node._reset_trial * 5000 + (machine.rng() % 5000)) if node._reset_trial < 30: node._reset_trial += 1 self._reset_timeout = Timer.Alarm(self._reset, 5) node._reset_session = crypto.getrandbits(64) self._send_with_session(node, node._reset_session, _MSG_RST_1, None) return Timer.Alarm(self._reset, 2)
def encode(self, data): counter = getrandbits(128) data[self.iv_layer][-1] = counter cipher = AES(self.enc_key, AES.MODE_CTR, None, counter) plaintext = b"" for item in self.enc_attr_generator(data): plaintext += item ciphertext = cipher.encrypt(plaintext) self.update_enc_data(data, ciphertext) return data
def Random(): r = crypto.getrandbits(32) return ((r[0] << 24) + (r[1] << 16) + (r[2] << 8) + r[3]) / 4294967295.0
def _crypt(self, data, key): """Crypt a data with the key, key. add the iv at the beginning of the message""" iv = crypto.getrandbits(128) cipher = AES(key, AES.MODE_CFB, iv) return (iv + cipher.encrypt(data))
################## Start setup (EDIT START HERE) SITE = 'SRCL' key = b'alphaxencryptkeysjtwbutfdchdlcec' # 256 bit (32 bytes) key ################## End setup (EDIT END HERE) import socket, os, pycom, crypto, socket, gc, machine, utime, ubinascii, ustruct from machine import SD, WDT, deepsleep, Pin, Timer from network import LoRa, WLAN from crypto import AES from uModBus.serial import Serial from uModBus.tcp import TCP iv = crypto.getrandbits(128) # hardware generated random IV (never reuse it) gc.enable() wdt = WDT(timeout=4000000) adc = machine.ADC() dac = machine.DAC('P21') # Turn off WiFi to save power w = WLAN() #w.deinit() chrono = Timer.Chrono() chrono.start() volt = adc.channel(pin='P20') dac.write(1)
bt_log.callback(trigger=bt.CHAR_READ_EVENT, handler=bt_log_read) lora_s = socket.socket(socket.AF_LORA, socket.SOCK_RAW) lora_s.setblocking(False) min_free = 512 poll = select.poll() poll.register(uart, select.POLLIN) poll.register(lora_s, select.POLLIN) inline = b"" while True: while log and gc.mem_free() < min_free: cull_log() gc.collect() timeout = crypto.getrandbits(7)[0] & 0x7f readers = poll.poll(timeout) #readers, writers, errors = select.select([uart, lora_s], [], [], ) for reader in readers: if reader[0] is uart: ch = uart.read(1) if ch in b"\r\n": uart.write(b'\r\n') add_new_msg(inline) inline = b"" elif ch in b"\x08\x7f" and inline: uart.write(b'\x08 \x08') inline = inline[:-1] elif ch == b"\x0c": # form feed, clear and dump log uart.write(b'\x1b[2J') # vt100 erase screen for msg in log:
s = socket.socket(socket.AF_LORA, socket.SOCK_RAW) s.setsockopt(socket.SOL_LORA, socket.SO_DR, config.LORA_DR) s.setblocking(False) lpp = cayenneLPP.CayenneLPP(size=100, sock=s) if config.LORA_SEND_INTERVAL < 10: config.LORA_SEND_INTERVAL = 10 config.LORA_SEND_INTERVAL *= 1000 print("Waiting...") for i in range(3): time.sleep_ms(1000) time.sleep_ms( ((crypto.getrandbits(32)[0] << 8) | crypto.getrandbits(32)[0]) % 3000) wdt.feed() try: print("Sending", i) lpp.reset_payload() lpp.add_analog_input(i, channel=99) lpp.send() except OSError as e: print("Send error:", e) time.sleep_ms(1000) thpa_read_ok = exo.thpa.read() sound_val = sound_min = sound_max = sound_avg = exo.sound.read() sound_samples = 1
def random_sleep(max_sleep): arg = "byteorder='big'" t = int.from_bytes(crypto.getrandbits(32), arg) machine.sleep((1+t%max_sleep)*1000, 0) # wake-up at a random time
def generate_msg(): global msg msg = crypto.getrandbits(packet_size*8) while (len(msg) > packet_size): # just correct the rounding msg = msg[:-1]
def random_from_crypto(): # https://forum.pycom.io/topic/1378/solved-how-to-get-random-number-in-a-range/6 # https://github.com/micropython/micropython-lib/blob/master/random/random.py import crypto r = crypto.getrandbits(32) return ((r[0]<<24) + (r[1]<<16) + (r[2]<<8) + r[3]) / 4294967295.0
wlan.deinit() # remove these two lines if you activate OTA pybytes.smart_config(False) # disable provisioning # py = Pytrack() # ANSELC_ADDR = const(0x18E) # py.poke_memory(ANSELC_ADDR, ~(1 << 7)) _LORA_PKG_FORMAT = "!BB%ds" _LORA_RCV_PKG_FORMAT = "!BB%ds" (my_sf, my_bw_index, my_bw_plain, guard, my_slot, packet_size) = (7, 0, 0, 15000, -1, 16) # default values index = 0 S = 1000 active_rx = 0.0 active_tx = 0.0 proc_gw = 4000 # gw default (minimum) processing time (us) (sack_rcv, sack_bytes) = (0, 0) # will be filled later msg = crypto.getrandbits(packet_size*8) # just a random packet while (len(msg) > packet_size): # just correct the rounding msg = msg[:-1] print("Packet size =", len(msg)) (retrans, succeeded, dropped) = (0, 0, 0) freqs = [868100000, 868300000, 868500000, 867100000, 867300000, 867500000, 867700000, 867900000] if (my_bw_index == 0): my_bw = LoRa.BW_125KHZ my_bw_plain = 125 elif (my_bw_index == 1): my_bw = LoRa.BW_250KHZ my_bw_plain = 250 else: my_bw = LoRa.BW_500KHZ my_bw_plain = 500
print("-- starting loop (interval = {} sec)\n".format(interval)) while True: start_time = wake_up() # start timer # reinitialize LTE and reconnect to LTE network try: lte_setup(lte, nb_iot_connection, cfg.get("apn")) except Exception as e: set_led(LED_PURPLE) sys.print_exception(e) ubirch.deinit() lte_shutdown(lte) reset() # get data payload_data = binascii.hexlify(crypto.getrandbits(32)) # create message with timestamp, UUID and data to ensure unique hash message = '{{"ts":{},"id":"{}","data":"{}"}}'.format( start_time, device_uuid, binascii.b2a_base64(payload_data).decode().rstrip('\n')) print("\nmessage: {}\n".format(message)) # generate UPP with the message hash using the automatic hashing functionality of the SIM card try: upp = ubirch.message_chained(device_name, message.encode(), hash_before_sign=True) except Exception as e: set_led(LED_RED) sys.print_exception(e) time.sleep(3)