20080116-0125

5 files changed, 883 insertions, 40 deletions

diff --git a/libinterp/ipint.c b/libinterp/ipint.c
index b7cb8af2..d81fccf4 100644
--- a/libinterp/ipint.c
+++ b/libinterp/ipint.c
@@ -46,6 +46,44 @@ freeIPint(Heap *h, int swept)
 }
 
 void
+IPint_iptob64z(void *fp)
+{
+	F_IPint_iptob64 *f;
+	BigInt b;
+	char buf[MaxBigBytes];	/* TO DO: should allocate these */
+	uchar *p;
+	int n, o;
+
+	f = fp;
+	destroy(*f->ret);
+	*f->ret = H;
+
+	if(f->i == H)
+		error(exNilref);
+
+	b = MP(f->i);
+	n = (b->top+1)*Dbytes;
+	p = malloc(n+1);
+	if(p == nil)
+		error(exHeap);
+	n = mptobe(b, p+1, n, nil);
+	if(n < 0){
+		free(p);
+		return;
+	}
+	p[0] = 0;
+	if(n != 0 && (p[1]&0x80)){
+		/* force leading 0 byte for compatibility with older representation */
+		o = 0;
+		n++;
+	}else
+		o = 1;
+	enc64(buf, sizeof(buf), p+o, n);
+	retstr(buf, f->ret);
+	free(p);
+}
+
+void
 IPint_iptob64(void *fp)
 {
 	F_IPint_iptob64 *f;
@@ -112,21 +150,33 @@ IPint_iptostr(void *fp)
 	retstr(buf, f->ret);
 }
 
+static Keyring_IPint*
+strtoipint(String *s, int base)
+{
+	char *p, *q;
+	BigInt b;
+
+	p = string2c(s);
+	b = strtomp(p, &q, base, nil);
+	if(b == nil)
+		return H;
+	if(q == p || *q != 0){
+		mpfree(b);
+		return H;
+	}
+	return newIPint(b);
+}
+
 void
 IPint_b64toip(void *fp)
 {
 	F_IPint_b64toip *f;
-	BigInt b;
 
 	f = fp;
 	destroy(*f->ret);
 	*f->ret = H;
 
-	if(f->str == H)
-		error(exNilref);
-
-	b = strtomp(string2c(f->str), nil, 64, nil);
-	*f->ret = newIPint(b);
+	*f->ret = strtoipint(f->str, 64);
 }
 
 void
@@ -167,17 +217,12 @@ void
 IPint_strtoip(void *fp)
 {
 	F_IPint_strtoip *f;
-	BigInt b;
 
 	f = fp;
 	destroy(*f->ret);
 	*f->ret = H;
 
-	if(f->str == H)
-		return;
-
-	b = strtomp(string2c(f->str), nil, f->base, nil);
-	*f->ret = newIPint(b);
+	*f->ret = strtoipint(f->str, f->base);
 }
 
 /* create a random integer */
@@ -384,6 +429,27 @@ IPint_div(void *fp)
 	f->ret->t1 = newIPint(rem);
 }
 void
+IPint_mod(void *fp)
+{
+	F_IPint_mod *f;
+	BigInt i1, i2, ret;
+
+	f = fp;
+	destroy(*f->ret);
+	*f->ret = H;
+
+	if(f->i1 == H || f->i2 == H)
+		error(exNilref);
+
+	i1 = ((IPint*)f->i1)->b;
+	i2 = ((IPint*)f->i2)->b;
+	ret = mpnew(0);
+	if(ret != nil)
+		mpmod(i1, i2, ret);
+
+	*f->ret = newIPint(ret);
+}
+void
 IPint_neg(void *fp)
 {
 	F_IPint_neg *f;
@@ -669,6 +735,7 @@ if(0)print("1");
 
 	two = itomp(2, nil);
 	if(mpcmp(diff, two) < 0){
+		mpfree(one);
 		mpfree(two);
 		itomp(0, result);
 		return;
diff --git a/libinterp/keyring.c b/libinterp/keyring.c
index 20ce610c..57a2095d 100644
--- a/libinterp/keyring.c
+++ b/libinterp/keyring.c
@@ -26,8 +26,18 @@ Type	*TAuthinfo;
 Type *TAESstate;
 Type	*TDESstate;
 Type *TIDEAstate;
+Type *TBFstate;
 Type	*TRC4state;
 Type	*TIPint;
+Type *TDSAsk;
+Type *TDSApk;
+Type *TDSAsig;
+Type *TEGsk;
+Type *TEGpk;
+Type *TEGsig;
+Type *TRSAsk;
+Type *TRSApk;
+Type *TRSAsig;
 
 enum {
 	Maxmsg=	4096
@@ -43,7 +53,17 @@ uchar Authinfomap[] = Keyring_Authinfo_map;
 uchar AESstatemap[] = Keyring_AESstate_map;
 uchar DESstatemap[] = Keyring_DESstate_map;
 uchar IDEAstatemap[] = Keyring_IDEAstate_map;
+uchar BFstatemap[] = Keyring_BFstate_map;
 uchar RC4statemap[] = Keyring_RC4state_map;
+uchar DSAskmap[] = Keyring_DSAsk_map;
+uchar DSApkmap[] = Keyring_DSApk_map;
+uchar DSAsigmap[] = Keyring_DSAsig_map;
+uchar EGskmap[] = Keyring_EGsk_map;
+uchar EGpkmap[] = Keyring_EGpk_map;
+uchar EGsigmap[] = Keyring_EGsig_map;
+uchar RSAskmap[] = Keyring_RSAsk_map;
+uchar RSApkmap[] = Keyring_RSApk_map;
+uchar RSAsigmap[] = Keyring_RSAsig_map;
 
 PK*	checkPK(Keyring_PK *k);
 
@@ -57,6 +77,15 @@ static char exBadSK[]	= "bad secret key";
 static char exBadPK[]	= "bad public key";
 static char exBadCert[]	= "bad certificate";
 
+typedef struct XBFstate XBFstate;
+
+/* BF state */
+struct XBFstate
+{
+	Keyring_BFstate	x;
+	BFstate	state;
+};
+
 /*
  *  Infinite (actually kind of big) precision integers
  */
@@ -114,6 +143,38 @@ big64conv(Fmt *f)
 	return  n;
 }
 
+static BigInt
+checkIPint(Keyring_IPint *v)
+{
+	IPint *ip;
+
+	ip = (IPint*)v;
+	if(ip == H || ip == nil)
+		error(exNilref);
+	if(D2H(ip)->t != TIPint)
+		error(exType);
+	return ip->b;
+}
+
+static void*
+newthing(Type *t, int add)
+{
+	Heap *h;
+
+	h = heap(t);
+	if(add)
+		ptradd(h);
+	return H2D(void*, h);
+}
+
+static Keyring_IPint*
+ipcopymp(BigInt b)
+{
+	if(b == nil)
+		return H;
+	return newIPint(mpcopy(b));
+}
+
 /* convert a base64 string to a big */
 BigInt
 base64tobig(char *str, char **strp)
@@ -949,17 +1010,6 @@ Keyring_sign(void *fp)
 	mpfree(b);
 }
 
-static BigInt
-checkIPint(Keyring_IPint *v)
-{
-	IPint *ip;
-
-	ip = (IPint*)v;
-	if(ip == H || ip == nil || D2H(ip)->t != TIPint)
-		error(exType);
-	return ip->b;
-}
-
 void
 Keyring_signm(void *fp)
 {
@@ -2003,9 +2053,20 @@ keyringmodinit(void)
 		sizeof(DESstatemap));
 	TIDEAstate = dtype(freeheap, sizeof(XIDEAstate), IDEAstatemap,
 		sizeof(IDEAstatemap));
+	TBFstate = dtype(freeheap, sizeof(XBFstate), BFstatemap,
+		sizeof(BFstatemap));
 	TRC4state = dtype(freeheap, sizeof(XRC4state), RC4statemap,
 		sizeof(RC4statemap));
 	TAuthinfo = dtype(freeheap, sizeof(Keyring_Authinfo), Authinfomap, sizeof(Authinfomap));
+	TDSAsk = dtype(freeheap, sizeof(Keyring_DSAsk), DSAskmap, sizeof(DSAskmap));
+	TDSApk = dtype(freeheap, sizeof(Keyring_DSApk), DSApkmap, sizeof(DSApkmap));
+	TDSAsig = dtype(freeheap, sizeof(Keyring_DSAsig), DSAsigmap, sizeof(DSAsigmap));
+	TEGsk = dtype(freeheap, sizeof(Keyring_EGsk), EGskmap, sizeof(EGskmap));
+	TEGpk = dtype(freeheap, sizeof(Keyring_EGpk), EGpkmap, sizeof(EGpkmap));
+	TEGsig = dtype(freeheap, sizeof(Keyring_EGsig), EGsigmap, sizeof(EGsigmap));
+	TRSAsk = dtype(freeheap, sizeof(Keyring_RSAsk), RSAskmap, sizeof(RSAskmap));
+	TRSApk = dtype(freeheap, sizeof(Keyring_RSApk), RSApkmap, sizeof(RSApkmap));
+	TRSAsig = dtype(freeheap, sizeof(Keyring_RSAsig), RSAsigmap, sizeof(RSAsigmap));
 
 	if((sav = elgamalinit()) != nil)
 		algs[nalg++] = sav;
@@ -2201,9 +2262,9 @@ Keyring_dessetup(void *fp)
 	destroy(*f->ret);
 	*f->ret = H;
 
-	if(f->key == (Array*)H)
+	if(f->key == H)
 		return;
-	if(f->ivec == (Array*)H)
+	if(f->ivec == H)
 		ivec = 0;
 	else
 		ivec = f->ivec->data;
@@ -2231,7 +2292,7 @@ Keyring_desecb(void *fp)
 
 	if(f->state == (Keyring_DESstate*)H)
 		return;
-	if(f->buf == (Array*)H)
+	if(f->buf == H)
 		return;
 	if(f->buf->len < f->n)
 		f->n = f->buf->len;
@@ -2255,9 +2316,9 @@ Keyring_descbc(void *fp)
 
 	f = fp;
 
-	if(f->state == (Keyring_DESstate*)H)
+	if(f->state == H)
 		return;
-	if(f->buf == (Array*)H)
+	if(f->buf == H)
 		return;
 	if(f->buf->len < f->n)
 		f->n = f->buf->len;
@@ -2450,6 +2511,63 @@ Keyring_aescbc(void *fp)
 }
 
 void
+Keyring_blowfishsetup(void *fp)
+{
+	F_Keyring_blowfishsetup *f;
+	Heap *h;
+	XBFstate *is;
+	uchar *ivec;
+
+	f = fp;
+	destroy(*f->ret);
+	*f->ret = H;
+
+	if(f->key == (Array*)H)
+		return;
+	if(f->ivec == (Array*)H)
+		ivec = nil;
+	else
+		ivec = f->ivec->data;
+
+	if(f->key->len <= 0)
+		return;
+	if(ivec && f->ivec->len != BFbsize)
+		return;
+
+	h = heap(TBFstate);
+	is = H2D(XBFstate*, h);
+
+	setupBFstate(&is->state, f->key->data, f->key->len, ivec);
+
+	*f->ret = (Keyring_BFstate*)is;
+}
+
+void
+Keyring_blowfishcbc(void *fp)
+{
+	F_Keyring_blowfishcbc *f;
+	XBFstate *is;
+	uchar *p;
+
+	f = fp;
+
+	if(f->state == (Keyring_BFstate*)H)
+		return;
+	if(f->buf == (Array*)H)
+		return;
+	if(f->buf->len < f->n)
+		f->n = f->buf->len;
+
+	is = (XBFstate*)f->state;
+	p = f->buf->data;
+
+	if(f->direction == 0)
+		bfCBCencrypt(p, f->n, &is->state);
+	else
+		bfCBCdecrypt(p, f->n, &is->state);
+}
+
+void
 Keyring_rc4setup(void *fp)
 {
 	F_Keyring_rc4setup *f;
@@ -2515,3 +2633,397 @@ Keyring_rc4back(void *fp)
 	is = (XRC4state*)f->state;
 	rc4back(&is->state, f->n);
 }
+
+/*
+ *  public/secret keys, signing and verifying
+ */
+
+static void
+dsapk2pub(DSApub* p, Keyring_DSApk* pk)
+{
+	if(pk == H)
+		error(exNilref);
+	p->p = checkIPint(pk->p);
+	p->q = checkIPint(pk->q);
+	p->alpha = checkIPint(pk->alpha);
+	p->key = checkIPint(pk->key);
+}
+
+static void
+dsask2priv(DSApriv* p, Keyring_DSAsk* sk)
+{
+	if(sk == H || sk->pk == H)
+		error(exNilref);
+	dsapk2pub(&p->pub, sk->pk);
+	p->secret = checkIPint(sk->secret);
+}
+
+static void
+dsapriv2sk(Keyring_DSAsk* sk, DSApriv* p)
+{
+	Keyring_DSApk* pk;
+
+	pk = sk->pk;
+	pk->p = ipcopymp(p->pub.p);
+	pk->q = ipcopymp(p->pub.q);
+	pk->alpha = ipcopymp(p->pub.alpha);
+	pk->key = ipcopymp(p->pub.key);
+	sk->secret = ipcopymp(p->secret);
+}
+
+void
+DSAsk_gen(void *fp)
+{
+	F_DSAsk_gen *f;
+	Keyring_DSAsk *sk;
+	DSApriv *p;
+	DSApub pub, *oldpk;
+	void *v;
+
+	f = fp;
+	v = *f->ret;
+	sk = newthing(TDSAsk, 0);
+	sk->pk = newthing(TDSApk, 0);
+	*f->ret = sk;
+	destroy(v);
+	oldpk = nil;
+	if(f->oldpk != H){
+		dsapk2pub(&pub, f->oldpk);
+		oldpk = &pub;
+	}
+	release();
+	p = dsagen(oldpk);
+	acquire();
+	dsapriv2sk(sk, p);
+	dsaprivfree(p);
+}
+
+void
+DSAsk_sign(void *fp)
+{
+	F_DSAsk_sign *f;
+	Keyring_DSAsig *sig;
+	DSApriv p;
+	BigInt m;
+	DSAsig *s;
+	void *v;
+
+	f = fp;
+	v = *f->ret;
+	sig = newthing(TDSAsig, 0);
+	*f->ret = sig;
+	destroy(v);
+
+	dsask2priv(&p, f->k);
+	m = checkIPint(f->m);
+	release();
+	s = dsasign(&p, m);
+	acquire();
+	sig->r = ipcopymp(s->r);
+	sig->s = ipcopymp(s->s);
+	dsasigfree(s);
+}
+
+void
+DSApk_verify(void *fp)
+{
+	F_DSApk_verify *f;
+	DSApub p;
+	DSAsig sig;
+	BigInt m;
+
+	f = fp;
+	*f->ret = 0;
+	if(f->m == H || f->sig == H)
+		return;
+	dsapk2pub(&p, f->k);
+	sig.r = checkIPint(f->sig->r);
+	sig.s = checkIPint(f->sig->s);
+	m = checkIPint(f->m);
+	release();
+	*f->ret = dsaverify(&p, &sig, m) == 0;
+	acquire();
+}
+
+static void
+egpk2pub(EGpub* p, Keyring_EGpk* pk)
+{
+	if(pk == H)
+		error(exNilref);
+	p->p = checkIPint(pk->p);
+	p->alpha = checkIPint(pk->alpha);
+	p->key = checkIPint(pk->key);
+}
+
+static void
+egsk2priv(EGpriv* p, Keyring_EGsk* sk)
+{
+	if(sk == H || sk->pk == H)
+		error(exNilref);
+	egpk2pub(&p->pub, sk->pk);
+	p->secret = checkIPint(sk->secret);
+}
+
+static void
+egpriv2sk(Keyring_EGsk* sk, EGpriv* p)
+{
+	Keyring_EGpk* pk;
+
+	pk = sk->pk;
+	pk->p = ipcopymp(p->pub.p);
+	pk->alpha = ipcopymp(p->pub.alpha);
+	pk->key = ipcopymp(p->pub.key);
+	sk->secret = ipcopymp(p->secret);
+}
+
+void
+EGsk_gen(void *fp)
+{
+	F_EGsk_gen *f;
+	Keyring_EGsk *sk;
+	EGpriv *p;
+	void *v;
+
+	f = fp;
+	v = *f->ret;
+	sk = newthing(TEGsk, 0);
+	sk->pk = newthing(TEGpk, 0);
+	*f->ret = sk;
+	destroy(v);
+	release();
+	for(;;){
+		p = eggen(f->nlen, f->nrep);
+		if(mpsignif(p->pub.p) == f->nlen)
+			break;
+		egprivfree(p);
+	}
+	acquire();
+	egpriv2sk(sk, p);
+	egprivfree(p);
+}
+
+void
+EGsk_sign(void *fp)
+{
+	F_EGsk_sign *f;
+	Keyring_EGsig *sig;
+	EGpriv p;
+	BigInt m;
+	EGsig *s;
+	void *v;
+
+	f = fp;
+	v = *f->ret;
+	sig = newthing(TEGsig, 0);
+	*f->ret = sig;
+	destroy(v);
+
+	egsk2priv(&p, f->k);
+	m = checkIPint(f->m);
+	release();
+	s = egsign(&p, m);
+	acquire();
+	sig->r = ipcopymp(s->r);
+	sig->s = ipcopymp(s->s);
+	egsigfree(s);
+}
+
+void
+EGpk_verify(void *fp)
+{
+	F_EGpk_verify *f;
+	EGpub p;
+	EGsig sig;
+	BigInt m;
+
+	f = fp;
+	*f->ret = 0;
+	if(f->m == H || f->sig == H)
+		return;
+	egpk2pub(&p, f->k);
+	sig.r = checkIPint(f->sig->r);
+	sig.s = checkIPint(f->sig->s);
+	m = checkIPint(f->m);
+	release();
+	*f->ret = egverify(&p, &sig, m) == 0;
+	acquire();
+}
+
+static void
+rsapk2pub(RSApub* p, Keyring_RSApk* pk)
+{
+	if(pk == H)
+		error(exNilref);
+	memset(p, 0, sizeof(*p));
+	p->n = checkIPint(pk->n);
+	p->ek = checkIPint(pk->ek);
+}
+
+static void
+rsask2priv(RSApriv* p, Keyring_RSAsk* sk)
+{
+	if(sk == H || sk->pk == H)
+		error(exNilref);
+	rsapk2pub(&p->pub, sk->pk);
+	p->dk = checkIPint(sk->dk);
+	p->p = checkIPint(sk->p);
+	p->q = checkIPint(sk->q);
+	p->kp = checkIPint(sk->kp);
+	p->kq = checkIPint(sk->kq);
+	p->c2 = checkIPint(sk->c2);
+}
+
+static void
+rsapriv2sk(Keyring_RSAsk* sk, RSApriv* p)
+{
+	Keyring_RSApk* pk;
+
+	pk = sk->pk;
+	pk->n = ipcopymp(p->pub.n);
+	pk->ek = ipcopymp(p->pub.ek);
+	sk->dk = ipcopymp(p->dk);
+	sk->p = ipcopymp(p->p);
+	sk->q = ipcopymp(p->q);
+	sk->kp = ipcopymp(p->kp);
+	sk->kq = ipcopymp(p->kq);
+	sk->c2 = ipcopymp(p->c2);
+}
+
+void
+RSApk_encrypt(void *fp)
+{
+	F_RSApk_encrypt *f;
+	RSApub p;
+	BigInt m, o;
+	void *v;
+
+	f = fp;
+	v = *f->ret;
+	*f->ret = H;
+	destroy(v);
+
+	rsapk2pub(&p, f->k);
+	m = checkIPint(f->m);
+	release();
+	o = rsaencrypt(&p, m, nil);
+	acquire();
+	*f->ret = newIPint(o);
+}
+
+void
+RSAsk_gen(void *fp)
+{
+	F_RSAsk_gen *f;
+	Keyring_RSAsk *sk;
+	RSApriv *p;
+	void *v;
+
+	f = fp;
+	v = *f->ret;
+	sk = newthing(TRSAsk, 0);
+	sk->pk = newthing(TRSApk, 0);
+	*f->ret = sk;
+	destroy(v);
+	release();
+	for(;;){
+		p = rsagen(f->nlen, f->elen, f->nrep);
+		if(mpsignif(p->pub.n) == f->nlen)
+			break;
+		rsaprivfree(p);
+	}
+	acquire();
+	rsapriv2sk(sk, p);
+	rsaprivfree(p);
+}
+
+void
+RSAsk_fill(void *fp)
+{
+	F_RSAsk_fill *f;
+	Keyring_RSAsk *sk;
+	RSApriv *p;
+	void *v;
+
+	f = fp;
+	v = *f->ret;
+	sk = newthing(TRSAsk, 0);
+	sk->pk = newthing(TRSApk, 0);
+	*f->ret = sk;
+	destroy(v);
+	release();
+	p = rsafill(checkIPint(f->n), checkIPint(f->e), checkIPint(f->d),
+			checkIPint(f->p), checkIPint(f->q));
+	acquire();
+	if(p == nil) {
+		*f->ret = H;
+		destroy(sk);
+	}else{
+		rsapriv2sk(sk, p);
+		rsaprivfree(p);
+	}
+}
+
+void
+RSAsk_decrypt(void *fp)
+{
+	F_RSAsk_decrypt *f;
+	RSApriv p;
+	BigInt m, o;
+	void *v;
+
+	f = fp;
+	v = *f->ret;
+	*f->ret = H;
+	destroy(v);
+
+	rsask2priv(&p, f->k);
+	m = checkIPint(f->m);
+	release();
+	o = rsadecrypt(&p, m, nil);
+	acquire();
+	*f->ret = newIPint(o);
+}
+
+void
+RSAsk_sign(void *fp)
+{
+	F_RSAsk_sign *f;
+	Keyring_RSAsig *sig;
+	RSApriv p;
+	BigInt m, s;
+	void *v;
+
+	f = fp;
+	v = *f->ret;
+	sig = newthing(TRSAsig, 0);
+	*f->ret = sig;
+	destroy(v);
+
+	rsask2priv(&p, f->k);
+	m = checkIPint(f->m);
+	release();
+	s = rsadecrypt(&p, m, nil);
+	acquire();
+	sig->n = newIPint(s);
+}
+
+void
+RSApk_verify(void *fp)
+{
+	F_RSApk_verify *f;
+	RSApub p;
+	BigInt sig, m, t;
+
+	f = fp;
+	*f->ret = 0;
+	if(f->m == H || f->sig == H)
+		return;
+	rsapk2pub(&p, f->k);
+	sig = checkIPint(f->sig->n);
+	m = checkIPint(f->m);
+	release();
+	t = rsaencrypt(&p, sig, nil);
+	*f->ret = mpcmp(t, m) == 0;
+	mpfree(t);
+	acquire();
+}
diff --git a/libinterp/keyring.h b/libinterp/keyring.h
index 0bea5171..0aa4185a 100644
--- a/libinterp/keyring.h
+++ b/libinterp/keyring.h
@@ -8,19 +8,27 @@ Runtab Keyringmodtab[]={
 	"IPint.b64toip",0xa803ee03,IPint_b64toip,40,2,{0x0,0x80,},
 	"IPint.bebytestoip",0x6fa90725,IPint_bebytestoip,40,2,{0x0,0x80,},
 	"IPint.bits",0xeb4c9bad,IPint_bits,40,2,{0x0,0x80,},
+	"blowfishcbc",0xac616ba,Keyring_blowfishcbc,48,2,{0x0,0xc0,},
+	"blowfishsetup",0x44452583,Keyring_blowfishsetup,40,2,{0x0,0xc0,},
 	"IPint.bytestoip",0x6fa90725,IPint_bytestoip,40,2,{0x0,0x80,},
 	"certtoattr",0xbc65254a,Keyring_certtoattr,40,2,{0x0,0x80,},
 	"certtostr",0xbc65254a,Keyring_certtostr,40,2,{0x0,0x80,},
 	"IPint.cmp",0x79774f9e,IPint_cmp,40,2,{0x0,0xc0,},
 	"IPint.copy",0x491fbd11,IPint_copy,40,2,{0x0,0x80,},
 	"DigestState.copy",0x491fbd11,DigestState_copy,40,2,{0x0,0x80,},
+	"RSAsk.decrypt",0xf3b51b95,RSAsk_decrypt,40,2,{0x0,0xc0,},
 	"descbc",0xac616ba,Keyring_descbc,48,2,{0x0,0xc0,},
 	"desecb",0xac616ba,Keyring_desecb,48,2,{0x0,0xc0,},
 	"dessetup",0x44452583,Keyring_dessetup,40,2,{0x0,0xc0,},
 	"dhparams",0x6abb2418,Keyring_dhparams,40,0,{0},
 	"IPint.div",0x4672bf61,IPint_div,40,2,{0x0,0xc0,},
+	"RSApk.encrypt",0xdc0ec366,RSApk_encrypt,40,2,{0x0,0xc0,},
 	"IPint.eq",0x79774f9e,IPint_eq,40,2,{0x0,0xc0,},
 	"IPint.expmod",0xe6105024,IPint_expmod,48,2,{0x0,0xe0,},
+	"RSAsk.fill",0x2ab0d50a,RSAsk_fill,56,2,{0x0,0xf8,},
+	"RSAsk.gen",0xc197fd0,RSAsk_gen,48,0,{0},
+	"DSAsk.gen",0x46f0eb94,DSAsk_gen,40,2,{0x0,0x80,},
+	"EGsk.gen",0x4a59c528,EGsk_gen,40,0,{0},
 	"genSK",0xadd8cbd9,Keyring_genSK,48,2,{0x0,0xc0,},
 	"genSKfromPK",0x5416d1ee,Keyring_genSKfromPK,40,2,{0x0,0xc0,},
 	"getbytearray",0x4e02ce80,Keyring_getbytearray,40,2,{0x0,0x80,},
@@ -34,12 +42,14 @@ Runtab Keyringmodtab[]={
 	"IPint.inttoip",0x95dc8b6d,IPint_inttoip,40,0,{0},
 	"IPint.invert",0xa47c1b24,IPint_invert,40,2,{0x0,0xc0,},
 	"IPint.iptob64",0xfab4eb8a,IPint_iptob64,40,2,{0x0,0x80,},
+	"IPint.iptob64z",0xfab4eb8a,IPint_iptob64z,40,2,{0x0,0x80,},
 	"IPint.iptobebytes",0xc8e5162d,IPint_iptobebytes,40,2,{0x0,0x80,},
 	"IPint.iptobytes",0xc8e5162d,IPint_iptobytes,40,2,{0x0,0x80,},
 	"IPint.iptoint",0xeb4c9bad,IPint_iptoint,40,2,{0x0,0x80,},
 	"IPint.iptostr",0xf9fdc03d,IPint_iptostr,40,2,{0x0,0x80,},
 	"md4",0x7656377,Keyring_md4,48,2,{0x0,0xb0,},
 	"md5",0x7656377,Keyring_md5,48,2,{0x0,0xb0,},
+	"IPint.mod",0xa47c1b24,IPint_mod,40,2,{0x0,0xc0,},
 	"IPint.mul",0xa47c1b24,IPint_mul,40,2,{0x0,0xc0,},
 	"IPint.neg",0x491fbd11,IPint_neg,40,2,{0x0,0x80,},
 	"IPint.not",0x491fbd11,IPint_not,40,2,{0x0,0x80,},
@@ -61,6 +71,9 @@ Runtab Keyringmodtab[]={
 	"IPint.shl",0xc7b0bc01,IPint_shl,40,2,{0x0,0x80,},
 	"IPint.shr",0xc7b0bc01,IPint_shr,40,2,{0x0,0x80,},
 	"sign",0xdacb7a7e,Keyring_sign,48,2,{0x0,0xb0,},
+	"RSAsk.sign",0x5dbdc2fe,RSAsk_sign,40,2,{0x0,0xc0,},
+	"DSAsk.sign",0x6e51e1b3,DSAsk_sign,40,2,{0x0,0xc0,},
+	"EGsk.sign",0xca053e70,EGsk_sign,40,2,{0x0,0xc0,},
 	"signm",0xba5bd10f,Keyring_signm,48,2,{0x0,0xe0,},
 	"sktoattr",0xfb4e61ba,Keyring_sktoattr,40,2,{0x0,0x80,},
 	"sktopk",0x6f74c7c9,Keyring_sktopk,40,2,{0x0,0x80,},
@@ -71,9 +84,12 @@ Runtab Keyringmodtab[]={
 	"strtosk",0xcc511522,Keyring_strtosk,40,2,{0x0,0x80,},
 	"IPint.sub",0xa47c1b24,IPint_sub,40,2,{0x0,0xc0,},
 	"verify",0x8b5b9f76,Keyring_verify,48,2,{0x0,0xe0,},
+	"RSApk.verify",0x1857beff,RSApk_verify,48,2,{0x0,0xe0,},
+	"DSApk.verify",0xeca448ff,DSApk_verify,48,2,{0x0,0xe0,},
+	"EGpk.verify",0xfb1e256c,EGpk_verify,48,2,{0x0,0xe0,},
 	"verifym",0x8b5b9f76,Keyring_verifym,48,2,{0x0,0xe0,},
 	"writeauthinfo",0x5ba03002,Keyring_writeauthinfo,40,2,{0x0,0xc0,},
 	"IPint.xor",0xa47c1b24,IPint_xor,40,2,{0x0,0xc0,},
 	0
 };
-#define Keyringmodlen	74
+#define Keyringmodlen	90
diff --git a/libinterp/runt.h b/libinterp/runt.h
index e9342d08..75144e0c 100644
--- a/libinterp/runt.h
+++ b/libinterp/runt.h
@@ -31,7 +31,17 @@ typedef struct Keyring_AESstate Keyring_AESstate;
 typedef struct Keyring_DESstate Keyring_DESstate;
 typedef struct Keyring_IDEAstate Keyring_IDEAstate;
 typedef struct Keyring_RC4state Keyring_RC4state;
+typedef struct Keyring_BFstate Keyring_BFstate;
 typedef struct Keyring_Authinfo Keyring_Authinfo;
+typedef struct Keyring_RSApk Keyring_RSApk;
+typedef struct Keyring_RSAsk Keyring_RSAsk;
+typedef struct Keyring_RSAsig Keyring_RSAsig;
+typedef struct Keyring_DSApk Keyring_DSApk;
+typedef struct Keyring_DSAsk Keyring_DSAsk;
+typedef struct Keyring_DSAsig Keyring_DSAsig;
+typedef struct Keyring_EGpk Keyring_EGpk;
+typedef struct Keyring_EGsk Keyring_EGsk;
+typedef struct Keyring_EGsig Keyring_EGsig;
 typedef struct Loader_Inst Loader_Inst;
 typedef struct Loader_Typedesc Loader_Typedesc;
 typedef struct Loader_Link Loader_Link;
@@ -337,6 +347,12 @@ struct Keyring_RC4state
 };
 #define Keyring_RC4state_size 4
 #define Keyring_RC4state_map {0}
+struct Keyring_BFstate
+{
+	WORD	x;
+};
+#define Keyring_BFstate_size 4
+#define Keyring_BFstate_map {0}
 struct Keyring_Authinfo
 {
 	Keyring_SK*	mysk;
@@ -348,6 +364,76 @@ struct Keyring_Authinfo
 };
 #define Keyring_Authinfo_size 24
 #define Keyring_Authinfo_map {0xfc,}
+struct Keyring_RSApk
+{
+	Keyring_IPint*	n;
+	Keyring_IPint*	ek;
+};
+#define Keyring_RSApk_size 8
+#define Keyring_RSApk_map {0xc0,}
+struct Keyring_RSAsk
+{
+	Keyring_RSApk*	pk;
+	Keyring_IPint*	dk;
+	Keyring_IPint*	p;
+	Keyring_IPint*	q;
+	Keyring_IPint*	kp;
+	Keyring_IPint*	kq;
+	Keyring_IPint*	c2;
+};
+#define Keyring_RSAsk_size 28
+#define Keyring_RSAsk_map {0xfe,}
+struct Keyring_RSAsig
+{
+	Keyring_IPint*	n;
+};
+#define Keyring_RSAsig_size 4
+#define Keyring_RSAsig_map {0x80,}
+struct Keyring_DSApk
+{
+	Keyring_IPint*	p;
+	Keyring_IPint*	q;
+	Keyring_IPint*	alpha;
+	Keyring_IPint*	key;
+};
+#define Keyring_DSApk_size 16
+#define Keyring_DSApk_map {0xf0,}
+struct Keyring_DSAsk
+{
+	Keyring_DSApk*	pk;
+	Keyring_IPint*	secret;
+};
+#define Keyring_DSAsk_size 8
+#define Keyring_DSAsk_map {0xc0,}
+struct Keyring_DSAsig
+{
+	Keyring_IPint*	r;
+	Keyring_IPint*	s;
+};
+#define Keyring_DSAsig_size 8
+#define Keyring_DSAsig_map {0xc0,}
+struct Keyring_EGpk
+{
+	Keyring_IPint*	p;
+	Keyring_IPint*	alpha;
+	Keyring_IPint*	key;
+};
+#define Keyring_EGpk_size 12
+#define Keyring_EGpk_map {0xe0,}
+struct Keyring_EGsk
+{
+	Keyring_EGpk*	pk;
+	Keyring_IPint*	secret;
+};
+#define Keyring_EGsk_size 8
+#define Keyring_EGsk_map {0xc0,}
+struct Keyring_EGsig
+{
+	Keyring_IPint*	r;
+	Keyring_IPint*	s;
+};
+#define Keyring_EGsig_size 8
+#define Keyring_EGsig_map {0xc0,}
 struct Loader_Inst
 {
 	BYTE	op;
@@ -3135,6 +3221,28 @@ struct F_IPint_bits
 	uchar	temps[12];
 	Keyring_IPint*	i;
 };
+void Keyring_blowfishcbc(void*);
+typedef struct F_Keyring_blowfishcbc F_Keyring_blowfishcbc;
+struct F_Keyring_blowfishcbc
+{
+	WORD	regs[NREG-1];
+	WORD	noret;
+	uchar	temps[12];
+	Keyring_BFstate*	state;
+	Array*	buf;
+	WORD	n;
+	WORD	direction;
+};
+void Keyring_blowfishsetup(void*);
+typedef struct F_Keyring_blowfishsetup F_Keyring_blowfishsetup;
+struct F_Keyring_blowfishsetup
+{
+	WORD	regs[NREG-1];
+	Keyring_BFstate**	ret;
+	uchar	temps[12];
+	Array*	key;
+	Array*	ivec;
+};
 void IPint_bytestoip(void*);
 typedef struct F_IPint_bytestoip F_IPint_bytestoip;
 struct F_IPint_bytestoip
@@ -3190,6 +3298,16 @@ struct F_DigestState_copy
 	uchar	temps[12];
 	Keyring_DigestState*	d;
 };
+void RSAsk_decrypt(void*);
+typedef struct F_RSAsk_decrypt F_RSAsk_decrypt;
+struct F_RSAsk_decrypt
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_RSAsk*	k;
+	Keyring_IPint*	m;
+};
 void Keyring_descbc(void*);
 typedef struct F_Keyring_descbc F_Keyring_descbc;
 struct F_Keyring_descbc
@@ -3243,6 +3361,16 @@ struct F_IPint_div
 	Keyring_IPint*	i1;
 	Keyring_IPint*	i2;
 };
+void RSApk_encrypt(void*);
+typedef struct F_RSApk_encrypt F_RSApk_encrypt;
+struct F_RSApk_encrypt
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_RSApk*	k;
+	Keyring_IPint*	m;
+};
 void IPint_eq(void*);
 typedef struct F_IPint_eq F_IPint_eq;
 struct F_IPint_eq
@@ -3264,6 +3392,49 @@ struct F_IPint_expmod
 	Keyring_IPint*	exp;
 	Keyring_IPint*	mod;
 };
+void RSAsk_fill(void*);
+typedef struct F_RSAsk_fill F_RSAsk_fill;
+struct F_RSAsk_fill
+{
+	WORD	regs[NREG-1];
+	Keyring_RSAsk**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	n;
+	Keyring_IPint*	e;
+	Keyring_IPint*	d;
+	Keyring_IPint*	p;
+	Keyring_IPint*	q;
+};
+void RSAsk_gen(void*);
+typedef struct F_RSAsk_gen F_RSAsk_gen;
+struct F_RSAsk_gen
+{
+	WORD	regs[NREG-1];
+	Keyring_RSAsk**	ret;
+	uchar	temps[12];
+	WORD	nlen;
+	WORD	elen;
+	WORD	nrep;
+};
+void DSAsk_gen(void*);
+typedef struct F_DSAsk_gen F_DSAsk_gen;
+struct F_DSAsk_gen
+{
+	WORD	regs[NREG-1];
+	Keyring_DSAsk**	ret;
+	uchar	temps[12];
+	Keyring_DSApk*	oldpk;
+};
+void EGsk_gen(void*);
+typedef struct F_EGsk_gen F_EGsk_gen;
+struct F_EGsk_gen
+{
+	WORD	regs[NREG-1];
+	Keyring_EGsk**	ret;
+	uchar	temps[12];
+	WORD	nlen;
+	WORD	nrep;
+};
 void Keyring_genSK(void*);
 typedef struct F_Keyring_genSK F_Keyring_genSK;
 struct F_Keyring_genSK
@@ -3400,6 +3571,15 @@ struct F_IPint_iptob64
 	uchar	temps[12];
 	Keyring_IPint*	i;
 };
+void IPint_iptob64z(void*);
+typedef struct F_IPint_iptob64z F_IPint_iptob64z;
+struct F_IPint_iptob64z
+{
+	WORD	regs[NREG-1];
+	String**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i;
+};
 void IPint_iptobebytes(void*);
 typedef struct F_IPint_iptobebytes F_IPint_iptobebytes;
 struct F_IPint_iptobebytes
@@ -3461,6 +3641,16 @@ struct F_Keyring_md5
 	Array*	digest;
 	Keyring_DigestState*	state;
 };
+void IPint_mod(void*);
+typedef struct F_IPint_mod F_IPint_mod;
+struct F_IPint_mod
+{
+	WORD	regs[NREG-1];
+	Keyring_IPint**	ret;
+	uchar	temps[12];
+	Keyring_IPint*	i1;
+	Keyring_IPint*	i2;
+};
 void IPint_mul(void*);
 typedef struct F_IPint_mul F_IPint_mul;
 struct F_IPint_mul
@@ -3672,6 +3862,36 @@ struct F_Keyring_sign
 	Keyring_DigestState*	state;
 	String*	ha;
 };
+void RSAsk_sign(void*);
+typedef struct F_RSAsk_sign F_RSAsk_sign;
+struct F_RSAsk_sign
+{
+	WORD	regs[NREG-1];
+	Keyring_RSAsig**	ret;
+	uchar	temps[12];
+	Keyring_RSAsk*	k;
+	Keyring_IPint*	m;
+};
+void DSAsk_sign(void*);
+typedef struct F_DSAsk_sign F_DSAsk_sign;
+struct F_DSAsk_sign
+{
+	WORD	regs[NREG-1];
+	Keyring_DSAsig**	ret;
+	uchar	temps[12];
+	Keyring_DSAsk*	k;
+	Keyring_IPint*	m;
+};
+void EGsk_sign(void*);
+typedef struct F_EGsk_sign F_EGsk_sign;
+struct F_EGsk_sign
+{
+	WORD	regs[NREG-1];
+	Keyring_EGsig**	ret;
+	uchar	temps[12];
+	Keyring_EGsk*	k;
+	Keyring_IPint*	m;
+};
 void Keyring_signm(void*);
 typedef struct F_Keyring_signm F_Keyring_signm;
 struct F_Keyring_signm
@@ -3768,6 +3988,39 @@ struct F_Keyring_verify
 	Keyring_Certificate*	cert;
 	Keyring_DigestState*	state;
 };
+void RSApk_verify(void*);
+typedef struct F_RSApk_verify F_RSApk_verify;
+struct F_RSApk_verify
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Keyring_RSApk*	k;
+	Keyring_RSAsig*	sig;
+	Keyring_IPint*	m;
+};
+void DSApk_verify(void*);
+typedef struct F_DSApk_verify F_DSApk_verify;
+struct F_DSApk_verify
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Keyring_DSApk*	k;
+	Keyring_DSAsig*	sig;
+	Keyring_IPint*	m;
+};
+void EGpk_verify(void*);
+typedef struct F_EGpk_verify F_EGpk_verify;
+struct F_EGpk_verify
+{
+	WORD	regs[NREG-1];
+	WORD*	ret;
+	uchar	temps[12];
+	Keyring_EGpk*	k;
+	Keyring_EGsig*	sig;
+	Keyring_IPint*	m;
+};
 void Keyring_verifym(void*);
 typedef struct F_Keyring_verifym F_Keyring_verifym;
 struct F_Keyring_verifym
@@ -3800,21 +4053,15 @@ struct F_IPint_xor
 	Keyring_IPint*	i2;
 };
 #define Keyring_PATH "$Keyring"
+#define Keyring_SHA1dlen 20
+#define Keyring_MD5dlen 16
+#define Keyring_MD4dlen 16
 #define Keyring_Encrypt 0
 #define Keyring_Decrypt 1
 #define Keyring_AESbsize 16
 #define Keyring_DESbsize 8
 #define Keyring_IDEAbsize 8
-#define Keyring_DEScbc 0
-#define Keyring_DESecb 1
-#define Keyring_SHA1 2
-#define Keyring_MD5 3
-#define Keyring_MD4 4
-#define Keyring_IDEAcbc 5
-#define Keyring_IDEAecb 6
-#define Keyring_SHA1dlen 20
-#define Keyring_MD5dlen 16
-#define Keyring_MD4dlen 16
+#define Keyring_BFbsize 8
 void Loader_compile(void*);
 typedef struct F_Loader_compile F_Loader_compile;
 struct F_Loader_compile
diff --git a/libinterp/sysmod.h b/libinterp/sysmod.h
index 5c352ae6..f18e9352 100644
--- a/libinterp/sysmod.h
+++ b/libinterp/sysmod.h
@@ -30,6 +30,7 @@ Runtab Sysmodtab[]={
 	"print",0xac849033,Sys_print,0,0,{0},
 	"pwrite",0x9d8aac6,Sys_pwrite,56,2,{0x0,0xc0,},
 	"read",0x7cfef557,Sys_read,48,2,{0x0,0xc0,},
+	"readn",0x7cfef557,Sys_readn,48,2,{0x0,0xc0,},
 	"remove",0xc6935858,Sys_remove,40,2,{0x0,0x80,},
 	"seek",0xaeccaddb,Sys_seek,56,2,{0x0,0x80,},
 	"sleep",0xe67bf126,Sys_sleep,40,0,{0},
@@ -44,4 +45,4 @@ Runtab Sysmodtab[]={
 	"wstat",0x56b02096,Sys_wstat,104,2,{0x0,0xbc,},
 	0
 };
-#define Sysmodlen	42
+#define Sysmodlen	43