/*      $OpenBSD: srs.c,v 1.5 2021/06/14 17:58:16 eric Exp $    */

/*
 * Copyright (c) 2019 Gilles Chehade <gilles@poolp.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <openssl/sha.h>
#include <string.h>

#include "smtpd.h"

static uint8_t  base32[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";

static int
minrange(uint16_t tref, uint16_t t2, int drift, int mod)
{
        if (tref > drift) {
                /* t2 must fall in between tref and tref - drift */
                if (t2 <= tref && t2>= tref - drift)
                        return 1;
        }
        else {
                /* t2 must fall in between 0 and tref, or wrap */
                if (t2 <= tref || t2 >= mod - (drift - tref))
                        return 1;
        }
        return 0;
}

static int
maxrange(uint16_t tref, uint16_t t2, int drift, int mod)
{
        if (tref + drift < 1024) {
                /* t2 must fall in between tref and tref + drift */
                if (t2 >= tref && t2 <= tref + drift)
                        return 1;
        }
        else {
                /* t2 must fall in between tref + drift, or wrap */
                if (t2 >= tref || t2 <= (tref + drift) % 1024)
                        return 1;
        }
        return 0;
}

static int
timestamp_check_range(uint16_t tref, uint16_t t2)
{
        if (! minrange(tref, t2, env->sc_srs_ttl, 1024) &&
            ! maxrange(tref, t2, 1, 1024))
                return 0;

        return 1;
}

static const unsigned char *
srs_hash(const char *key, const char *value)
{
        SHA_CTX c;
        static unsigned char md[SHA_DIGEST_LENGTH];

        SHA1_Init(&c);
        SHA1_Update(&c, key, strlen(key));
        SHA1_Update(&c, value, strlen(value));
        SHA1_Final(md, &c);
        return md;
}

static const char *
srs0_encode(const char *sender, const char *rcpt_domain)
{
        static char dest[SMTPD_MAXMAILADDRSIZE];
        char tmp[SMTPD_MAXMAILADDRSIZE];
        char md[SHA_DIGEST_LENGTH*4+1];
        struct mailaddr maddr;
        uint16_t timestamp;
        int ret;

        /* compute 10 bits timestamp according to spec */
        timestamp = (time(NULL) / (60 * 60 * 24)) % 1024;

        /* parse sender into user and domain */
        if (! text_to_mailaddr(&maddr, sender))
                return sender;

        /* TT=<orig_domainpart>=<orig_userpart>@<new_domainpart> */
        ret = snprintf(tmp, sizeof tmp, "%c%c=%s=%s@%s",
            base32[(timestamp>>5) & 0x1F],
            base32[timestamp & 0x1F],
            maddr.domain, maddr.user, rcpt_domain);
        if (ret == -1 || ret >= (int)sizeof tmp)
                return sender;

        /* compute HHHH */
        base64_encode_rfc3548(srs_hash(env->sc_srs_key, tmp), SHA_DIGEST_LENGTH,
            md, sizeof md);

        /* prepend SRS0=HHHH= prefix */
        ret = snprintf(dest, sizeof dest, "SRS0=%c%c%c%c=%s",
            md[0], md[1], md[2], md[3], tmp);
        if (ret == -1 || ret >= (int)sizeof dest)
                return sender;

        return dest;
}

static const char *
srs1_encode_srs0(const char *sender, const char *rcpt_domain)
{
        static char dest[SMTPD_MAXMAILADDRSIZE];
        char tmp[SMTPD_MAXMAILADDRSIZE];
        char md[SHA_DIGEST_LENGTH*4+1];
        struct mailaddr maddr;
        int ret;

        /* parse sender into user and domain */
        if (! text_to_mailaddr(&maddr, sender))
                return sender;

        /* <last_domainpart>==<SRS0_userpart>@<new_domainpart> */
        ret = snprintf(tmp, sizeof tmp, "%s==%s@%s",
            maddr.domain, maddr.user, rcpt_domain);
        if (ret == -1 || ret >= (int)sizeof tmp)
                return sender;

        /* compute HHHH */
        base64_encode_rfc3548(srs_hash(env->sc_srs_key, tmp), SHA_DIGEST_LENGTH,
                md, sizeof md);

        /* prepend SRS1=HHHH= prefix */
        ret = snprintf(dest, sizeof dest, "SRS1=%c%c%c%c=%s",
            md[0], md[1], md[2], md[3], tmp);
        if (ret == -1 || ret >= (int)sizeof dest)
                return sender;

        return dest;
}

static const char *
srs1_encode_srs1(const char *sender, const char *rcpt_domain)
{
        static char dest[SMTPD_MAXMAILADDRSIZE];
        char tmp[SMTPD_MAXMAILADDRSIZE];
        char md[SHA_DIGEST_LENGTH*4+1];
        struct mailaddr maddr;
        int ret;

        /* parse sender into user and domain */
        if (! text_to_mailaddr(&maddr, sender))
                return sender;

        /* <SRS1_userpart>@<new_domainpart> */
        ret = snprintf(tmp, sizeof tmp, "%s@%s", maddr.user, rcpt_domain);
        if (ret == -1 || ret >= (int)sizeof tmp)
                return sender;

        /* sanity check: there's at least room for a checksum
         * with allowed delimiter =, + or -
         */
        if (strlen(tmp) < 5)
                return sender;
        if (tmp[4] != '=' && tmp[4] != '+' && tmp[4] != '-')
                return sender;

        /* compute HHHH */
        base64_encode_rfc3548(srs_hash(env->sc_srs_key, tmp + 5), SHA_DIGEST_LENGTH,
                md, sizeof md);

        /* prepend SRS1=HHHH= prefix skipping previous hops' HHHH */
        ret = snprintf(dest, sizeof dest, "SRS1=%c%c%c%c=%s",
            md[0], md[1], md[2], md[3], tmp + 5);
        if (ret == -1 || ret >= (int)sizeof dest)
                return sender;

        return dest;
}

const char *
srs_encode(const char *sender, const char *rcpt_domain)
{
        if (strncasecmp(sender, "SRS0=", 5) == 0)
                return srs1_encode_srs0(sender+5, rcpt_domain);
        if (strncasecmp(sender, "SRS1=", 5) == 0)
                return srs1_encode_srs1(sender+5, rcpt_domain);
        return srs0_encode(sender, rcpt_domain);
}

static const char *
srs0_decode(const char *rcpt)
{
        static char dest[SMTPD_MAXMAILADDRSIZE];
        char md[SHA_DIGEST_LENGTH*4+1];
        struct mailaddr maddr;
        char *p;
        uint8_t *idx;
        int ret;
        uint16_t timestamp, srs_timestamp;

        /* sanity check: we have room for a checksum and delimiter */
        if (strlen(rcpt) < 5)
                return NULL;

        /* compute checksum */
        base64_encode_rfc3548(srs_hash(env->sc_srs_key, rcpt+5), SHA_DIGEST_LENGTH,
            md, sizeof md);

        /* compare prefix checksum with computed checksum */
        if (strncmp(md, rcpt, 4) != 0) {
                if (env->sc_srs_key_backup == NULL)
                        return NULL;
                base64_encode_rfc3548(srs_hash(env->sc_srs_key_backup, rcpt+5),
                    SHA_DIGEST_LENGTH, md, sizeof md);
                if (strncmp(md, rcpt, 4) != 0)
                        return NULL;
        }
        rcpt += 5;

        /* sanity check: we have room for a timestamp and delimiter */
        if (strlen(rcpt) < 3)
                return NULL;

        /* decode timestamp */
        if ((idx = strchr(base32, rcpt[0])) == NULL)
                return NULL;
        srs_timestamp = ((idx - base32) << 5);

        if ((idx = strchr(base32, rcpt[1])) == NULL)
                return NULL;
        srs_timestamp |= (idx - base32);
        rcpt += 3;

        /* compute current 10 bits timestamp */
        timestamp = (time(NULL) / (60 * 60 * 24)) % 1024;

        /* check that SRS timestamp isn't too far from current */
        if (timestamp != srs_timestamp)
                if (! timestamp_check_range(timestamp, srs_timestamp))
                        return NULL;

        if (! text_to_mailaddr(&maddr, rcpt))
                return NULL;

        /* sanity check: we have at least one SRS separator */
        if ((p = strchr(maddr.user, '=')) == NULL)
                return NULL;
        *p++ = '\0';

        /* maddr.user holds "domain\0user", with p pointing at user */
        ret = snprintf(dest, sizeof dest, "%s@%s", p, maddr.user);
        if (ret == -1 || ret >= (int)sizeof dest)
                return NULL;

        return dest;
}

static const char *
srs1_decode(const char *rcpt)
{
        static char dest[SMTPD_MAXMAILADDRSIZE];
        char md[SHA_DIGEST_LENGTH*4+1];
        struct mailaddr maddr;
        char *p;
        uint8_t *idx;
        int ret;
        uint16_t timestamp, srs_timestamp;

        /* sanity check: we have room for a checksum and delimiter */
        if (strlen(rcpt) < 5)
                return NULL;

        /* compute checksum */
        base64_encode_rfc3548(srs_hash(env->sc_srs_key, rcpt+5), SHA_DIGEST_LENGTH,
            md, sizeof md);

        /* compare prefix checksum with computed checksum */
        if (strncmp(md, rcpt, 4) != 0) {
                if (env->sc_srs_key_backup == NULL)
                        return NULL;
                base64_encode_rfc3548(srs_hash(env->sc_srs_key_backup, rcpt+5),
                    SHA_DIGEST_LENGTH, md, sizeof md);
                if (strncmp(md, rcpt, 4) != 0)
                        return NULL;
        }
        rcpt += 5;

        if (! text_to_mailaddr(&maddr, rcpt))
                return NULL;

        /* sanity check: we have at least one SRS separator */
        if ((p = strchr(maddr.user, '=')) == NULL)
                return NULL;
        *p++ = '\0';

        /* maddr.user holds "domain\0user", with p pointing at user */
        ret = snprintf(dest, sizeof dest, "SRS0%s@%s", p, maddr.user);
        if (ret == -1 || ret >= (int)sizeof dest)
                return NULL;


        /* we're ready to return decoded address, but let's check if
         * SRS0 timestamp is valid.
         */

        /* first, get rid of SRS0 checksum (=HHHH=), we can't check it */
        if (strlen(p) < 6)
                return NULL;
        p += 6;

        /* we should be pointing to a timestamp, check that we're indeed */
        if (strlen(p) < 3)
                return NULL;
        if (p[2] != '=' && p[2] != '+' && p[2] != '-')
                return NULL;
        p[2] = '\0';

        if ((idx = strchr(base32, p[0])) == NULL)
                return NULL;
        srs_timestamp = ((idx - base32) << 5);

        if ((idx = strchr(base32, p[1])) == NULL)
                return NULL;
        srs_timestamp |= (idx - base32);

        /* compute current 10 bits timestamp */
        timestamp = (time(NULL) / (60 * 60 * 24)) % 1024;

        /* check that SRS timestamp isn't too far from current */
        if (timestamp != srs_timestamp)
                if (! timestamp_check_range(timestamp, srs_timestamp))
                        return NULL;

        return dest;
}

const char *
srs_decode(const char *rcpt)
{
        if (strncasecmp(rcpt, "SRS0=", 5) == 0)
                return srs0_decode(rcpt + 5);
        if (strncasecmp(rcpt, "SRS1=", 5) == 0)
                return srs1_decode(rcpt + 5);

        return NULL;
}