Rawsexprs: module{	PATH:	con "rawsexprs.dis"; 	Sexp: adt {		pick {		String =>			s: string;			hint:	string;		Binary =>			data:	array of byte;			hint: string;		List =>			l:	cyclic list of ref Sexp;		} 		unpack:	fn(a: array of byte): (ref Sexp, array of byte, string);		text:	fn(e: self ref Sexp): string;		packedsize:	fn(e: self ref Sexp): int;		pack:	fn(e: self ref Sexp): array of byte;	}; 	init:	fn();}; SPKI: module{	PATH: con "/dis/lib/spki/spki.dis"; 	Hash: adt {		alg:	string;		hash:	array of byte; 		sexp:	fn(h: self ref Hash): ref Sexprs->Sexp;		text:	fn(h: self ref Hash): string;		eq:	fn(h1: self ref Hash, h2: ref Hash): int;	}; 	Key: adt {		pk:	ref Keyring->PK;	# either pk/sk or hash might be nil		sk:	ref Keyring->SK;		nbits:	int;		halg:	string;	# basic signature hash algorithm		henc:	string;	# pre-signature encoding		hash:	list of ref Hash; 		hashed:	fn(k: self ref Key, alg: string): array of byte;		hashexp:	fn(k: self ref Key, alg: string): ref Hash;		ishash:	fn(k: self ref Key): int;		public:	fn(k: self ref Key): ref Key;		sigalg:	fn(k: self ref Key): string;		text:	fn(k: self ref Key): string;		sexp:	fn(k: self ref Key): ref Sexprs->Sexp;		eq:	fn(k1: self ref Key, k2: ref Key): int;	}; 	Name: adt {		principal:	ref Key;		names:	list of string; 		isprincipal:	fn(n: self ref Name): int;		local:	fn(n: self ref Name): ref Name;		islocal:	fn(n: self ref Name): int;		isprefix:	fn(n1: self ref Name, n2: ref Name): int;		text:	fn(n: self ref Name): string;		sexp:	fn(n: self ref Name): ref Sexprs->Sexp;		eq:	fn(n1: self ref Name, n2: ref Name): int;	}; 	Cert: adt {		e:	ref Sexprs->Sexp;	# S-expression, if originally parsed		issuer:	ref Name;		subject:	ref Subject;		valid:	ref Valid;		pick {		A or KH or O =>	# auth, keyholder or object			delegate:	int;			tag:	ref Sexprs->Sexp;		N =>	# name		} 		text:	fn(c: self ref Cert): string;		sexp:	fn(c: self ref Cert): ref Sexprs->Sexp;	}; 	# the pick might move to a more general `Principal' structure,	# allowing compound and quoting principals	Subject: adt {		pick{		P =>			key:	ref Key;		N =>			name:	ref Name;		O =>			hash:	ref Hash;		KH =>			holder:	ref Name;		T =>			k, n:	int;			subs:	cyclic list of ref Subject;		} 		eq:	fn(s1: self ref Subject, s2: ref Subject): int;		principal:	fn(s: self ref Subject): ref Key;		text:	fn(s: self ref Subject): string;		sexp:	fn(s: self ref Subject): ref Sexprs->Sexp;	}; 	Principal: adt[T] {		pick{		N =>			name:	ref Name;		Q =>			quoter:	T;			quotes:	cyclic ref Principal;		}	}; 	Signature: adt {		hash:	ref Hash;		key:	ref Key;	# find by hash if necessary		sa:	string;	# alg[-[encoding-]hash]		sig:	list of (string, array of byte); 		algs:	fn(s: self ref Signature): (string, string, string);		sexp:	fn(s: self ref Signature): ref Sexprs->Sexp;		text:	fn(s: self ref Signature): string;	}; 	Seqel: adt {		pick{		C =>			c: ref Cert;		K =>			k: ref Key;		O =>			op: string;			args: list of ref Sexprs->Sexp;		S =>			sig: ref Signature;		RV =>	# <reval>			ok:	list of (string, string);			onetime:	array of byte;			valid:	ref Valid;		CRL =>			bad:	list of (string, string);			valid:	ref Valid;		Delta =>			hash:	string;			bad:	list of (string, string);			valid:	ref Valid;		E =>			exp:	ref Sexprs->Sexp;		} 		sexp:	fn(se: self ref Seqel): ref Sexprs->Sexp;		text:	fn(se: self ref Seqel): string;	}; 	Valid: adt {		notbefore:	string;		notafter:	string; 		intersect:	fn(a: self Valid, b: Valid): (int, Valid);		text:	fn(a: self Valid): string;		sexp:	fn(a: self Valid): ref Sexprs->Sexp;	}; 	Toplev: adt {		pick {		C =>			v:	ref Cert;		Sig =>			v:	ref Signature;		K =>			v:	ref Key;		Seq =>			v:	list of ref Seqel;		} 		sexp:	fn(t: self ref Toplev): ref Sexprs->Sexp;		text:	fn(t: self ref Toplev): string;	}; 	init:	fn(); 	# parse structures	parse:	fn(s: ref Sexprs->Sexp): (ref Toplev, string);	parseseq:	fn(s: ref Sexprs->Sexp): list of ref Seqel;	parsecert:	fn(s: ref Sexprs->Sexp): ref Cert;	parsesig:	fn(s: ref Sexprs->Sexp): ref Signature;	parsename:	fn(s: ref Sexprs->Sexp): ref Name;	parsekey:	fn(s: ref Sexprs->Sexp): ref Key;	parsehash:	fn(s: ref Sexprs->Sexp): ref Hash;	parsecompound:	fn(s: ref Sexprs->Sexp): ref Name;	parsevalid:	fn(s: ref Sexprs->Sexp): ref Valid; 	# signature checking	checksig:	fn(c: ref Cert, sig: ref Signature): string;	sig2icert:	fn(sig: ref Signature, signer: string, exp: int): ref Keyring->Certificate; 	# signature making	signcert:	fn(c: ref Cert, sigalg: string, key: ref Key): (ref Signature, string);	signbytes:	fn(a: array of byte, sigalg: string, key: ref Key): (ref Signature, string); 	# tags	maketag:	fn(e: ref Sexprs->Sexp): ref Sexprs->Sexp;	tagintersect:	fn(t1: ref Sexprs->Sexp, t2: ref Sexprs->Sexp): ref Sexprs->Sexp;	tagimplies:	fn(t1: ref Sexprs->Sexp, t2: ref Sexprs->Sexp): int; 	# hash canonical s-expression	hashbytes:	fn(a: array of byte, alg: string): array of byte;	hashexp:	fn(e: ref Sexprs->Sexp, alg: string): array of byte; 	# convert between date and time strings and Inferno form	date2epoch:	fn(s: string): int;	# YYYY-MM-DD_HH:MM:SS	epoch2date:	fn(t: int): string;	time2secs:	fn(s: string): int;	# HH:MM:SS	secs2time:	fn(t: int): string; 	# misc	sigalgs:	fn(algs: string): (string, string, string); 	# debugging	dump:	fn(s: string, a: array of byte);}; Proofs: module{	Proof: adt {		n:	int; 		parse:	fn(s: string): ref Proof;		sexp:	fn(p: self ref Proof): ref Sexprs->Sexp;		text:	fn(p: self ref Proof): string;	}; 	init:	fn(): string;}; Verifier: module{	PATH:	con "/dis/lib/spki/verifier.dis"; 	Speaksfor: adt {		subject:	ref SPKI->Subject;		name:	ref SPKI->Name;		regarding:	ref Sexprs->Sexp;		valid:	ref SPKI->Valid;	}; 	init:	fn();	verify:	fn(seq: list of ref SPKI->Seqel): (ref Speaksfor, list of ref SPKI->Seqel, string);};