identity.h

 
#ifndef ARPA2_IDENTITY_H
#define ARPA2_IDENTITY_H
 
 
#include <stdbool.h>
#include <stdint.h>
 
#include <time.h>
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
void a2id_init (void);
 
 
void a2id_fini (void);
 
 
/* Maximum identity length is:
 *  - local-part in 64 bytes
 *  - one byte AT symbol
 *  - domain in 255 Punycode chars
 *  - one Punycode char yields up to 4 bytes
 * Buffers add one for a trailing NUL.
 */
#define A2ID_MAXLEN   ( 64 + 1 + 4*255     )
#define A2ID_BUFSIZE  ( 64 + 1 + 4*255 + 1 )
//
#define A2SEL_MAXLEN  ( 64 + 1 + 4*255     )
#define A2SEL_BUFSIZE ( 64 + 1 + 4*255 + 1 )
 
 
typedef enum {
                /* Option #0 is a local-part "+svccmd+svcargs[+FLGEXPSIG+]"        */
        A2ID_OFS_PLUS_SERVICE,          /* "[+svccmd+svcargs][+FLGEXPSIG+]@domain" */
        A2ID_OFS_SERVICE,               /*  "[svccmd+svcargs][+FLGEXPSIG+]@domain" */
        A2ID_OFS_PLUS_SVCARGS,          /*        "[+svcargs][+FLGEXPSIG+]@domain" */
        A2ID_OFS_SVCARGS,               /*         "[svcargs][+FLGEXPSIG+]@domain" */
                /* Option #1 is a local-part  "userid+aliases[+FLGEXPSIG+]"        */
        A2ID_OFS_USERID,                /*  "[userid+aliases][+FLGEXPSIG+]@domain" */
        A2ID_OFS_PLUS_ALIASES,          /*        "[+aliases][+FLGEXPSIG+]@domain" */
        A2ID_OFS_ALIASES,               /*         "[aliases][+FLGEXPSIG+]@domain" */
                /* Selectors may have an open ended '+'                            */
        A2ID_OFS_OPEN_END,              /*                 "+[+FLGEXPSIG+]"        */
                /* Both the local-part grammars fallback to "[+FLGEXPSIG+]"        */
        A2ID_OFS_PLUS_SIG,              /*                  "[+FLGEXPSIG+]@domain" */
        A2ID_OFS_SIGFLAGS,              /*                   "[FLGEXPSIG+]@domain" */
        A2ID_OFS_SIGEXPIRE,             /*                      "[EXPSIG+]@domain" */
        A2ID_OFS_SIGVALUE,              /*                         "[SIG+]@domain" */
        A2ID_OFS_SIGPLUS,               /*                            "[+]@domain" */
        A2ID_OFS_AT_DOMAIN,             /*                               "@domain" */
                /* Selectors can place a dot before the domain                     */
        A2ID_OFS_DOT_DOMAIN,            /*                             "[.]domain" */
        A2ID_OFS_DOMAIN,                /*                                "domain" */
        A2ID_OFS_END,                   /*                                      "" */
        A2ID_OFS_BUFSIZE,               /* Buffersize used, with a terminating NUL */
        //
        A2ID_OFS_COUNT
} a2id_offset_t;
 
 
typedef struct {
        uint32_t sigflags, expireday;
        uint16_t ofs [A2ID_OFS_COUNT];
        char txt [A2SEL_BUFSIZE];
        time_t expiration;
} a2sel_t;
 
 
typedef a2sel_t a2id_t;
 
 
typedef a2id_t a2act_t;
 
 
bool a2id_parse (a2id_t *out, const char *in, unsigned inlen);
 
 
bool a2id_parse_remote (a2id_t *out, const char *in, unsigned inlen);
 
 
bool a2sel_parse (a2sel_t *out, const char *in, unsigned inlen);
 
 
bool a2act_parse (a2act_t *out, const char *in, unsigned inlen, unsigned nact);
 
 
static inline bool a2act_isempty (const a2act_t *tested) {
        return (* tested->txt == '\0');
}
 
 
static inline bool a2act_isstatic (const a2act_t *tested) {
        return (tested->ofs [A2ID_OFS_ALIASES ] <  tested->ofs [A2ID_OFS_PLUS_SIG]) &&
               (tested->ofs [A2ID_OFS_PLUS_SIG] == tested->ofs [A2ID_OFS_AT_DOMAIN]);
}
 
 
static inline bool a2act_isdynamic (const a2act_t *tested) {
        return (tested->ofs [A2ID_OFS_PLUS_ALIASES] == tested->ofs [A2ID_OFS_PLUS_SIG]) &&
               (tested->ofs [A2ID_OFS_SIGPLUS     ] <  tested->ofs [A2ID_OFS_AT_DOMAIN]);
}
 
 
static inline bool a2act_isdynamicrecipe (const a2act_t *tested) {
        return a2act_isdynamic (tested) &&
               (tested->ofs [A2ID_OFS_SIGVALUE] == tested->ofs [A2ID_OFS_SIGPLUS]);
}
 
 
#define a2id_equal(a,b) (0 == strcmp ((a)->txt, (b)->txt))
 
 
#define a2sel_equal(a,b) (0 == strcmp ((a)->txt, (b)->txt))
 
 
// bool a2id_match (a2id_t *id, a2sel_t *sel);
//
#define a2id_match(id,sel) (a2sel_subseteq ((id),(sel)))
//
#define a2id_member(id,sel) (a2id_match ((id),(sel)))
 
 
bool a2sel_special (const a2sel_t *special, const a2sel_t *general);
//
#define a2sel_subseteq(s,g) a2sel_special ((s), (g))
 
 
 
bool a2sel_textshift (a2id_t *shifty, a2id_offset_t ofsidx,
                        uint16_t newofs, bool before);
 
 
 
bool a2sel_iterate_init (const a2sel_t *start, a2sel_t *cursor);
 
bool a2sel_iterate_next (const a2sel_t *start, a2sel_t *cursor);
 
#define a2id_iterate_init(in,cursor) a2sel_iterate_init ((const a2sel_t *) (start), (cursor))
 
#define a2id_iterate_next(in,cursor) a2sel_iterate_next ((const a2sel_t *) (start), (cursor))
 
 
typedef struct {
        const a2sel_t *src;
        const char *uid;
        int uidlen;
        const char *dom;
} a2sel_quickiter;
 
bool a2sel_quickiter_init (a2sel_quickiter *iter);
 
bool a2sel_quickiter_next (a2sel_quickiter *iter);
 
 
bool a2sel_abstractions (const a2sel_t *specific, const a2sel_t *generic, uint16_t *steps);
//
#define a2sel_abstractions_domain(steps)   ((steps) >> 7)
#define a2sel_abstractions_username(steps) ((steps) & 0x007f)
 
 
 
bool a2id_addkey (int keyfd);
 
 
void a2id_dropkeys (void);
 
 
typedef enum {
        //
        // char #0, bits 0..3, index values 0..3
        A2ID_SIGDATA_EXPIRATION,        /* Include expiration timer (EXP), in days since key creation */
        A2ID_SIGDATA_REMOTE_DOMAIN,     /* UTF-8 String, from _DOT_DOMAIN to _END */
        A2ID_SIGDATA_REMOTE_USERID,     /* UTF-8 String, up to _AT_DOMAIN, may be case-sensitive!!! */
        A2ID_SIGDATA_LOCAL_ALIASES,     /* UTF-8 String from _PLUS_ALIASES to _PLUS_SIG
                                           or, if that is empty, _PLUS_SVCARGS to _PLUS_SIG */
        //
        // char #1, bits 0..3, index values 4..7
        A2ID_SIGDATA_SESSIONID,         /* Machine-generated, protocol-specific session identity */
        A2ID_SIGDATA_SUBJECT,           /* Human-entered, protocol-specific, aim for a canonical form */
        A2ID_SIGDATA_TOPIC,             /* Automation-friendly, protocol-specific, like [TOPIC] in subject */
        A2ID_SIGDATA_CRYPTLOCAL,        /* Encrypted string from A2ID_OFS_USERID to A2ID_OFS_PLUS_SIG */
        //
        // No futher assigments yet
        A2ID_SIGDATA_COUNT
} a2id_sigdata_t;
//
#define A2ID_SIGFLAG_EXPIRATION         ( 1 << A2ID_SIGDATA_EXPIRATION    )
#define A2ID_SIGFLAG_REMOTE_DOMAIN      ( 1 << A2ID_SIGDATA_REMOTE_DOMAIN )
#define A2ID_SIGFLAG_REMOTE_USERID      ( 1 << A2ID_SIGDATA_REMOTE_USERID )
#define A2ID_SIGFLAG_LOCAL_ALIASES      ( 1 << A2ID_SIGDATA_LOCAL_ALIASES )
#define A2ID_SIGFLAG_SESSIONID          ( 1 << A2ID_SIGDATA_SESSIONID     )
#define A2ID_SIGFLAG_SUBJECT            ( 1 << A2ID_SIGDATA_SUBJECT       )
#define A2ID_SIGFLAG_TOPIC              ( 1 << A2ID_SIGDATA_TOPIC         )
#define A2ID_SIGFLAG_CRYPTLOCAL         ( 1 << A2ID_SIGDATA_CRYPTLOCAL    )
 
 
typedef bool a2id_sigdata_cb (a2id_sigdata_t sd,
                        void *cbdata, const a2id_t *id,
                        uint8_t *buf, uint16_t *buflen);
 
 
bool a2id_sigdata_base (a2id_sigdata_t sd,
                        void *cbdata_rid, const a2id_t *lid,
                        uint8_t *buf, uint16_t *buflen);
 
 
bool a2id_sign (a2id_t *tbs,
                a2id_sigdata_cb cb, void *cbdata);
 
 
bool a2id_verify (a2id_t *a2id_to_be_verified,
                a2id_sigdata_cb cb, void *cbdata);
 
 
#ifndef DEBUG_DETAIL
#define a2sel_detail(descr,id) do { ; } while (0)
#define a2id_detail(descr,id) a2sel_detail ((descr), (a2sel_t *) (id))
#else
#include <arpa2/except.h>
static inline void a2sel_detail (char *descr, const a2sel_t *sel) {
        int arrows = A2ID_OFS_COUNT;
        int buflen = sel->ofs [A2ID_OFS_END] + arrows + 1;
        char buf [buflen];
        int bufofs = 0;
        int selofs = 0;
        /* Print all but the final _BUFSIZE after the NUL char */
        while (arrows > 0) {
                assertxt (sel->ofs [A2ID_OFS_COUNT - arrows] >= selofs,
                        "A2ID_OFS_xxx are not monotonically rising");
                if (sel->ofs [A2ID_OFS_COUNT - arrows] == selofs) {
                        buf [bufofs++] = '|';
                        arrows--;
                        continue;
                }
                buf [bufofs++] = sel->txt [selofs++];
        }
        buf [bufofs] = '\0';
        log_detail ("%s: %s", descr, buf);
}
#endif /* DEBUG_DETAIL */
 
#ifdef __cplusplus
}
#endif
 
#endif /* ARPA2_IDENTITY_H */