path: root/appl/cmd/ssh/sshserve.b

implement Sshserve;

include "sys.m";
	sys: Sys;

include "draw.m";

include "keyring.m";
	kr: Keyring;
	IPint: import kr;
	PK, SK: import kr;

include "env.m";
	env: Env;

include "sh.m";
	sh: Sh;

include "wait.m";
	wait: Wait;

include "arg.m";

include "sshio.m";
	sshio: Sshio;
	Conn, Msg: import sshio;
	recvmsg: import sshio;
	error, debug: import sshio;

Sshserve: module
{
	init: fn(nil: ref Draw->Context, argl: list of string);
};

AuthRpc: adt {};
debuglevel := 0;

cipherlist := "blowfish rc4 3des";
ciphers: list of Cipher;

authlist := "rsa password tis";
authsrvs: list of Auth;

maxmsg := 256*1024;

serverpriv: ref SK.RSA;
serverkey: ref PK.RSA;
hostpriv: ref SK.RSA;

init(nil: ref Draw->Context, args: list of string)
{
	sys = load Sys Sys->PATH;
	kr = load Keyring Keyring->PATH;
	env = load Env Env->PATH;
	sh = load Sh Sh->PATH;
	sshio = load Sshio Sshio->PATH;
	sshio->init();
	wait = load Wait Wait->PATH;
	wait->init();
#	fmtinstall('B', mpfmt);
#	fmtinstall('H', encodefmt);
	sys->pctl(Sys->NEWPGRP|Sys->FORKFD|Sys->FORKNS|Sys->FORKENV, nil);
	keyfile: string;
	arg := load Arg Arg->PATH;
	arg->setusage("sshserve [-A authlist] [-c cipherlist] [-k keyfile] client-ip-address");
	arg->init(args);
	while((o := arg->opt()) != 0){
		case o {
		'D' =>
			debuglevel = int arg->earg();
		'A' =>
			authlist = arg->earg();
		'c' =>
			cipherlist = arg->earg();
		'k' =>
			keyfile = arg->earg();
		* =>
			arg->usage();
		}
	}
	args = arg->argv();
	if(len args != 1)
		arg->usage();
	arg = nil;

	sys->dup(2, 1);
#	if(keyfile != nil)
#		;	# read hostpriv from file
#	sshlog("connect from %s", c.host);
	authsrvs = loadlist("auth", authlist, authload);
	ciphers = loadlist("cipher", cipherlist, cipherload);
	hostpriv = kr->rsagen(1024, 6, 0);
	serverpriv = kr->rsagen(768, 6, 0);
	serverkey = serverpriv.pk;
	{
		versioning(sys->fildes(0));
		c := Conn.mk(hd args, sys->fildes(0));
		c.setkey(hostpriv.pk);
		authenticate(c);
		comms(c);
	}exception e{
	"fail:*" =>
		raise e;
	"error*" =>
		notegrp(sys->pctl(0, nil), "error");
		raise "fail:"+e;
	}
}

authload(f: string): Auth
{
	return load Auth f;
}

cipherload(f: string): Cipher
{
	return load Cipher f;
}

loadlist[T](sort: string, set: string, loadf: ref fn(f: string): T): list of T
{
	l: list of T;
	(nil, fld) := sys->tokenize(set, " \t,");
	for(; fld != nil; fld = tl fld){
		f := "/dis/ssh/"+sort+hd fld+".dis";
		m := loadf(f);
		if(m == nil)
			error(sys->sprint("unknown %s scheme %s (%s)", sort, hd fld, f));
		l = m :: l;
	}
	return l;
}

comms(c: ref Conn)
{
	(kidpid, infd, waiting) := prelude(c);
Work:
	for(;;)alt{
	(m, nil) := <-c.in =>
		if(m == nil){
			notegrp(kidpid, "hungup");
			exit;
		}
		case m.mtype {
		* =>
			sshio->badmsg(m, 0, nil);
		SSH_MSG_DISCONNECT =>
			notegrp(kidpid, "hungup");
			sysfatal("client disconnected");
		SSH_CMSG_STDIN_DATA =>
			if(infd != nil){
				n := m.get4();
				sys->write(infd, m.getbytes(n), n);
			}
		SSH_CMSG_EOF =>
			infd = nil;
		SSH_CMSG_EXIT_CONFIRMATION =>
			#  sent by some clients as dying breath
			notegrp(kidpid, "hungup");
			break Work;
		SSH_CMSG_WINDOW_SIZE =>
			;	#  we don't care 
		}
	(pid, nil, status) := <-waiting =>
		if(pid == kidpid){
			if(status != "" && status != "0"){
				m := Msg.mk(SSH_MSG_DISCONNECT, 4+Sys->UTFmax*len status);
				m.putstring(status);
				sendmsg(c, m);
			}else{
				m := Msg.mk(SSH_SMSG_EXITSTATUS, 4);
				m.put4(0);
				sendmsg(c, m);
			}
			sendmsg(c, nil);
			break Work;
		}
	}
	notegrp(sys->pctl(0, nil), "done");
}

prelude(c: ref Conn): (int, ref Sys->FD, chan of (int, string, string))
{
	for(;;){
		m := recvmsg(c, -1);
		if(m == nil)
			return (-1, nil, nil);
		case m.mtype {
		* =>
			sendmsg(c, Msg.mk(SSH_SMSG_FAILURE, 0));
		SSH_MSG_DISCONNECT =>
			sysfatal("client disconnected");
		SSH_CMSG_REQUEST_PTY =>
			sendmsg(c, Msg.mk(SSH_SMSG_SUCCESS, 0));
		SSH_CMSG_MAX_PACKET_SIZE =>
			n := m.get4();
			if(n >= 32 && n <= SSH_MAX_MSG){
				maxmsg = n;
				sendmsg(c, Msg.mk(SSH_SMSG_SUCCESS, 0));
			}else
				sendmsg(c, Msg.mk(SSH_SMSG_FAILURE, 0));
		SSH_CMSG_EXEC_SHELL =>
			return startcmd(c, nil);
		SSH_CMSG_EXEC_CMD =>
			cmd := m.getstring();
			return startcmd(c, cmd);
		}
	}
}

copyout(c: ref Conn, fd: ref Sys->FD, mtype: int)
{
	buf := array[8192] of byte;
	max := len buf;
	if(max > maxmsg-32)	#  32 is an overestimate of packet overhead 
		max = maxmsg-32;
	if(max <= 0)
		sysfatal("maximum message size too small");
	while((n := sys->read(fd, buf, max)) > 0){
		m := Msg.mk(mtype, 4+n);
		m.put4(n);
		m.putbytes(buf, n);
		sendmsg(c, m);
	}
}

send_ssh_smsg_public_key(c: ref Conn, cookie: array of byte)
{
	m := Msg.mk(SSH_SMSG_PUBLIC_KEY, 2048);
	m.putbytes(cookie, COOKIELEN);
	m.putpk(serverkey);
	m.putpk(c.hostkey);
	m.put4(c.flags);
	ciphermask := 0;
	for(l1 := ciphers; l1 != nil; l1 = tl l1)
		ciphermask |= 1<<(hd l1)->id();
	m.put4(ciphermask);
	authmask := 0;
	for(l2 := authsrvs; l2 != nil; l2 = tl l2)
		authmask |= 1<<(hd l2)->id();
	m.put4(authmask);
	sendmsg(c, m);
}

rpcdecrypt(rpc: ref AuthRpc, b: ref IPint): ref IPint
{
	raise "rpcdecrypt";
#	p := array of byte b.iptostr(16);
#	if(auth_rpc(rpc, "write", p, len p) != ARok)
#		sysfatal("factotum rsa write: %r");
#	if(auth_rpc(rpc, "read", nil, 0) != ARok)
#		sysfatal("factotum rsa read: %r");
#	return strtomp(rpc.arg, nil, 16, nil);
}

recv_ssh_cmsg_session_key(c: ref Conn, rpc: ref AuthRpc, cookie: array of byte)
{
	m := recvmsg(c, SSH_CMSG_SESSION_KEY);
	id := m.get1();
	c.cipher = nil;
	for(l := ciphers; l != nil; l = tl l)
		if((hd l)->id() == id){
			c.cipher = hd l;
			break;
		}
	if(c.cipher == nil)
		sysfatal(sys->sprint("invalid cipher %d selected", id));
	if(!sshio->eqbytes(m.getbytes(COOKIELEN), cookie, len cookie))
		sysfatal("bad cookie");
	serverkeylen := serverkey.n.bits();
	hostkeylen := c.hostkey.n.bits();
	ksmall, kbig: ref SK.RSA;
	if(serverkeylen+128 <= hostkeylen){
		ksmall = serverpriv;
		kbig = nil;
	}else if(hostkeylen+128 <= serverkeylen){
		ksmall = nil;
		kbig = serverpriv;
	}else
		sysfatal("server session and host keys do not differ by at least 128 bits");
	b := m.getipint();
	debug(DBG_CRYPTO, sys->sprint("encrypted with kbig is %s\n", b.iptostr(16)));
	if(kbig != nil)
		b = sshio->rsadecrypt(kbig, b);
	else
#		b = rpcdecrypt(rpc, b);
		b = sshio->rsadecrypt(hostpriv, b);
	b = sshio->rsaunpad(b);
	sshio->debug(DBG_CRYPTO, sys->sprint("encrypted with ksmall is %s\n", b.iptostr(16)));
	if(ksmall != nil)
		b = sshio->rsadecrypt(ksmall, b);
	else
#		b = rpcdecrypt(rpc, b);
		b = sshio->rsadecrypt(hostpriv, b);
	b = sshio->rsaunpad(b);
	debug(DBG_CRYPTO, sys->sprint("munged is %s\n", b.iptostr(16)));
	n := (b.bits()+7)/8;
	if(n < SESSKEYLEN)
		sysfatal("client sent short session key");
	buf := array[SESSKEYLEN] of byte;
	sshio->iptorjustbe(b, buf, SESSKEYLEN);
	for(i := 0; i < SESSIDLEN; i++)
		buf[i] ^= c.sessid[i];
	c.sesskey[0: ] = buf[0: SESSKEYLEN];
	debug(DBG_CRYPTO, sys->sprint("unmunged is %.*s\n", SESSKEYLEN*2, sshio->hex(buf)));
	c.flags = m.get4();
}

authsrvuser(c: ref Conn)
{
	m := recvmsg(c, SSH_CMSG_USER);
	user := m.getstring();
	c.user = user;
	inited := 0;
	ai: ref Auth->AuthInfo;
	while(authsrvs != nil && ai == nil){
#		# 
#		# 		 * clumsy: if the client aborted the auth_tis early
#		# 		 * we don't send a new failure.  we check this by
#		# 		 * looking at c->unget, which is only used in that
#		# 		 * case.
#		# 		 
		if(c.unget == nil)
			sendmsg(c, Msg.mk(SSH_SMSG_FAILURE, 0));
		m = recvmsg(c, -1);
		for(l := authsrvs; l != nil; l = tl l)
			if((hd l)->firstmsg() == m.mtype){
				bit := 1 << (hd l)->id();
				if((inited & bit) == 0){
					(hd l)->init(sshio);
					inited |= bit;
				}
				ai = (hd l)->authsrv(c, m);
				break;
			}
		if(l == nil)
			sshio->badmsg(m, 0, nil);
	}
	sendmsg(c, Msg.mk(SSH_SMSG_SUCCESS, 0));
#	if(noworld(ai.cuid))
#		ns := "/lib/namespace.noworld";
#	else
#		ns = nil;
#	if(auth_chuid(ai, ns) < 0){
#		sshlog("auth_chuid to %s: %r", ai.cuid);
#		sysfatal("auth_chuid: %r");
#	}
#	sshlog("logged in as %q", ai.user);
	if(ai != nil)
		sys->print("logged in as %q\n", ai.user);
}

keyjunk()
{
	p: array of byte;
	m: ref IPint;
	rpc: ref AuthRpc;
	key: ref PK.RSA;

#	# 
#	# BUG: should use `attr' to get the key attributes
#	# after the read, but that's not implemented yet.
#	# 	 
#	if((b = Bopen("/mnt/factotum/ctl", OREAD)) == nil)
#		sysfatal("open /mnt/factotum/ctl: %r");
#	while((p = Brdline(b, '\n')) != nil){
#		if(strstr(p, " proto=rsa ") != nil && strstr(p, " service=sshserve ") != nil)
#			break;
#	}
#	if(p == nil)
#		sysfatal("no sshserve keys found in /mnt/factotum/ctl");
#	a = _parseattr(p);
#	Bterm(b);
#	key = rsaprivalloc();
#	if((p = _strfindattr(a, "n")) == nil)
#		sysfatal("no n in sshserve key");
#	if((key.n = IPint.strtoip(p, 16)) == nil)
#		sysfatal("bad n in sshserve key");
#	if((p = _strfindattr(a, "ek")) == nil)
#		sysfatal("no ek in sshserve key");
#	if((key.ek = IPint.strtoip(p, 16)) == nil)
#		sysfatal("bad ek in sshserve key");
#	_freeattr(a);
#	if((afd = sys->open("/mnt/factotum/rpc", ORDWR)) == nil)
#		sysfatal("open /mnt/factotum/rpc: %r");
#	if((rpc = auth_allocrpc(afd)) == nil)
#		sysfatal("auth_allocrpc: %r");
#	p = "proto=rsa role=client service=sshserve";
#	if(auth_rpc(rpc, "start", p, len p) != ARok)
#		sysfatal("auth_rpc start %s: %r", p);
#	if(auth_rpc(rpc, "read", nil, 0) != ARok)
#		sysfatal("auth_rpc read: %r");
#	m = strtomp(rpc.arg, nil, 16, nil);
#	if(mpcmp(m, key.n) != 0)
#		sysfatal("key in /mnt/factotum/ctl does not match rpc key");
#	mpfree(m);
#	c.hostkey = key;
}

versioning(fd: ref Sys->FD)
{
	sys->fprint(fd, "SSH-1.5-Inferno\n");
	(maj, min, err_or_id) := sshio->readversion(fd);
	if(maj < 0)
		sysfatal(err_or_id);
	if(maj != 1 || min < 5)
		sysfatal(sys->sprint("protocol mismatch; got %s, need SSH-1.x for x >= 5", err_or_id));
}

authenticate(c: ref Conn)
{
	rpc: ref AuthRpc;

	cookie := array[COOKIELEN] of {* => byte sshio->fastrand()};
	c.sessid = sshio->calcsessid(c.hostkey.n, serverkey.n, cookie);
	send_ssh_smsg_public_key(c, cookie);
	recv_ssh_cmsg_session_key(c, rpc, cookie);
#	afd = nil;
	c.cipher->init(c.sesskey, 1);	#  turns on encryption 
	sendmsg(c, Msg.mk(SSH_SMSG_SUCCESS, 0));
	authsrvuser(c);
}

startcmd(c: ref Conn, cmd: string): (int, ref Sys->FD, chan of (int, string, string))
{
	pfd := array[3] of {* => array[2] of ref Sys->FD};
	for(i := 0; i < 3; i++)
		if(sys->pipe(pfd[i]) < 0)
			sysfatal(sys->sprint("pipe: %r"));
	wfd := sys->open("#p/"+string sys->pctl(0, nil)+"/wait", Sys->OREAD);
	if(wfd == nil)
		sysfatal(sys->sprint("open wait: %r"));
	pidc := chan of int;
	spawn startcmd1(c, cmd, pfd, pidc);
	kidpid := <-pidc;
	(nil, waited) := wait->monitor(wfd);
	spawn copyout(c, pfd[1][0], SSH_SMSG_STDOUT_DATA);
	pfd[1][0] = nil;
	spawn copyout(c, pfd[2][0], SSH_SMSG_STDERR_DATA);
	pfd[2][0] = nil;
	return (kidpid, pfd[0][0], waited);
}

startcmd1(c: ref Conn, cmd: string, pfd: array of array of ref Sys->FD, pidc: chan of int)
{
	sysname := env->getenv("sysname");
	tz := env->getenv("timezone");
	sys->pctl(Sys->FORKFD, nil);
	for(i := 0; i < len pfd; i++)
		if(sys->dup(pfd[i][1].fd, i) < 0)
			sysfatal(sys->sprint("dup: %r"));
	pfd = nil;
	sys->pctl(Sys->NEWPGRP|Sys->FORKNS|Sys->FORKENV|Sys->NEWFD, 0::1::2::nil);
	pidc <-= sys->pctl(0, nil);
	env->setenv("user", c.user);
	if(sysname != nil)
		env->setenv("sysname", sysname);
	if(tz != nil)
		env->setenv("tz", tz);
	if(sys->chdir("/usr/"+c.user) < 0)
		sys->chdir("/");
	if(cmd != nil){
		env->setenv("service", "rx");
		status := sh->run(nil, list of {"/dis/sh.dis", "-lc", cmd});
		if(status != nil)
			raise "fail:"+status;
	}else{
		env->setenv("service", "con");
		#execl("/bin/ip/telnetd", "telnetd", "-tn", nil);	# TO DO: just for echo and line editing
		sys->fprint(sys->fildes(2), "sshserve: cannot run /dis/ip/telnetd: %r");
	}
}

sysfatal(s: string)
{
	sys->print("sysfatal: %s\n", s);
	notegrp(sys->pctl(0, nil), "zap");
	exit;
}

notegrp(pid: int, nil: string)
{
	fd := sys->open("#p/"+string pid+"/ctl", Sys->OWRITE);
	if(fd != nil)
		sys->fprint(fd, "killgrp");
}

sendmsg(c: ref Conn, m: ref Msg)
{
	c.out <-= m;
}