summaryrefslogtreecommitdiff
path: root/libinterp
diff options
context:
space:
mode:
Diffstat (limited to 'libinterp')
-rw-r--r--libinterp/ipint.c91
-rw-r--r--libinterp/keyring.c544
-rw-r--r--libinterp/keyring.h18
-rw-r--r--libinterp/runt.h267
-rw-r--r--libinterp/sysmod.h3
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
generated by cgit v1.2.3 (git 2.46.0) at 2025-12-10 15:20:46 +0000