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)
