chiark / gitweb /
Abolish serpent-l. Use PKCS#1 v1.5 RSA padding but without hash OID for secnet.
[chiark-tcl.git] / base / hook.c
1 /*
2  */
3
4 #include <errno.h>
5
6 #include "hbytes.h"
7 #include "tables.h"
8
9 int staticerr(Tcl_Interp *ip, const char *m) {
10   Tcl_SetResult(ip, (char*)m, TCL_STATIC);
11   return TCL_ERROR;
12 }
13
14 int posixerr(Tcl_Interp *ip, int errnoval, const char *m) {
15   const char *em;
16   
17   Tcl_ResetResult(ip);
18   errno= errnoval;
19   em= Tcl_PosixError(ip);
20   Tcl_AppendResult(ip, m, ": ", em, (char*)0);
21   return TCL_ERROR;
22 }
23
24 void objfreeir(Tcl_Obj *o) {
25   if (o->typePtr && o->typePtr->freeIntRepProc)
26     o->typePtr->freeIntRepProc(o);
27   o->typePtr= 0;
28 }  
29
30 int do_hbytes_rep_info(ClientData cd, Tcl_Interp *ip,
31                        Tcl_Obj *obj, Tcl_Obj **result) {
32   const char *tn;
33   int nums[3], i, lnl;
34   Tcl_Obj *objl[4];
35
36   if (obj->typePtr == &hbytes_type) {
37     HBytes_Value *v= OBJ_HBYTES(obj);
38     memset(nums,0,sizeof(nums));
39     nums[1]= hbytes_len(v);
40   
41     if (HBYTES_ISEMPTY(v)) tn= "empty";
42     else if (HBYTES_ISSENTINEL(v)) tn= "sentinel!";
43     else if (HBYTES_ISSIMPLE(v)) tn= "simple";
44     else {
45       HBytes_ComplexValue *cx= v->begin_complex;
46       tn= "complex";
47       nums[0]= cx->prespace;
48       nums[2]= cx->avail - cx->len;
49     }
50     lnl= 3;
51   } else {
52     tn= "other";
53     lnl= 0;
54   }
55     
56   objl[0]= Tcl_NewStringObj((char*)tn,-1);
57   for (i=0; i<lnl; i++) objl[i+1]= Tcl_NewIntObj(nums[i]);
58   *result= Tcl_NewListObj(lnl+1,objl);
59     
60   return TCL_OK;
61 }
62
63 static void hbytes_t_dup(Tcl_Obj *src, Tcl_Obj *dup) {
64   objfreeir(dup);
65   hbytes_array(OBJ_HBYTES(dup),
66                hbytes_data(OBJ_HBYTES(src)),
67                hbytes_len(OBJ_HBYTES(src)));
68 }
69
70 static void hbytes_t_free(Tcl_Obj *o) {
71   hbytes_free(OBJ_HBYTES(o));
72 }
73
74 void obj_updatestr_array_prefix(Tcl_Obj *o, const Byte *byte,
75                                 int l, const char *prefix) {
76   char *str;
77   int pl;
78
79   pl= strlen(prefix);
80   o->length= l*2+pl;
81   str= o->bytes= TALLOC(o->length+1);
82   
83   memcpy(str,prefix,pl);
84   str += pl;
85
86   while (l>0) {
87     sprintf(str,"%02x",*byte);
88     str+=2; byte++; l--;
89   }
90   *str= 0;
91 }
92
93 void obj_updatestr_array(Tcl_Obj *o, const Byte *byte, int l) {
94   obj_updatestr_array_prefix(o,byte,l,"");
95 }
96
97 void obj_updatestr_vstringls(Tcl_Obj *o, ...) {
98   va_list al;
99   char *p;
100   const char *part;
101   int l, pl;
102
103   va_start(al,o);
104   for (l=0; (part= va_arg(al, const char*)); )
105     l+= va_arg(al, int);
106   va_end(al);
107   
108   o->length= l;
109   o->bytes= TALLOC(l+1);
110
111   va_start(al,o);
112   for (p= o->bytes; (part= va_arg(al, const char*)); p += pl) {
113     pl= va_arg(al, int);
114     memcpy(p, part, pl);
115   }
116   va_end(al);
117
118   *p= 0;
119 }
120
121 void obj_updatestr_string(Tcl_Obj *o, const char *str) {
122   obj_updatestr_vstringls(o, str, strlen(str), (char*)0);
123 }
124
125 static void hbytes_t_ustr(Tcl_Obj *o) {
126   obj_updatestr_array(o,
127                       hbytes_data(OBJ_HBYTES(o)),
128                       hbytes_len(OBJ_HBYTES(o)));
129 }
130
131 static int hbytes_t_sfa(Tcl_Interp *ip, Tcl_Obj *o) {
132   char *str, *ep, *os;
133   Byte *startbytes, *bytes;
134   int l;
135   char cbuf[3];
136
137   os= str= Tcl_GetStringFromObj(o,&l);  assert(str);
138   objfreeir(o);
139
140   if (l & 1) return staticerr(ip, "hbytes: conversion from hex:"
141                               " odd length in hex");
142
143   startbytes= bytes= hbytes_arrayspace(OBJ_HBYTES(o), l/2);
144
145   cbuf[2]= 0;
146   while (l>0) {
147     cbuf[0]= *str++;
148     cbuf[1]= *str++;
149     *bytes++= strtoul(cbuf,&ep,16);
150     if (ep != cbuf+2) {
151       hbytes_free(OBJ_HBYTES(o));
152       return staticerr(ip, "hbytes: conversion from hex:"
153                        " bad hex digit");
154     }
155     l -= 2;
156   }
157
158   o->typePtr = &hbytes_type;
159   return TCL_OK;
160 }
161
162 Tcl_ObjType hbytes_type = {
163   "hbytes",
164   hbytes_t_free, hbytes_t_dup, hbytes_t_ustr, hbytes_t_sfa
165 };
166
167 int do_hbytes_raw2h(ClientData cd, Tcl_Interp *ip,
168                     Tcl_Obj *binary, HBytes_Value *result) {
169   const unsigned char *str;
170   int l;
171
172   str= Tcl_GetByteArrayFromObj(binary,&l);
173   hbytes_array(result, str, l);
174   return TCL_OK;
175 }
176
177 int do_hbytes_h2raw(ClientData cd, Tcl_Interp *ip,
178                     HBytes_Value hex, Tcl_Obj **result) {
179   *result= Tcl_NewByteArrayObj(hbytes_data(&hex), hbytes_len(&hex));
180   return TCL_OK;
181 }
182
183 int do_hbytes_length(ClientData cd, Tcl_Interp *ip,
184                      HBytes_Value v, int *result) {
185   *result= hbytes_len(&v);
186   return TCL_OK;
187 }
188
189 int do_hbytes_random(ClientData cd, Tcl_Interp *ip,
190                      int length, HBytes_Value *result) {
191   Byte *space;
192   int rc;
193   
194   space= hbytes_arrayspace(result, length);
195   rc= get_urandom(ip, space, length);
196   if (rc) { hbytes_free(result); return rc; }
197   return TCL_OK;
198 }  
199   
200 int do_hbytes_overwrite(ClientData cd, Tcl_Interp *ip,
201                         HBytes_Var v, int start, HBytes_Value sub) {
202   int sub_l;
203
204   sub_l= hbytes_len(&sub);
205   if (start < 0)
206     return staticerr(ip, "hbytes overwrite start -ve");
207   if (start + sub_l > hbytes_len(v.hb))
208     return staticerr(ip, "hbytes overwrite out of range");
209   memcpy(hbytes_data(v.hb) + start, hbytes_data(&sub), sub_l);
210   return TCL_OK;
211 }
212
213 int do_hbytes_trimleft(ClientData cd, Tcl_Interp *ip, HBytes_Var v) {
214   const Byte *o, *p, *e;
215   o= p= hbytes_data(v.hb);
216   e= p + hbytes_len(v.hb);
217
218   while (p<e && !*p) p++;
219   if (p != o)
220     hbytes_unprepend(v.hb, p-o);
221
222   return TCL_OK;
223 }
224
225 int do_hbytes_repeat(ClientData cd, Tcl_Interp *ip,
226                      HBytes_Value sub, int count, HBytes_Value *result) {
227   int sub_l;
228   Byte *data;
229   const Byte *sub_d;
230
231   sub_l= hbytes_len(&sub);
232   if (count < 0) return staticerr(ip, "hbytes repeat count -ve");
233   if (count > INT_MAX/sub_l) return staticerr(ip, "hbytes repeat too long");
234
235   data= hbytes_arrayspace(result, sub_l*count);
236   sub_d= hbytes_data(&sub);
237   while (count) {
238     memcpy(data, sub_d, sub_l);
239     count--; data += sub_l;
240   }
241   return TCL_OK;
242 }  
243
244 int do_hbytes_zeroes(ClientData cd, Tcl_Interp *ip,
245                      int length, HBytes_Value *result) {
246   Byte *space;
247   space= hbytes_arrayspace(result, length);
248   memset(space,0,length);
249   return TCL_OK;
250 }
251
252 int do_hbytes_compare(ClientData cd, Tcl_Interp *ip,
253                       HBytes_Value a, HBytes_Value b, int *result) {
254   int al, bl, minl, r;
255
256   al= hbytes_len(&a);
257   bl= hbytes_len(&b);
258   minl= al<bl ? al : bl;
259
260   r= memcmp(hbytes_data(&a), hbytes_data(&b), minl);
261   
262   if (r<0) *result= -2;
263   else if (r>0) *result= +2;
264   else {
265     if (al<bl) *result= -1;
266     else if (al>bl) *result= +1;
267     else *result= 0;
268   }
269   return TCL_OK;
270 }
271
272 int do_hbytes_range(ClientData cd, Tcl_Interp *ip,
273                     HBytes_Value v, int start, int size,
274                     HBytes_Value *result) {
275   const Byte *data;
276   int l;
277
278   l= hbytes_len(&v);
279   if (start<0 || size<0 || l<start+size)
280     return staticerr(ip, "hbytes range subscripts out of range");
281
282   data= hbytes_data(&v);
283   hbytes_array(result, data+start, size);
284   return TCL_OK;
285 }
286   
287 int do_toplevel_hbytes(ClientData cd, Tcl_Interp *ip,
288                        const HBytes_SubCommand *subcmd,
289                        int objc, Tcl_Obj *const *objv) {
290   return subcmd->func(0,ip,objc,objv);
291 }
292
293 int do_toplevel_dgram_socket(ClientData cd, Tcl_Interp *ip,
294                              const DgramSocket_SubCommand *subcmd,
295                              int objc, Tcl_Obj *const *objv) {
296   return subcmd->func(0,ip,objc,objv);
297 }
298
299 int do_toplevel_ulong(ClientData cd, Tcl_Interp *ip,
300                       const ULong_SubCommand *subcmd,
301                       int objc, Tcl_Obj *const *objv) {
302   return subcmd->func(0,ip,objc,objv);
303 }
304
305 #define URANDOM "/dev/urandom"
306
307 int get_urandom(Tcl_Interp *ip, Byte *buffer, int l) {
308   static FILE *urandom;
309
310   int r, esave;
311
312   if (!urandom) {
313     urandom= fopen(URANDOM,"rb");
314     if (!urandom) return posixerr(ip,errno,"open " URANDOM);
315   }
316   r= fread(buffer,1,l,urandom);
317   if (r==l) return 0;
318
319   esave= errno;
320   fclose(urandom); urandom=0;
321
322   if (ferror(urandom)) {
323     return posixerr(ip,errno,"read " URANDOM);
324   } else {
325     assert(feof(urandom));
326     return staticerr(ip, URANDOM " gave eof!");
327   }
328 }
329
330 int Hbytes_Init(Tcl_Interp *ip) {
331   const TopLevel_Command *cmd;
332
333   Tcl_RegisterObjType(&hbytes_type);
334   Tcl_RegisterObjType(&blockcipherkey_type);
335   Tcl_RegisterObjType(&enum_nearlytype);
336   Tcl_RegisterObjType(&enum1_nearlytype);
337   Tcl_RegisterObjType(&sockaddr_type);
338   Tcl_RegisterObjType(&dgramsockid_type);
339   Tcl_RegisterObjType(&ulong_type);
340
341   for (cmd=toplevel_commands;
342        cmd->name;
343        cmd++)
344     Tcl_CreateObjCommand(ip, cmd->name, cmd->func, 0,0);
345
346   return TCL_OK;
347 }