miniroon

miniroon-verify.c (6030B)

---

 #include <errno.h>
 #include <assert.h>
 #include <stdbool.h>
 #include <unistd.h>
 #include <sys/select.h>
 
 // for debug prints
 #include <stdio.h>
 
 #include <skalibs/types.h>
 #include <skalibs/strerr.h>
 #include <skalibs/djbunix.h>
 #include <skalibs/exec.h>
 #include <skalibs/netstring.h>
 #include <skalibs/uint64.h>
 #include <skalibs/stralloc.h>
 #include <skalibs/env.h>
 
 #include "verify_common.h"
 #include "bytebuffer.h"
 #include "netstring.h"
 #include "hmac_sha2_256.h"
 #include "miniroon-header.h"
 #include "caveats.h"
 
 typedef struct miniroon_data_s {
   miniroon_header hdr;
   bytebuffer caveats[MAX_CAVEATS];
   size_t caveat_count;
 } miniroon_data;
 
 /* declarations */
 void miniroon_data_init(miniroon_data *data);
 void process_payload(const bytebuffer payload);
 void validate_and_exec(miniroon_data *data);
 void read_secret(const bytebuffer secret);
 
 #define MINIROON_HMAC_SIZE 32
 //#define MINIROON_HMAC_FUNC(key, msg, out) hmac_b2s_256(key, msg, out)
 #define MINIROON_HMAC_FUNC(key, msg, out) hmac_sha2_256(key, msg, out)
 
 /* definitions */
 
 
 void miniroon_data_init(miniroon_data *data) {
   memset(data, 0, sizeof(miniroon_data));
   // data->env_modif = STRALLOC_ZERO ;
 }
 
 void read_secret(const bytebuffer secret){
   assert(secret.len == MINIROON_HMAC_SIZE);
   size_t bytes_read = 0;
   int secret_fd = openc_readb("secret");
   if (secret_fd < 0) {
     strerr_dief1sys(111, "open(secret)");
   }
   while(bytes_read < secret.len) {
     ssize_t r = read(secret_fd, &secret.data[bytes_read], secret.len - bytes_read);
     switch(r) {
       case 0:
         strerr_dief1x(111, "EOF before full secret was read");
         break;
       case -1:
         if(errno != EINTR) {
           strerr_dief1sys(111, "read() length");
         }
         break;
     }
     bytes_read += r;
   }
   if(close(secret_fd) != 0) {
     strerr_dief1sys(111, "close(secret_fd)");
   }
 }
 
 
 void validate_and_exec(miniroon_data *md) {
   miniroon_caveats_state state;
   miniroon_caveats_state_init(&state);
   // stralloc env_modif;
 
   for(size_t i=0; i < md->caveat_count; i++) {
     dbg_print_bb1("Validate caveat", md->caveats[i]);
     miniroon_caveat_prepare(md->caveats[i], &state);
   }
   for(size_t i=0; i < md->caveat_count; i++) {
     dbg_print_bb1("Validate caveat", md->caveats[i]);
     miniroon_caveat_validate(md->caveats[i], &state);
   }
 
   /* iff everything validated correctly */
   // TODO: pass unused argv from main() ?
   char cmd[] = "./run";
   const char *cmd_argv[2] = {cmd, 0};
   miniroon_caveats_state_exec(&state, cmd_argv);
 }
 
 void process_payload(const bytebuffer payload) {
   miniroon_data md;
   miniroon_data_init(&md);
   netstring_chunk c;
   netstring_chunk_init(&c, payload);
 
   if(!netstring_chunk_next(&c)) {
     strerr_dief1x(111, "Mising miniroon header");
   }
   parse_header(&md.hdr, c.inner);
   // header should be verified by now, we can start hashing
   uint8_t hmac_data[MINIROON_HMAC_SIZE];
   bytebuffer hmac_bb = {hmac_data, MINIROON_HMAC_SIZE};
   read_secret(hmac_bb);
   // dbg_print_bb1("Secret", hmac_bb);
   MINIROON_HMAC_FUNC(hmac_bb, c.inner, hmac_bb);
   // dbg_print_bb1("Signature update", hmac_bb);
 
   if(!netstring_chunk_next(&c)) {
     strerr_dief1x(111, "Mising miniroon body");
   }
   netstring_chunk body;
   netstring_chunk_init(&body, c.inner);
 
   while(netstring_chunk_next(&body)) {
     dbg_print_bb1("Got caveat", body.inner);
     if(md.caveat_count >= MAX_CAVEATS) {
       strerr_dief1x(111, "Too many caveats");
     }
     md.caveats[md.caveat_count++] = body.inner;
     MINIROON_HMAC_FUNC(hmac_bb, body.inner, hmac_bb);
     // dbg_print_bb1("Signature update", hmac_bb);
   }
 
   if(!netstring_chunk_next(&c)) {
     strerr_dief1x(111, "Mising miniroon signature");
   }
   dbg_print_bb1("Got signature", c.inner);
   if(c.inner.len != MINIROON_HMAC_SIZE) {
     strerr_dief1x(111, "Invalid miniroon signature length");
   }
   /* constant time hash compare */
   uint8_t bitdiff = 0;
   for(size_t i=0; i<MINIROON_HMAC_SIZE; i++) {
     bitdiff |= hmac_data[i] ^ c.inner.data[i];
   }
   if(netstring_chunk_next(&c)) {
     strerr_dief1x(111, "Extraneous data in miniroon");
   }
   if(bitdiff) {
     strerr_dief1x(111, "Invalid miniroon signature");
   }
 
   validate_and_exec(&md);
   strerr_dief1x(110, "Internal logic error, should not get here");
 }
 
 void read_payload(int payload_fd, const bytebuffer bb) {
   int flags = fcntl(payload_fd, F_GETFL);
   if(flags == -1) {
     strerr_dief1sys(111, "fcntl(payload_fd) getfd");
   }
   if(fcntl(payload_fd, F_SETFL, flags & ~O_NONBLOCK) < 0) {
     strerr_dief1sys(111, "fcntl(payload_fd) setfd");
   }
 
   ssize_t payload_read = fd_read(payload_fd, bb.data, bb.len);
   if(payload_read < 0 ) {
     strerr_dief1sys(111, "read(payload)");
   }
   if(payload_read != bb.len) {
     strerr_dief1x(111, "could not read whole payload");
   }
 }
 
 bool parse_fd(char const *arg, int *fd) {
   size_t arg_size = strlen(arg);
   return int_scan(arg, fd) == arg_size;
 }
 
 bool parse_size(char const *arg, size_t *size) {
   size_t arg_size = strlen(arg);
   return size_scan(arg, size) == arg_size;
 }
 
 int main (int argc, char const *const *argv)
 {
   if (argc != 3) {
     strerr_dieusage(100, USAGE);
   }
 
   int payload_fd;
   size_t payload_size;
 
   if(!parse_fd(argv[1], &payload_fd)) {
     strerr_dief1x(100, "could not parse payload fd");
   }
 
   if(!parse_size(argv[2], &payload_size)) {
     strerr_dief1x(100, "could not parse payload length");
   }
 
   char payload_data[payload_size];
   bytebuffer payload = {payload_data, payload_size};
   read_payload(payload_fd, payload);
   fd_close(payload_fd);
 
   dbg_print_bb1("Got payload", payload);
   process_payload(payload);
   strerr_dief1x(110, "Internal logic error, should not get here");
   return 110;
 }
 /*
 capability ```
 container/bzr.ccx/123456
 login/tty1/7890
 ```
 - secret
 - execline command
 - env allowlist (re?)
 - max execution count/id (uuidv7?)
 
 ```
 caphdr = [capv0;name;invoke-once]
 c1 = [caphdr;;h1=hmac(secret, caphdr)]
 c2 = [caphdr;[att1];h2=hmac(h1, att1)]
 c3 = [caphdr;[att1;att2];h3=hmac(h2, att2)]
 ```
 */
 
 /*  vim: sts=2 sw=2 et
 */