implement Oldauth;

#
# TO DO
#	- more error checking?
#	- details of auth error handling
#

include "sys.m";
	sys: Sys;

include "ipints.m";
	ipints: IPints;
	IPint: import ipints;

include "crypt.m";
	crypt: Crypt;
	PK, SK, PKsig: import crypt;

include "msgio.m";
	msgio: Msgio;

include "oldauth.m";

init()
{
	sys = load Sys Sys->PATH;
	ipints = load IPints IPints->PATH;
	crypt = load Crypt Crypt->PATH;
	msgio = load Msgio Msgio->PATH;
	msgio->init();
}

efmt()
{
	sys->werrstr("input or format error");
}

readauthinfo(filename: string): ref Authinfo
{
	fd := sys->open(filename, Sys->OREAD);
	if(fd == nil)
		return nil;
	a := array[5] of string;
	for(i := 0; i < len a; i++){
		(s, err) := getstr(fd);
		if(err != nil){
			sys->werrstr(sys->sprint("%q: input or format error", filename));
			return nil;
		}
		a[i] = s;
	}
	info := ref Authinfo;
	(info.spk, nil) = strtopk(a[0]);
	info.cert = strtocert(a[1]);
	(info.mysk, info.owner) = strtosk(a[2]);
	if(info.spk == nil || info.cert == nil || info.mysk == nil){
		efmt();
		return nil;
	}
	info.mypk = crypt->sktopk(info.mysk);
	info.alpha = IPint.strtoip(a[3], 64);
	info.p = IPint.strtoip(a[4], 64);
	if(info.alpha == nil || info.p == nil){
		efmt();
		return nil;
	}
	return info;
}

writeauthinfo(filename: string, info: ref Authinfo): int
{
	if(info.alpha == nil || info.p == nil ||
	   info.spk == nil || info.mysk == nil || info.cert == nil){
		sys->werrstr("invalid authinfo");
		return -1;
	}
	a := array[5] of string;
	a[0] = pktostr(info.spk, info.cert.signer);	# signer's public key
	a[1] = certtostr(info.cert);	# certificate for my public key
	a[2] = sktostr(info.mysk, info.owner);	# my secret/public key
	a[3] = b64(info.alpha);	# diffie hellman base
	a[4] = b64(info.p);	# diffie hellman modulus
	fd := sys->open(filename, Sys->OWRITE|Sys->OTRUNC);
	if(fd == nil){
		fd = sys->create(filename, Sys->OWRITE, 8r600);
		if(fd == nil){
			fd = sys->open(filename, Sys->OWRITE);
			if(fd == nil)
				return -1;
		}
	}
	for(i := 0; i < len a; i++)
		if(sendstr(fd, a[i]) <= 0)
			return -1;
	return 0;
}

sendstr(fd: ref Sys->FD, s: string): int
{
	a := array of byte s;
	return msgio->sendmsg(fd, a, len a);
}

getstr(fd: ref Sys->FD): (string, string)
{
	b := msgio->getmsg(fd);
	if(b == nil)
		return (nil, sys->sprint("%r"));
	return (string b, nil);
}

certtostr(c: ref Certificate): string
{
	s := sys->sprint("%s\n%s\n%s\n%ud\n", c.sa, c.ha, c.signer, c.exp);
	pick r := c.sig {
	RSA =>
		s += b64(r.n)+"\n";
	Elgamal =>
		s += b64(r.r)+"\n"+b64(r.s)+"\n";
	DSA =>
		s += b64(r.r)+"\n"+b64(r.s)+"\n";
	* =>
		raise "unknown key type";
	}
	return s;
}

pktostr(pk: ref PK, owner: string): string
{
	pick k := pk {
	RSA =>
		s := sys->sprint("rsa\n%s\n", owner);
		s += b64(k.n)+"\n"+b64(k.ek)+"\n";
		return s;
	Elgamal =>
		s := sys->sprint("elgamal\n%s\n", owner);
		s += b64(k.p)+"\n"+b64(k.alpha)+"\n"+b64(k.key)+"\n";
		return s;
	DSA =>
		s := sys->sprint("dsa\n%s\n", owner);
		s += b64(k.p)+"\n"+b64(k.q)+"\n"+b64(k.alpha)+"\n"+b64(k.key)+"\n";
		return s;
	* =>
		raise "unknown key type";
	}
}

sktostr(sk: ref SK, owner: string): string
{
	pick k := sk {
	RSA =>
		s := sys->sprint("rsa\n%s\n", owner);
		s += b64(k.pk.n)+"\n"+b64(k.pk.ek)+"\n"+b64(k.dk)+"\n"+
			b64(k.p)+"\n"+b64(k.q)+"\n"+
			b64(k.kp)+"\n"+b64(k.kq)+"\n"+
			k.c2.iptob64()+"\n";
		return s;
	Elgamal =>
		pk := k.pk;
		s := sys->sprint("elgamal\n%s\n", owner);
		s += b64(pk.p)+"\n"+b64(pk.alpha)+"\n"+b64(pk.key)+"\n"+b64(k.secret)+"\n";
		return s;
	DSA =>
		pk := k.pk;
		s := sys->sprint("dsa\n%s\n", owner);
		s += b64(pk.p)+"\n"+b64(pk.q)+"\n"+b64(pk.alpha)+"\n"+b64(k.secret)+"\n";
		return s;
	* =>
		raise "unknown key type";
	}
}

fields(s: string): array of string
{
	(nf, flds) := sys->tokenize(s, "\n^");
	a := array[nf] of string;
	for(i := 0; i < len a; i++){
		a[i] = hd flds;
		flds = tl flds;
	}
	return a;
}

bigs(a: array of string): array of ref IPint
{
	b := array[len a] of ref IPint;
	for(i := 0; i < len b; i++){
		b[i] = IPint.strtoip(a[i], 64);
		if(b[i] == nil)
			return nil;
	}
	return b;
}

need[T](a: array of T, min: int): int
{
	if(len a < min){
		efmt();
		return 1;
	}
	return 0;
}

strtocert(s: string): ref Certificate
{
	f := fields(s);
	if(need(f, 4))
		return nil;
	sa := f[0];
	ha := f[1];
	signer := f[2];
	exp := int big f[3];	# unsigned
	b := bigs(f[4:]);
	case f[0] {
	"rsa" =>
		if(need(b, 1))
			return nil;
		return ref Certificate(sa, ha, signer, exp, ref PKsig.RSA(b[0]));
	"elgamal" =>
		if(need(b, 2))
			return nil;
		return ref Certificate(sa, ha, signer, exp, ref PKsig.Elgamal(b[0], b[1]));
	"dsa" =>
		if(need(b, 2))
			return nil;
		return ref Certificate(sa, ha, signer, exp, ref PKsig.DSA(b[0], b[1]));
	* =>
		sys->werrstr("unknown algorithm: "+f[0]);
		return nil;
	}
}

strtopk(s: string): (ref PK, string)
{
	f := fields(s);
	if(need(f, 3))
		return (nil, "format error");
	sa := f[0];
	owner := f[1];
	b := bigs(f[2:]);
	case sa {
	"rsa" =>
		if(need(b, 2))
			return (nil, "format error");
		return (ref PK.RSA(b[0], b[1]), owner);
	"elgamal" =>
		if(need(b, 3))
			return (nil, "format error");
		return (ref PK.Elgamal(b[0], b[1], b[2]), owner);
	"dsa" =>
		if(need(b, 4))
			return (nil, "format error");
		return (ref PK.DSA(b[0], b[1], b[2], b[3]), owner);
	* =>
		return (nil, "unknown algorithm: "+f[0]);
	}
}

strtosk(s: string): (ref SK, string)
{
	f := fields(s);
	if(need(f, 3))
		return (nil, "format error");
	sa := f[0];
	owner := f[1];
	b := bigs(f[2:]);
	case sa {
	"rsa" =>
		if(need(b, 8))
			return (nil, "format error");
		return (ref SK.RSA(ref PK.RSA(b[0], b[1]), b[2], b[3], b[4], b[5], b[6], b[7]), owner);
	"elgamal" =>
		if(need(b, 4))
			return (nil, "format error");
		return (ref SK.Elgamal(ref PK.Elgamal(b[0], b[1], b[2]), b[3]), owner);
	"dsa" =>
		if(need(b, 5))
			return (nil, "format error");
		return (ref SK.DSA(ref PK.DSA(b[0], b[1], b[2], b[3]), b[4]), owner);
	* =>
		return (nil, "unknown algorithm: "+f[0]);
	}
}

skalg(sk: ref SK): string
{
	if(sk == nil)
		return "nil";
	case tagof sk {
	tagof SK.RSA =>	return "rsa";
	tagof SK.Elgamal =>	return "elgamal";
	tagof SK.DSA =>	return "dsa";
	* =>	return "gok";
	}
}

sign(sk: ref SK, signer: string, exp: int, state: ref Crypt->DigestState, ha: string): ref Certificate
{
	# add signer name and expiration time to hash
	if(state == nil)
		return nil;
	a := sys->aprint("%s %d", signer, exp);
	digest := hash(ha, a, state);
	if(digest == nil)
		return nil;
	b := IPint.bebytestoip(digest);
	return ref Certificate(skalg(sk), ha, signer, exp, crypt->sign(sk, b));
}

verify(pk: ref PK, cert: ref Certificate, state: ref Crypt->DigestState): int
{
	if(state == nil)
		return 0;
	a := sys->aprint("%s %d", cert.signer, cert.exp);
	digest := hash(cert.ha, a, state);
	if(digest == nil)
		return 0;
	b := IPint.bebytestoip(digest);
	return crypt->verify(pk, cert.sig, b);
}

hash(ha: string, a: array of byte, state: ref Crypt->DigestState): array of byte
{
	digest: array of byte;
	case ha {
	"sha" or "sha1" =>
		digest = array[Crypt->SHA1dlen] of byte;
		crypt->sha1(a, len a, digest, state);
	"md5" =>
		digest = array[Crypt->MD5dlen] of byte;
		crypt->md5(a, len a, digest, state);
	* =>
		# don't bother with md4
		sys->werrstr("unimplemented algorithm: "+ha);
		return nil;
	}
	return digest;
}

b64(ip: ref IPint): string
{
	return ip.iptob64z();
}