bincookie.h

Go to the documentation of this file.

 
#ifndef _BINCOOKIE_H
#define _BINCOOKIE_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
// https://github.com/nodejs/http-parser/blob/master/http_parser.h#L32
#include <sys/types.h>
#if defined(_WIN32) && !defined(__MINGW32__) && (!defined(_MSC_VER) || _MSC_VER < 1600) &&         \
    !defined(__WINE__)
#include <BaseTsd.h>
#include <stddef.h>
typedef unsigned __int32 uint32_t;
typedef unsigned __int8 bool;
#else
#include <stdbool.h>
#include <stdint.h>
#endif
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
 
 
#define bincookie_is_secure(cookie_ptr) (cookie_ptr->flags & secure) 
 
#define bincookie_domain_access_full(cookie_ptr)                                                   \
    (((char *)cookie_ptr + cookie_ptr->domain_offset)[0] == '.') 
 
#define bincookie_iter_state_init(s)                                                               \
    s.page_offset = 0;                                                                             \
    s.page_index = 0; 
 
#define bincookie_domain(c) ((char *)c + c->domain_offset) 
 
#define bincookie_path(c)                                                                          \
    ((char *)c +                                                                                   \
     c->path_offset) 
 
#define bincookie_name(c)                                                                          \
    ((char *)c +                                                                                   \
     c->name_offset) 
 
#define bincookie_value(c) ((char *)c + c->value_offset) 
#define APPLE_EPOCH_OFFSET 978307200
 
#define bincookie_expiration_time(c)                                                               \
    (c->expiry_date_epoch + APPLE_EPOCH_OFFSET) 
 
#define bincookie_creation_time(c)                                                                 \
    (c->create_date_epoch + APPLE_EPOCH_OFFSET) 
 
typedef enum {
    secure = 1,         
    http_only = 1 << 2, 
} bincookie_flag;
 
typedef struct {
    uint32_t page_offset; 
    uint32_t page_index;  
} bincookie_iter_state_t;
 
typedef struct {
    uint32_t size; 
    unsigned char unk1[4];
    bincookie_flag flags; 
    unsigned char unk2[4];
 
    uint32_t domain_offset; 
    uint32_t name_offset;   
    uint32_t path_offset;   
    uint32_t value_offset;  
    unsigned char unk[8];
 
    double expiry_date_epoch; 
    double create_date_epoch; 
} bincookie_cookie_t;
 
typedef struct {
    unsigned char unk1[4];     
    uint32_t num_cookies;      
    uint32_t cookie_offsets[]; 
} bincookie_page_t;
 
typedef struct {
    unsigned char magic[4]; 
    uint32_t num_pages;     
    uint32_t page_sizes[];  
} bincookie_t;
 
 
static inline bool bincookie_validate_pages(const bincookie_t *bc, size_t num_bytes) {
    size_t page_offset = sizeof(bincookie_t) + (size_t)bc->num_pages * sizeof(uint32_t);
    for (uint32_t i = 0; i < bc->num_pages; i++) {
        if (page_offset > num_bytes || num_bytes - page_offset < sizeof(bincookie_page_t)) {
            return false;
        }
        const bincookie_page_t *page = (const bincookie_page_t *)((const char *)bc + page_offset);
        size_t offsets_room = num_bytes - page_offset - sizeof(bincookie_page_t);
        if (offsets_room / sizeof(uint32_t) < page->num_cookies) {
            return false;
        }
        for (uint32_t j = 0; j < page->num_cookies; j++) {
            uint32_t cookie_offset = page->cookie_offsets[j];
            if (cookie_offset > num_bytes - page_offset ||
                num_bytes - page_offset - cookie_offset < sizeof(bincookie_cookie_t)) {
                return false;
            }
            const bincookie_cookie_t *cookie =
                (const bincookie_cookie_t *)((const char *)page + cookie_offset);
            size_t cookie_pos = page_offset + cookie_offset;
            uint32_t string_offsets[] = {cookie->domain_offset,
                                         cookie->name_offset,
                                         cookie->path_offset,
                                         cookie->value_offset};
            for (size_t k = 0; k < sizeof(string_offsets) / sizeof(string_offsets[0]); k++) {
                if (string_offsets[k] >= num_bytes - cookie_pos) {
                    return false;
                }
            }
        }
        page_offset += bc->page_sizes[i];
    }
    return true;
}
 
static inline bincookie_t *const bincookie_init_file(FILE *fin) {
    const long last_pos = ftell(fin);
    rewind(fin);
    char magic[4];
    bincookie_t *cook = NULL;
    size_t read = fread(magic, sizeof(magic), 1, fin);
    bool is_cook = magic[0] == 'c' && magic[1] == 'o' && magic[2] == 'o' && magic[3] == 'k';
    if (read != 1 || !is_cook) {
        errno = EIO;
        goto done;
    }
    // Read entire file
    fseek(fin, 0, SEEK_END);
    size_t num_bytes = (size_t)ftell(fin);
    // The fixed header, made up of the magic and num_pages, must be present before any
    // file-derived field is dereferenced.
    if (num_bytes < sizeof(bincookie_t)) {
        errno = EIO;
        goto done;
    }
    cook = (bincookie_t *)malloc(num_bytes);
    // LCOV_EXCL_START
    if (cook == NULL) {
        goto done;
    } // LCOV_EXCL_STOP
    memset(cook, 0, num_bytes);
    rewind(fin);
    // LCOV_EXCL_START
    if (fread(cook, num_bytes, 1, fin) != 1) {
        free(cook);
        cook = NULL;
        goto done;
    } // LCOV_EXCL_STOP
    cook->num_pages = __builtin_bswap32(cook->num_pages);
    // num_pages comes straight from the file; reject any value whose page size table cannot fit
    // within the bytes actually read from disk before the table is dereferenced.
    if (cook->num_pages > (num_bytes - sizeof(bincookie_t)) / sizeof(uint32_t)) {
        free(cook);
        cook = NULL;
        errno = EIO;
        goto done;
    }
    // Fix page size numbers
    for (uint32_t i = 0; i < cook->num_pages; i++) {
        *(cook->page_sizes + i) = __builtin_bswap32(*(cook->page_sizes + i));
    }
    // Every page, cookie offset table, and cookie offset is also file-controlled, so reject the
    // file unless the whole structure stays within bounds.
    if (!bincookie_validate_pages(cook, num_bytes)) {
        free(cook);
        cook = NULL;
        errno = EIO;
        goto done;
    }
done:
    fseek(fin, last_pos, SEEK_SET);
    return cook;
}
 
static inline bincookie_t *const bincookie_init_path(const char *file_path) {
    FILE *binary_file = fopen(file_path, "rb");
    if (!binary_file) {
        return NULL;
    }
    bincookie_t *ret = bincookie_init_file(binary_file);
    fclose(binary_file);
    return ret;
}
 
static inline bincookie_page_t *const bincookie_iter_pages(const bincookie_t *bc,
                                                           bincookie_iter_state_t *const state) {
    if (state->page_offset == 0) {
        state->page_offset = (uint32_t)(4 + sizeof(uint32_t) + (sizeof(uint32_t) * bc->num_pages));
    }
    if (state->page_index < bc->num_pages) {
        bincookie_page_t *page = (bincookie_page_t *)((char *)bc + state->page_offset);
        state->page_offset += bc->page_sizes[state->page_index];
        state->page_index++;
        return page;
    }
    return NULL;
}
 
static inline bincookie_cookie_t *const bincookie_iter_cookies(const bincookie_page_t *page,
                                                               unsigned int *i) {
    if (*i < page->num_cookies) {
        bincookie_cookie_t *ptr = (bincookie_cookie_t *)((char *)page + page->cookie_offsets[*i]);
        (*i)++;
        return ptr;
    }
    return NULL;
}
 
#ifdef __cplusplus
}
#endif
 
#endif // _BINCOOKIE_H