srsq.c

Go to the documentation of this file.

 
#include <time.h>       /* time */
#include <sys/time.h>   /* timeval / timezone struct */
#include "str.h"
#include "sha1.h"
#include "byte.h"
#include "case.h"
#include "stralloc.h"
#include "srsq.h"
#include "uint_t.h"
 
static const char *srs_separators = "=-+";
 
stralloc secret = {0};
stralloc sendhost = {0};
stralloc senduser = {0};
 
const char *srs_errorstr(int code)
{
  X(0,"")
  /* Simple errors */
  X(SRS_SUCCESS,"Success")
  X(SRS_ENOTSRSADDRESS,"Not an SRS address.")
  X(SRS_ENOSENDERATSIGN,"No at sign in sender address")
 
  /* Config errors */
  X(SRS_ENOSECRETS,"No secrets in SRS configuration.")
  X(SRS_ESEPARATORINVALID,"Invalid separator suggested.")
 
  /* Run time errors */
  X(SRS_EOUTOFMEMORY,"Out of memory.")
 
  /* Syntax errors */
  X(SRS_ENOSRS0HOST,"No host in SRS0 address.")
  X(SRS_ENOSRS0USER,"No user in SRS0 address.")
  X(SRS_ENOSRS0HASH,"No hash in SRS0 address.")
  X(SRS_ENOSRS0STAMP,"No timestamp in SRS0 address.")
  X(SRS_ENOSRS1HOST,"No host in SRS1 address.")
  X(SRS_ENOSRS1USER,"No user in SRS1 address.")
  X(SRS_ENOSRS1HASH,"No hash in SRS1 address.")
  X(SRS_EBADTIMESTAMPCHAR,"Bad base32 character in timestamp.")
  X(SRS_EHASHTOOSHORT,"Hash too short in SRS address.")
 
  /* SRS errors */
  X(SRS_ETIMESTAMPOUTOFDATE,"Time stamp out of date.")
  X(SRS_EHASHINVALID,"Hash invalid in SRS address.")
 
  return "Unknown SRS error."; 
}
 
int srs_init(srs_ctx *srs)
{
  if (!stralloc_copys(&srs->secrets,"")) return SRS_EOUTOFMEMORY;
  srs->numsecrets = 0;
  srs->separator = '=';
  srs->maxage = 21;
  srs->hashlen = 4;
  srs->hashmin = srs->hashlen;
  srs->noforward = 0;
  srs->noreverse = 0;
  if (!stralloc_copys(&srs->nonrewrite,"")) return SRS_EOUTOFMEMORY;
 
  return SRS_SUCCESS;
}
 
/* Don't mess with these unless you know what you're doing well
 * enough to rewrite the timestamp functions. These are based on
 * a 2 character timestamp. 
 * Changing these in the wild is probably a bad idea. */
#define SRS_TIME_PRECISION (60*60*24)             /* One day */
#define SRS_TIME_BASEBITS  5     /* 2^5 = 32 = strlen(CHARS) */
 
/* This had better be a real variable since we do arithmethic with it. */
const char *SRS_TIME_BASECHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
#define SRS_TIME_SIZE   2
#define SRS_TIME_SLOTS (1 << (SRS_TIME_BASEBITS << (SRS_TIME_SIZE - 1)))
 
int srs_create_timestamp(char *buf,time_t now)  // ok
{
  now = now / SRS_TIME_PRECISION;
  buf[1] = SRS_TIME_BASECHARS[now & ((1 << SRS_TIME_BASEBITS) - 1)];
  now = now >> SRS_TIME_BASEBITS;
  buf[0] = SRS_TIME_BASECHARS[now & ((1 << SRS_TIME_BASEBITS) - 1)];
  buf[2] = '\0';
  return SRS_SUCCESS;
}
 
/* Keep backward compatiblity */
 
int srs_check_timestamp(srs_ctx *srs,char *stamp)
{
  char *sp = 0;
  char ch;
  int off;
  time_t now;
  time_t then;
 
  /* We had better go around this loop exactly twice! */
  then = 0;
  case_uppers(stamp);
  for (sp = stamp; *sp; sp++) {
    ch = *sp;
    off = str_chr(SRS_TIME_BASECHARS,ch); // original: off = bp - SRS_TIME_BASECHARS;
    if (off == str_len(sp))
      return SRS_EBADTIMESTAMPCHAR;
    then = (then << SRS_TIME_BASEBITS) | off;
  }
 
  time(&now);
  now = (now / SRS_TIME_PRECISION) % SRS_TIME_SLOTS;
  while (now < then)
    now = now + SRS_TIME_SLOTS;
 
  if (now <= then + srs->maxage) return SRS_SUCCESS;
  return SRS_ETIMESTAMPOUTOFDATE;
}
 
const char *SRS_HASH_BASECHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                 "abcdefghijklmnopqrstuvwxyz"
                                 "0123456789+/";
 
int srs_create_hash(srs_ctx *srs,char *hash,const char *secret,char *one,char *two,char *three)
{
  sha1_ctx ctx;
  int i, j;
  char srshash[SHA1_DIGESTSIZE + 1];
  unsigned char *hp = 0;
  char *bp;
 
  if (!secret) return SRS_ENOSECRETS;
 
  sha1_init(&ctx);
  sha1_update(&ctx,(uint8 *)secret,str_len(secret));
 
  if (one && *one) {
    case_lowers(one);
    sha1_update(&ctx,(uint8 *)one,str_len(one));
  }
  if (two && *two) {
    case_lowers(two);
    sha1_update(&ctx,(uint8 *)two,str_len(two));
  }
  if (three && *three) {
    case_lowers(three);
    sha1_update(&ctx,(uint8 *)three,str_len(three));
  }
 
  sha1_final((uint8 *)srshash,&ctx);  /* args inverted */
  srshash[SHA1_DIGESTSIZE] = '\0';
 
  /* A little base64 encoding. Just a little. */
 
  hp = (unsigned char *)srshash;
  bp = hash;
  for (i = j = 0; i < srs->hashlen; i++) {
    switch (i & 0x03) {
      default:  /* NOTREACHED */
      case 0:
        j = (*hp >> 2); break;
      case 1:
        j = ((*hp & 0x03) << 4) | ((*(hp + 1) & 0xF0) >> 4); hp++; break;
      case 2:
        j = ((*hp & 0x0F) << 2) | ((*(hp + 1) & 0xC0) >> 6); hp++; break;
      case 3:
        j = (*hp++ & 0x3F); break; 
    }
    *bp++ = SRS_HASH_BASECHARS[j];
  }
  *bp = '\0';
  hash[srs->hashlen - 1] = '\0';       // off-by-one error in srs2.c
 
  return SRS_SUCCESS;
}
 
int srs_check_hash(srs_ctx *srs,const char *hash,char *one,char *two,char *three)
{
  int i, j;
  char srshash[SRS_HASHLEN + 1];
 
  for (i = j = 0; j < srs->numsecrets; i++) {
    if (!stralloc_copys(&secret,srs->secrets.s + i)) return SRS_EOUTOFMEMORY;  
    i += secret.len;
    if (*(srs->secrets.s + i) == '\0') j++;
    if (!stralloc_0(&secret)) return SRS_EOUTOFMEMORY;
 
    srs_create_hash(srs,srshash,secret.s,one,two,three);
    if (!str_diffn(hash,srshash,SRS_HASHLEN)) return SRS_SUCCESS;
  }
 
  return SRS_EHASHINVALID;
}
 
int srs_make_shortcut(srs_ctx *srs,stralloc *srsaddr,char *sendhost,char *senduser,const char *aliashost) 
{
  char hash[SRS_HASHLEN + 1];
  char *srshash = hash;      // very ugly
  char srsstamp[SRS_TIME_SIZE + 1];
  int  j, r;
 
  /* This never happens if we get called from guarded() */
 
  if (!case_diffb(senduser,4,SRS0TAG) && str_chr(srs_separators,senduser[4]) < 3) {
    sendhost = senduser + 5;
    if (*sendhost == '\0') return SRS_ENOSRS0HOST;
    j = str_chr(sendhost,SRSDEL);
    senduser = sendhost + j + 1;
    if ((senduser == NULL) || (*senduser == '\0')) return SRS_ENOSRS0USER;
  }
 
  r = srs_create_timestamp(srsstamp,time(NULL));
  if (r != SRS_SUCCESS) return r;
 
  r = srs_create_hash(srs,srshash,srsstamp,sendhost,senduser,0);
  if (r != SRS_SUCCESS) return r;
 
  if (!stralloc_copys(srsaddr,SRS0TAG)) return SRS_EOUTOFMEMORY;
  if (!stralloc_catb(srsaddr,&srs->separator,1)) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,srshash)) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,SRSSEP)) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,srsstamp)) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,SRSSEP)) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,sendhost)) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,SRSSEP)) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,senduser)) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,"@")) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,aliashost)) return SRS_EOUTOFMEMORY;
  if (!stralloc_0(srsaddr)) return SRS_EOUTOFMEMORY;
 
  return SRS_SUCCESS;
}
 
int srs_make_guarded(srs_ctx *srs,stralloc *srsaddr,char *sendhost,
                     char *senduser,const char *aliashost) 
{
  char *srshost = 0;
  char *srsuser = 0;
  char *srshash = 0;
  int j = 0;
  int r;
 
  if (!case_diffb(senduser,4,SRS1TAG) && str_chr(srs_separators,senduser[4]) < 3) {
    srshash = senduser + 5;
    if (*srshash == '\0') return SRS_ENOSRS1HASH;
    if (j == str_chr(srshash,SRSDEL)) return SRS_ENOSRS1HOST;
    srshost = srshash + j + 1;
    j = str_chr(srshost,SRSDEL);
    if (j == str_len(srshost)) return SRS_ENOSRS1USER;
    srshost[j] = '\0';
    srsuser = srshost + j + 1;
    r = srs_create_hash(srs,srshash,0,srshost,srsuser,0);
    if (r != SRS_SUCCESS) return r;
  } else if (!case_diffb(senduser,4,SRS0TAG) && str_chr(srs_separators,senduser[4]) < 3) {
    srsuser = senduser + 4;
    srshost = sendhost;
    r = srs_create_hash(srs,srshash,0,srshost,srsuser,0);
    if (r != SRS_SUCCESS) return r;
  } else 
      return srs_make_shortcut(srs,srsaddr,sendhost,senduser,aliashost);
 
  /* make guarded address */
 
  if (!stralloc_copys(srsaddr,SRS1TAG)) return SRS_EOUTOFMEMORY;
  if (!stralloc_catb(srsaddr,&srs->separator,1)) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,srshash)) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,SRSSEP)) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,srshost)) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,SRSSEP)) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,srsuser)) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,"@")) return SRS_EOUTOFMEMORY;
  if (!stralloc_cats(srsaddr,aliashost)) return SRS_EOUTOFMEMORY;
  if (!stralloc_0(srsaddr)) return SRS_EOUTOFMEMORY;
 
  return SRS_SUCCESS;
}
 
int srs_parse_shortcut(srs_ctx *srs,stralloc *srsaddr,char *senduser)
{
  char *srshash = 0;
  char *srsstamp = 0;
  char *srshost = 0;
  char *srsuser = 0;
  int  j, r;
 
  if (!case_diffb(senduser,4,SRS0TAG)) {
    srshash = senduser + 5;
    j = str_chr(srshash,SRSDEL);
    if (j == str_len(srshash)) return SRS_ENOSRS0STAMP;
    srshash[j] = '\0';
    srsstamp = srshash + j + 1;
    j = str_chr(srsstamp,SRSDEL);
    if (j == str_len(srsstamp)) return SRS_ENOSRS0HOST;
    srsstamp[j] = '\0';
    srshost = srsstamp + j + 1;
    j = str_chr(srshost,SRSDEL);
    if (j == str_len(srshost)) return SRS_ENOSRS0USER;
    srshost[j] = '\0';
    srsuser = srshost + j + 1;
    r = srs_check_timestamp(srs,srsstamp);
    if (r != SRS_SUCCESS) return r;
    r = srs_check_hash(srs,srshash,srsstamp,srshost,srsuser);
    if (r != SRS_SUCCESS) return r;
 
    if (!stralloc_copys(srsaddr,srsuser)) return SRS_EOUTOFMEMORY;
    if (!stralloc_cats(srsaddr,"@")) return SRS_EOUTOFMEMORY;
    if (!stralloc_cats(srsaddr,srshost)) return SRS_EOUTOFMEMORY;
    if (!stralloc_0(srsaddr)) return SRS_EOUTOFMEMORY;
    return SRS_SUCCESS;
  }
 
  return SRS_ENOTSRSADDRESS;
}
 
int srs_reverse(srs_ctx *srs,stralloc *srsaddr,char *inaddr)
{
  char *srshash;
  char *srshost = 0;
  char *srsuser = 0;
  int  j, r;
 
  if (!SRS_IS_SRS_ADDRESS(inaddr)) return SRS_ENOTSRSADDRESS;
  if (srs->noreverse) return SRS_ENOTREWRITTEN;
  
  j = str_chr(inaddr,'@');
  if (j < str_len(inaddr)) inaddr[j] = '\0'; // only local part relevant
 
  if (!case_diffb(inaddr,4,SRS1TAG)) {
    srshash = inaddr + 5;
    j = str_chr(srshash,SRSDEL); 
    if (j != 3) return SRS_ENOSRS1HASH; 
    srshash[j] = '\0';
    srshost = srshash + j + 1;    // rewritten-domain-part
    if (j == str_len(srshost)) return SRS_ENOSRS1HOST; 
    j = str_chr(srshost,SRSDEL);
    if (j == str_len(srshost)) return SRS_ENOSRS1USER; 
    srsuser = srshost + j + 1;   // =orig-local-part.....
 
    r = srs_check_hash(srs,srshash,srshost,srsuser,0);
    if (r != SRS_SUCCESS) return r;
 
    if (!stralloc_copys(srsaddr,inaddr)) return SRS_EOUTOFMEMORY;
    if (!stralloc_cats(srsaddr,"@")) return SRS_EOUTOFMEMORY;
    if (!stralloc_cats(srsaddr,srshost)) return SRS_EOUTOFMEMORY;
    return SRS_SUCCESS;
  }
  else 
    return srs_parse_shortcut(srs,srsaddr,srsuser);
}
 
int srs_forward(srs_ctx *srs,stralloc *srsaddr,const char *sender,const char *alias)
{
  int at;
 
  if (srs->noforward) return SRS_ENOTREWRITTEN;
 
  /* This is allowed to be a plain domain */
 
  at = str_chr(alias,'@');
  if (at < str_len(alias)) {
    if (!stralloc_copys(&sendhost,alias + at + 1)) return SRS_EOUTOFMEMORY;
    if (!stralloc_0(&sendhost)) return SRS_EOUTOFMEMORY;
  } else return SRS_ENOSENDERATSIGN;
 
  if (!srs->alwaysrewrite) {
    if (case_equals(sendhost.s,alias)) {
      if (!stralloc_copys(srsaddr,sendhost.s)) return SRS_EOUTOFMEMORY;
      if (!stralloc_0(srsaddr)) return SRS_EOUTOFMEMORY;
      return SRS_SUCCESS;
    }
  }
 
  at = str_chr(sender,'@');
  if (at < str_len(sender)) {
    if (!stralloc_copyb(&senduser,sender,at)) return SRS_EOUTOFMEMORY;
  }
  if (!stralloc_copys(&sendhost,sender + at + 1)) return SRS_EOUTOFMEMORY;
  if (!stralloc_0(&senduser)) return SRS_EOUTOFMEMORY;
  if (!stralloc_0(&sendhost)) return SRS_EOUTOFMEMORY;
 
  return srs_make_guarded(srs,srsaddr,sendhost.s,senduser.s,alias);
}