chibipub

ap_json.c (7602B)

---

 #include "ap_json.h"
 #include "inbox.h"
 #include "sha256/sha256.h"
 #include "base64.h"
 
 #include <time.h>
 #include <strings.h>
 
 
 static int handle_ap_string(struct json_handlers *h, struct json_strtok *str)
 {
 	struct ap_json *apjson = (struct ap_json*)h->data;
 	if (str->is_key && str->size == 8
 			&& !memcmp(str->text, "@context", str->size)) {
 		apjson->flags |= AP_IS_CONTEXT;
 	} else if (apjson->flags & AP_IS_CONTEXT) {
 		apjson->flags &= ~AP_IS_CONTEXT;
 	}
 
 	return handle_string(&apjson->compact_handler, str);
 }
 
 static int handle_key(struct ap_json *a, char *key)
 {
 	struct json_strtok str;
 	unsigned int *nop;
 	init_json_strtok(&str);
 
 	str.text = (unsigned char *)key;
 	str.size = strlen(key);
 	str.is_key = 1;
 	if (!handle_string(&a->compact_handler, &str)) {
 		note_error(&a->errs, "push @wsheaders oob");
 		return 0;
 	}
 
 	if (!handle_token(&a->compact_handler, ':', &nop)) {
 		return 0;
 	}
 
 	return 1;
 }
 
 static int handle_kv(struct ap_json *a, char *key, char *val, int escape_val)
 {
 	struct json_strtok str;
 	init_json_strtok(&str);
 
 	if (!handle_key(a, key)) {
 		return 0;
 	}
 
 	str.text = (unsigned char *)val;
 	str.size = strlen(val);
 	str.is_key = 0;
 	str.needs_escape = escape_val;
 	if (!handle_string(&a->compact_handler, &str)) {
 		note_error(&a->errs, "push @wsheaders oob");
 		return 0;
 	}
 
 	return 1;
 }
 
 static int handle_wssig(struct ap_json *a)
 {
 	struct json_strtok sig;
 	init_json_strtok(&sig);
 	unsigned int *nop;
 
 	if (!handle_key(a, "@wssig")) {
 		return 0;
 	}
 
 	sig.text = (unsigned char*)a->sig->b64_sig;
 	sig.size = a->sig->b64_len;
 	sig.is_key = 0;
 	if (!handle_string(&a->compact_handler, &sig)) {
 		note_error(&a->errs, "push @wssig val oob");
 		return 0;
 	}
 
 	if (!handle_token(&a->compact_handler, ',', &nop)) {
 		note_error(&a->errs, "push @ws_sig : tok oob");
 		return 0;
 	}
 
 	return 1;
 }
 
 static int handle_wsstamp(struct ap_json *a)
 {
 	unsigned int *nop;
 	struct json_strtok str;
 	init_json_strtok(&str);
 
 	if (!handle_key(a, "@wsstamp")) {
 		return 0;
 	}
 
 	if (!handle_number(&a->compact_handler, time(NULL))) {
 		note_error(&a->errs, "push @wsstamp oob number");
 		return 0;
 	}
 
 	if (!handle_token(&a->compact_handler, ',', &nop)) {
 		note_error(&a->errs, "push @ws_sig : tok oob");
 		return 0;
 	}
 
 	return 1;
 }
 
 static int handle_wskeyid(struct ap_json *a)
 {
 	unsigned int *nop;
 	struct json_strtok str;
 	init_json_strtok(&str);
 
 	if (!handle_kv(a, "@wskeyid", (char*)a->sig->key_id, 0)) {
 		return 0;
 	}
 
 	if (!handle_token(&a->compact_handler, ',', &nop)) {
 		note_error(&a->errs, "push @wskeyid , tok oob");
 		return 0;
 	}
 
 	return 1;
 }
 
 static inline int handle_header(struct ap_json *a, struct http_header *header)
 {
 	return handle_kv(a, header->name, header->value, 1);
 }
 
 struct sized_str {
 	unsigned char *text;
 	int size;
 };
 
 static int split_headers(unsigned char *headers, int header_len,
 		struct sized_str *strs, int max_strs, int *out)
 {
 	int n_strs = 0;
 	struct sized_str *str;
 	unsigned char *p, *pstart;
 
 	pstart = p = headers;
 	for (;; p++) {
 		if (n_strs == max_strs)
 			return 0;
 
 		if (*p == ' ' || *p == 0) {
 			str = &strs[n_strs++];
 			str->text = pstart;
 			str->size = p - pstart;
 			pstart = p+1;
 		}
 
 		if (*p == 0)
 			break;
 	}
 
 	*out = n_strs;
 	return 1;
 }
 
 static inline struct http_header *find_header(struct http_header *headers,
 		unsigned char *name, int name_len)
 {
 	struct http_header *header;
 
 	for (header = headers; header; header = header->next) {
 		if (name_len == strlen(header->name) &&
 		    !strncasecmp((const char *)name, header->name, name_len)) {
 			return header;
 		}
 	}
 
 	return NULL;
 }
 
 static int handle_wssigbuf(struct ap_json *a)
 {
 	struct sized_str strs[16] = {0};
 	int n_headers = 0, i;
 	struct http_header *header;
 	struct cursor *c = &((struct json_pusher *)a->compact_handler.data)->cur;
 	struct sized_str *str;
 
 	if (!handle_key(a, "@wssigbuf")) {
 		return 0;
 	}
 
 	if (!push_byte(c, '"')) {
 		return 0;
 	}
 
 	fprintf(stderr, "headers: %s\n", a->sig->headers);
 
 	if (!split_headers((unsigned char*)a->sig->headers,
 				strlen(a->sig->headers), strs,
 				sizeof(strs)/sizeof(strs[0]), &n_headers)) {
 		note_error(&a->errs, "split_headers overflow");
 		return 0;
 	}
 
 	static const char request_target[] = "(request-target)";
 
 	for (i = 0; i < n_headers; i++) {
 		str = &strs[i];
 		if (!push_escaped(c, str->text, str->size)) {
 			return 0;
 		}
 		if (!push_str(c, ": ")) {
 			return 0;
 		}
 
 		if (str->size == (sizeof(request_target)-1) &&
 		    !memcmp(request_target, str->text, str->size)) {
 			if (!push_str(c, "post /inbox")) {
 				return 0;
 			}
 		} else if ((header = find_header(a->req->headers, str->text, str->size))) {
 			if (!push_escaped(c, (unsigned char*)header->value,
 						strlen(header->value))) {
 				return 0;
 			}
 		} else {
 			note_error(&a->errs, "could not find header %.*s",
 					str->size, str->text);
 			return 0;
 		}
 
 		if (i != n_headers-1) {
 			push_str(c, "\\n");
 		}
 	}
 
 	if (!push_str(c, "\",")) {
 		return 0;
 	}
 
 	return 1;
 }
 
 static int handle_wsdigest(struct ap_json *a)
 {
 	struct json_pusher *p = (struct json_pusher *)a->compact_handler.data;
 	struct cursor *c = &p->cur;
 	size_t b64_len;
 	unsigned char hash[32];
 	unsigned char b64[128];
 	unsigned char *pos;
 
 	if (!handle_key(a, "@wsdigest")) {
 		note_error(&a->errs, "wsdigest key oob");
 		return 0;
 	}
 
 	if (!push_byte(c, '"')) {
 		return 0;
 	}
 
 	sha256_hash(hash, a->req->body, a->req->body_len);
 	// TODO: this might be broken... 
 	base64_encode(hash, 32, b64, sizeof(b64), &b64_len);
 
 	pos = c->p;
 
 	if (!(push_str(c, "SHA-256=") && push_data(c, b64, b64_len) )) {
 		return 0;
 	}
 
 	// quick sanity check
 	if ((b64_len+8) != (c->p - pos) || !memcmp(pos, b64, b64_len)) {
 		note_error(&a->errs, "bad digest");
 		return 0;
 	}
 
 	return push_str(c, "\",");
 }
 
 static int handle_ap_token(struct json_handlers *h, char token,
 			   unsigned int **len)
 {
 	struct ap_json *a = (struct ap_json*)h->data;
 	unsigned int *nop;
 
 	/* push some extra data after the start of the initial object */
 	if (token == '{' && !(a->flags & AP_HAD_START)) {
 		a->flags |= AP_HAD_START | AP_IS_START;
 
 		if (!handle_token(&a->compact_handler, '{', &nop)) {
 			note_error(&a->errs, "push @ws_sig { tok oob");
 			return 0;
 		}
 
 		if (!handle_wssig(a)) {
 			note_error(&a->errs, "push wssig");
 			return 0;
 		}
 
 		if (!handle_wsstamp(a)) {
 			note_error(&a->errs, "push wsstamp");
 			return 0;
 		}
 
 		if (!handle_wsdigest(a)) {
 			note_error(&a->errs, "push wsdigest");
 			return 0;
 		}
 
 		if (!handle_wskeyid(a)) {
 			note_error(&a->errs, "push wskeyid");
 			return 0;
 		}
 
 		if (!handle_wssigbuf(a)) {
 			note_error(&a->errs, "push wssigbuf");
 			return 0;
 		}
 
 		return 1;
 	}
 
 	return handle_token(&a->compact_handler, token, len);
 }
 
 void init_ap_json(struct ap_json *a, struct json_handlers *inner)
 {
 	memset(a, 0, sizeof(*a));
 	init_errors(&a->errs);
 	copy_json_handlers(inner, &a->compact_handler);
 }
 
 static int handle_ap_bool(struct json_handlers *h, int val)
 {
 	struct ap_json *a = (struct ap_json*)h->data;
 	return handle_bool(&a->compact_handler, val);
 }
 
 static int handle_ap_null(struct json_handlers *h)
 {
 	struct ap_json *a = (struct ap_json*)h->data;
 	return handle_null(&a->compact_handler);
 }
 
 static int handle_ap_number(struct json_handlers *h, unsigned int number)
 {
 	struct ap_json *a = (struct ap_json*)h->data;
 	return handle_number(&a->compact_handler, number);
 }
 
 void make_ap_json_pusher(struct json_handlers *h, struct ap_json *out)
 {
 	h->data = out;
 	h->string = handle_ap_string;
 	h->boolean = handle_ap_bool;
 	h->null = handle_ap_null;
 	h->number = handle_ap_number;
 	h->token = handle_ap_token;
 }