10 void memxor(Byte *dest, const Byte *src, int l) {
11 while (l--) *dest++ ^= *src++;
14 const PadMethod padmethods[]= {
22 int do_hbytes_pkcs5(ClientData cd, Tcl_Interp *ip,
23 const PadMethod *meth, HBytes_Var v, Tcl_Obj *block,
25 int rc, blocksize, padlen, old_len, i;
29 if (meth->use_algname) {
30 const BlockCipherAlgInfo *alg;
31 alg= enum_lookup_cached(ip,block,blockcipheralginfos,"cipher alg for pad");
32 if (!alg) return TCL_ERROR;
33 blocksize= alg->blocksize;
35 rc= Tcl_GetIntFromObj(ip, block, &blocksize); if (rc) return rc;
36 if (blocksize < 1 || blocksize > 255)
37 return staticerr(ip, "block size out of pkcs#5 range 1..255");
41 padlen= blocksize - (hbytes_len(v.hb) % blocksize);
42 padding= hbytes_append(v.hb, padlen);
43 memset(padding, padlen, padlen);
45 old_len= hbytes_len(v.hb); if (old_len % blocksize) goto bad;
46 unpad= hbytes_unappend(v.hb, 1); if (!unpad) goto bad;
48 if (padlen < 1 || padlen > blocksize) goto bad;
49 unpad= hbytes_unappend(v.hb, padlen-1); if (!unpad) goto bad;
50 for (i=0; i<padlen-1; i++, unpad++) if (*unpad != padlen) goto bad;
61 int do_hbytes_hash(ClientData cd, Tcl_Interp *ip, const HashAlgInfo *alg,
62 HBytes_Value message, HBytes_Value *result) {
65 dest= hbytes_arrayspace(result,alg->hashsize);
66 alg->oneshot(dest, hbytes_data(&message), hbytes_len(&message));
70 #define OBJ_CIPHKEY(o) ((CiphKeyValue*)(o)->internalRep.otherValuePtr)
73 int valuelen, bufferslen;
74 Byte *value, *buffers;
76 void *alpha, *beta; /* key schedules etc.; each may be 0 */
79 static void freealg(CiphKeyValue *key) {
84 static void key_t_free(Tcl_Obj *obj) {
85 CiphKeyValue *key= OBJ_CIPHKEY(obj);
91 static void noalg(CiphKeyValue *key) {
93 key->alpha= key->beta= 0;
96 static void key_t_dup(Tcl_Obj *src_obj, Tcl_Obj *dup_obj) {
97 CiphKeyValue *src= OBJ_CIPHKEY(src_obj);
98 CiphKeyValue *dup= TALLOC(sizeof(*dup));
99 dup->valuelen= src->valuelen;
100 dup->value= src->valuelen ? TALLOC(src->valuelen) : 0;
101 dup->buffers= 0; dup->bufferslen= 0;
102 memcpy(dup->value, src->value, src->valuelen);
104 dup_obj->internalRep.otherValuePtr= dup;
107 static void key_t_ustr(Tcl_Obj *o) {
108 obj_updatestr_array(o, OBJ_CIPHKEY(o)->value, OBJ_CIPHKEY(o)->valuelen);
111 static int key_t_sfa(Tcl_Interp *ip, Tcl_Obj *o) {
115 rc= Tcl_ConvertToType(ip,o,&hbytes_type); if (rc) return rc;
116 val= TALLOC(sizeof(*val));
117 val->valuelen= l= hbytes_len(OBJ_HBYTES(o));
118 val->value= TALLOC(l);
121 memcpy(val->value, hbytes_data(OBJ_HBYTES(o)), l);
125 o->internalRep.otherValuePtr= val;
126 o->typePtr= &blockcipherkey_type;
131 Tcl_ObjType blockcipherkey_type = {
133 key_t_free, key_t_dup, key_t_ustr, key_t_sfa
136 static CiphKeyValue *get_key(Tcl_Interp *ip, Tcl_Obj *key_obj,
137 const void *alg, int want_bufferslen) {
141 rc= Tcl_ConvertToType(ip,key_obj,&blockcipherkey_type); if (rc) return 0;
142 key= OBJ_CIPHKEY(key_obj);
144 if (key->alg != alg) {
150 if (key->bufferslen < want_bufferslen) {
152 key->buffers= TALLOC(want_bufferslen);
153 key->bufferslen= want_bufferslen;
158 int do_hbytes_blockcipher(ClientData cd, Tcl_Interp *ip,
159 const BlockCipherOp *op,
160 int objc, Tcl_Obj *const *objv) {
161 return op->func((void*)op,ip,objc,objv);
164 static int blockcipher_prep(Tcl_Interp *ip, Tcl_Obj *key_obj,
165 const HBytes_Value *iv, int decrypt,
166 const BlockCipherAlgInfo *alg,
167 const BlockCipherModeInfo *mode, int data_len,
168 const CiphKeyValue **key_r, const void **sched_r,
169 const Byte **iv_r, int *iv_lenbytes_r,
170 Byte **buffers_r, int *nblocks_r) {
171 void *sched, **schedp;
172 int want_bufferslen, want_iv;
176 if (data_len % alg->blocksize)
177 return staticerr(ip, "block cipher input not whole number of blocks");
179 want_bufferslen= alg->blocksize * (mode->buf_blocks + mode->iv_blocks);
180 key= get_key(ip, key_obj, alg, want_bufferslen); if (!key) return TCL_ERROR;
182 schedp= (alg->decrypt.make_schedule==alg->encrypt.make_schedule
183 || !decrypt) ? &key->alpha : &key->beta;
186 if (key->valuelen < alg->key_min) return staticerr(ip, "key too short");
187 if (key->valuelen > alg->key_max) return staticerr(ip, "key too long");
189 sched= TALLOC(alg->schedule_size);
190 (decrypt ? &alg->decrypt : &alg->encrypt)->make_schedule
191 (sched, key->value, key->valuelen);
195 want_iv= alg->blocksize * mode->iv_blocks;
197 if (!hbytes_issentinel(iv))
198 return staticerr(ip,"iv supplied but mode does not take one");
199 } else if (hbytes_issentinel(iv)) {
200 if (decrypt) return staticerr(ip,"must supply iv when decrypting");
201 rc= get_urandom(ip, key->buffers, want_iv);
204 int iv_supplied= hbytes_len(iv);
205 if (iv_supplied > want_iv)
206 return staticerr(ip, "iv too large for algorithm and mode");
207 memcpy(key->buffers, hbytes_data(iv), iv_supplied);
208 memset(key->buffers + iv_supplied, 0, want_iv - iv_supplied);
215 *iv_lenbytes_r= want_iv;
217 *buffers_r= key->buffers + want_iv;
218 *nblocks_r= data_len / alg->blocksize;
223 int do_blockcipherop_d(ClientData cd, Tcl_Interp *ip,
224 HBytes_Var v, const BlockCipherAlgInfo *alg,
225 Tcl_Obj *key_obj, const BlockCipherModeInfo *mode,
226 HBytes_Value iv, HBytes_Value *result) {
227 return do_blockcipherop_e(cd,ip,v,alg,key_obj,mode,iv,result);
230 int do_blockcipherop_e(ClientData cd, Tcl_Interp *ip,
231 HBytes_Var v, const BlockCipherAlgInfo *alg,
232 Tcl_Obj *key_obj, const BlockCipherModeInfo *mode,
233 HBytes_Value iv, HBytes_Value *result) {
234 const BlockCipherOp *op= (const void*)cd;
235 int encrypt= op->encrypt;
237 const CiphKeyValue *key;
245 return staticerr(ip, "mode does not support encrypt/decrypt");
247 rc= blockcipher_prep(ip,key_obj,&iv,!encrypt,
248 alg,mode, hbytes_len(v.hb),
255 (encrypt ? mode->encrypt : mode->decrypt)
256 (hbytes_data(v.hb), nblocks, ivbuf, buffers, alg, encrypt, sched);
259 return staticerr(ip, failure);
261 hbytes_array(result, ivbuf, iv_lenbytes);
266 int do_blockcipherop_mac(ClientData cd, Tcl_Interp *ip,
267 HBytes_Value msg, const BlockCipherAlgInfo *alg,
268 Tcl_Obj *key_obj, const BlockCipherModeInfo *mode,
269 HBytes_Value iv, HBytes_Value *result) {
270 const CiphKeyValue *key;
275 int nblocks, iv_lenbytes;
279 return staticerr(ip, "mode does not support mac generation");
281 rc= blockcipher_prep(ip,key_obj,&iv,0,
282 alg,mode, hbytes_len(&msg),
288 failure= mode->mac(hbytes_data(&msg), nblocks, ivbuf, buffers, alg, sched);
290 return staticerr(ip,failure);
292 hbytes_array(result, buffers, alg->blocksize * mode->mac_blocks);
297 static void dbuf(const char *m, const Byte *a, int l) {
298 fprintf(stderr,"dbuf %s l=%d ",m,l);
299 while (l-->0) fprintf(stderr,"%02x",*a++);
303 int do_hbytes_hmac(ClientData cd, Tcl_Interp *ip, const HashAlgInfo *alg,
304 HBytes_Value message, Tcl_Obj *key_obj,
305 Tcl_Obj *maclen_obj, HBytes_Value *result) {
306 /* key->alpha = state after H(K XOR ipad <unfinished>
307 * key->beta = state after H(K XOR opad <unfinished>
308 * key->buffers = room for one block, or one state
315 rc= Tcl_GetIntFromObj(ip, maclen_obj, &ml); if (rc) return rc;
316 if (ml<0 || ml>alg->hashsize)
317 return staticerr(ip, "requested hmac output size out of range");
322 key= get_key(ip, key_obj, alg,
323 alg->blocksize > alg->statesize
324 ? alg->blocksize : alg->statesize);
329 if (key->valuelen > alg->blocksize)
330 return staticerr(ip, "key to hmac longer than hash block size");
332 dbuf("start key",key->value,key->valuelen);
333 memcpy(key->buffers, key->value, key->valuelen);
334 memset(key->buffers + key->valuelen, 0, alg->blocksize - key->valuelen);
335 for (i=0; i<alg->blocksize; i++) key->buffers[i] ^= 0x36;
337 key->alpha= TALLOC(alg->statesize);
338 alg->init(key->alpha);
339 dbuf("inner key",key->buffers,alg->blocksize);
340 alg->update(key->alpha, key->buffers, alg->blocksize);
342 key->beta= TALLOC(alg->statesize);
343 alg->init(key->beta);
344 for (i=0; i<alg->blocksize; i++) key->buffers[i] ^= (0x5c ^ 0x36);
345 alg->update(key->beta, key->buffers, alg->blocksize);
346 dbuf("inner key",key->buffers,alg->blocksize);
350 dest= hbytes_arrayspace(result, alg->hashsize);
352 memcpy(key->buffers, key->alpha, alg->statesize);
353 alg->update(key->buffers, hbytes_data(&message), hbytes_len(&message));
354 alg->final(key->buffers, dest);
355 dbuf("inner hash",dest,alg->hashsize);
357 memcpy(key->buffers, key->beta, alg->statesize);
358 alg->update(key->buffers, dest, alg->hashsize);
359 alg->final(key->buffers, dest);
360 dbuf("outer hash",dest,alg->hashsize);
362 hbytes_unappend(result, alg->hashsize - ml);