int iaap_recv_dec_process (int chan, int flags, byte * buf, int len) {// Decrypt & Process 1 received encrypted message
int bytes_written = BIO_write (hu_ssl_rm_bio, buf, len); // Write encrypted to SSL input BIO
if (bytes_written <= 0) {
loge ("BIO_write() bytes_written: %d", bytes_written);
return (-1);
}
if (bytes_written != len)
loge ("BIO_write() len: %d bytes_written: %d chan: %d", len, bytes_written, chan);
else if (ena_log_verbo)
logd ("BIO_write() len: %d bytes_written: %d chan: %d", len, bytes_written, chan);
errno = 0;
int ctr = 0;
int max_tries = 1; // Higher never works
int bytes_read = -1;
while (bytes_read <= 0 && ctr ++ < max_tries) {
bytes_read = SSL_read (hu_ssl_ssl, dec_buf, sizeof (dec_buf)); // Read decrypted to decrypted rx buf
if (bytes_read <= 0) {
loge ("ctr: %d SSL_read() bytes_read: %d errno: %d", ctr, bytes_read, errno);
hu_ssl_ret_log (bytes_read);
ms_sleep (1);
}
//logd ("ctr: %d SSL_read() bytes_read: %d errno: %d", ctr, bytes_read, errno);
}
if (bytes_read <= 0) {
loge ("ctr: %d SSL_read() bytes_read: %d errno: %d", ctr, bytes_read, errno);
hu_ssl_ret_log (bytes_read);
return (-1); // Fatal so return error and de-initialize; Should we be able to recover, if USB data got corrupted ??
}
if (ena_log_verbo)
logd ("ctr: %d SSL_read() bytes_read: %d", ctr, bytes_read);
int rmv = 0;
#ifndef NDEBUG
// if (chan != AA_CH_VID) // If not video...
rmv = hu_aad_dmp ("DR: ", 2, dec_buf, bytes_read); // Dump decrypted AA
#endif
int prot_func_ret = iaap_msg_process (chan, flags, dec_buf, bytes_read); // Process decrypted AA protocol message
return (0);//prot_func_ret);
}
int hu_aap_enc_send (int chan, byte * buf, int len) { // Send encrypted data: type,...
if (iaap_state != hu_STATE_STARTED) {
loge ("CHECK: iaap_state: %d (%s)", iaap_state, state_get (iaap_state));
return (-1);
}
if (ena_log_verbo && ena_log_send) {
#ifndef NDEBUG
hu_aad_dmp ("ES: ", 1, buf, len);
#endif
}
int bytes_written = SSL_write (hu_ssl_ssl, buf, len); // Write plaintext to SSL
if (bytes_written <= 0) {
loge ("SSL_write() bytes_written: %d", bytes_written);
hu_ssl_ret_log (bytes_written);
hu_ssl_inf_log ();
hu_aap_stop ();
return (-1);
}
if (bytes_written != len)
loge ("SSL_write() len: %d bytes_written: %d chan: %d", len, bytes_written, chan);
else if (ena_log_verbo && ena_log_send)
logd ("SSL_write() len: %d bytes_written: %d chan: %d", len, bytes_written, chan);
int bytes_read = BIO_read (hu_ssl_wm_bio, & enc_buf [4], sizeof (enc_buf) - 4); // Read encrypted from SSL BIO to enc_buf
if (bytes_read <= 0) {
loge ("BIO_read() bytes_read: %d", bytes_read);
hu_aap_stop ();
return (-1);
}
if (ena_log_verbo && ena_log_send)
logd ("BIO_read() bytes_read: %d", bytes_read);
int flags = 0x0b; // Flags = First + Last + Encrypted
if (chan != 0 && buf [0] == 0) { // If msg_type = 0 - 255
flags = 0x0f; // Control
//logd ("Setting control");
}
hu_aap_usb_set (chan, flags, -1, enc_buf, bytes_read + 4); // -1 for type so encrypted type position is not overwritten !!
hu_aap_usb_send (enc_buf, bytes_read + 4, iaap_send_tmo); // Send encrypted data to AA Server
return (0);
}
int hu_aap_usb_send (byte * buf, int len, int tmo) { // Send USB data: chan,flags,len,type,...
if (iaap_state != hu_STATE_STARTED && iaap_state != hu_STATE_STARTIN) { // Need to send when starting
loge ("CHECK: iaap_state: %d (%s)", iaap_state, state_get (iaap_state));
return (-1);
}
if (ena_log_verbo && ena_log_send) {
#ifndef NDEBUG
if (buf [1] | 0x08 == 0) // If not encrypted (which was dumped in hu_aap_enc_send()
hu_aad_dmp ("US: ", 1, & buf [4], len - 4);
#endif
}
int ret = hu_usb_send (buf, len, tmo);
if (ret < 0 || ret != len) {
loge ("Error hu_usb_send() error so stop USB & AAP ret: %d len: %d", ret, len);
hu_aap_stop ();
return (-1);
}
if (ena_log_verbo && ena_log_send)
logd ("OK hu_usb_send() ret: %d len: %d", ret, len);
return (ret);
}
int HUServer::hu_aap_unenc_send (int retry,int chan, byte * buf, int len, int overrideTimeout) { // Encrypt data and send: type,...
if (iaap_state != hu_STATE_STARTED && iaap_state != hu_STATE_STARTIN) {
logw ("CHECK: iaap_state: %d (%s)", iaap_state, state_get (iaap_state));
//logw ("chan: %d len: %d buf: %p", chan, len, buf);
//hex_dump (" W/ hu_aap_enc_send: ", 16, buf, len); // Byebye: hu_aap_enc_send: 00000000 00 0f 08 00
return (-1);
}
byte base_flags = 0;
uint16_t message_type = be16toh(*((uint16_t*)buf));
if (chan != AA_CH_CTR && message_type >= 2 && message_type < 0x8000) { // If not control channel and msg_type = 0 - 255 = control type message
base_flags |= HU_FRAME_CONTROL_MESSAGE; // Set Control Flag (On non-control channels, indicates generic/"control type" messages
//logd ("Setting control");
}
logd("Sending hu_aap_unenc_send %i bytes", len);
for (int frag_start = 0; frag_start < len; frag_start += MAX_FRAME_PAYLOAD_SIZE)
{
byte flags = base_flags;
if (frag_start == 0)
{
flags |= HU_FRAME_FIRST_FRAME;
}
int cur_len = MAX_FRAME_PAYLOAD_SIZE;
if ((frag_start + MAX_FRAME_PAYLOAD_SIZE) >= len)
{
flags |= HU_FRAME_LAST_FRAME;
cur_len = len - frag_start;
}
logd("Frame %i : %i bytes",(int)flags, cur_len);
#ifndef NDEBUG
// if (ena_log_verbo && ena_log_aap_send) {
if (log_packet_info) { // && ena_log_aap_send)
char prefix [MAX_FRAME_SIZE] = {0};
snprintf (prefix, sizeof (prefix), "S %d %s %1.1x", chan, chan_get (chan), flags); // "S 1 VID B"
int rmv = hu_aad_dmp (prefix, "HU", chan, flags, &buf[frag_start], cur_len);
}
#endif
enc_buf [0] = (byte) chan; // Encode channel and flags
enc_buf [1] = flags;
*((uint16_t*)&enc_buf[2]) = htobe16(cur_len);
int header_size = 4;
if ((flags & HU_FRAME_FIRST_FRAME) & !(flags & HU_FRAME_LAST_FRAME))
{
//write total len
*((uint32_t*)&enc_buf[header_size]) = htobe32(len);
header_size += 4;
}
memcpy(&enc_buf[header_size], &buf[frag_start], cur_len);
int ret = 0;
return hu_aap_tra_send (retry, enc_buf, cur_len + header_size, overrideTimeout < 0 ? iaap_tra_send_tmo : overrideTimeout); // Send encrypted data to AA Server
}
return (0);
}
int HUServer::hu_aap_enc_send (int retry,int chan, byte * buf, int len, int overrideTimeout) { // Encrypt data and send: type,...
if (iaap_state != hu_STATE_STARTED) {
logw ("CHECK: iaap_state: %d (%s)", iaap_state, state_get (iaap_state));
//logw ("chan: %d len: %d buf: %p", chan, len, buf);
//hex_dump (" W/ hu_aap_enc_send: ", 16, buf, len); // Byebye: hu_aap_enc_send: 00000000 00 0f 08 00
return (-1);
}
byte base_flags = HU_FRAME_ENCRYPTED;
uint16_t message_type = be16toh(*((uint16_t*)buf));
if (chan != AA_CH_CTR && message_type >= 2 && message_type < 0x8000) { // If not control channel and msg_type = 0 - 255 = control type message
base_flags |= HU_FRAME_CONTROL_MESSAGE; // Set Control Flag (On non-control channels, indicates generic/"control type" messages
//logd ("Setting control");
}
for (int frag_start = 0; frag_start < len; frag_start += MAX_FRAME_PAYLOAD_SIZE)
{
byte flags = base_flags;
if (frag_start == 0)
{
flags |= HU_FRAME_FIRST_FRAME;
}
int cur_len = MAX_FRAME_PAYLOAD_SIZE;
if ((frag_start + MAX_FRAME_PAYLOAD_SIZE) >= len)
{
flags |= HU_FRAME_LAST_FRAME;
cur_len = len - frag_start;
}
#ifndef NDEBUG
// if (ena_log_verbo && ena_log_aap_send) {
if (log_packet_info) { // && ena_log_aap_send)
char prefix [MAX_FRAME_SIZE] = {0};
snprintf (prefix, sizeof (prefix), "S %d %s %1.1x", chan, chan_get (chan), flags); // "S 1 VID B"
int rmv = hu_aad_dmp (prefix, "HU", chan, flags, &buf[frag_start], cur_len);
}
#endif
int bytes_written = SSL_write (hu_ssl_ssl, &buf[frag_start], cur_len); // Write plaintext to SSL
if (bytes_written <= 0) {
loge ("SSL_write() bytes_written: %d", bytes_written);
hu_ssl_ret_log (bytes_written);
hu_ssl_inf_log ();
hu_aap_stop ();
return (-1);
}
if (bytes_written != cur_len)
loge ("SSL_write() cur_len: %d bytes_written: %d chan: %d %s", cur_len, bytes_written, chan, chan_get (chan));
else if (ena_log_verbo && ena_log_aap_send)
logd ("SSL_write() cur_len: %d bytes_written: %d chan: %d %s", cur_len, bytes_written, chan, chan_get (chan));
enc_buf [0] = (byte) chan; // Encode channel and flags
enc_buf [1] = flags;
int header_size = 4;
if ((flags & HU_FRAME_FIRST_FRAME) & !(flags & HU_FRAME_LAST_FRAME))
{
//write total len
*((uint32_t*)&enc_buf[header_size]) = htobe32(len);
header_size += 4;
}
int bytes_read = BIO_read (hu_ssl_wm_bio, & enc_buf [header_size], sizeof (enc_buf) - header_size); // Read encrypted from SSL BIO to enc_buf +
if (bytes_read <= 0) {
loge ("BIO_read() bytes_read: %d", bytes_read);
hu_aap_stop ();
return (-1);
}
if (ena_log_verbo && ena_log_aap_send)
logd ("BIO_read() bytes_read: %d", bytes_read);
*((uint16_t*)&enc_buf[2]) = htobe16(bytes_read);
int ret = 0;
ret = hu_aap_tra_send (retry, enc_buf, bytes_read + header_size, overrideTimeout < 0 ? iaap_tra_send_tmo : overrideTimeout); // Send encrypted data to AA Server
if (retry)
return (ret);
}
return (0);
}
