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;
105 dup_obj->typePtr= &blockcipherkey_type;
108 static void key_t_ustr(Tcl_Obj *o) {
109 obj_updatestr_array(o, OBJ_CIPHKEY(o)->value, OBJ_CIPHKEY(o)->valuelen);
112 static int key_t_sfa(Tcl_Interp *ip, Tcl_Obj *o) {
116 rc= Tcl_ConvertToType(ip,o,&hbytes_type); if (rc) return rc;
117 val= TALLOC(sizeof(*val));
118 val->valuelen= l= hbytes_len(OBJ_HBYTES(o));
119 val->value= TALLOC(l);
122 memcpy(val->value, hbytes_data(OBJ_HBYTES(o)), l);
126 o->internalRep.otherValuePtr= val;
127 o->typePtr= &blockcipherkey_type;
132 Tcl_ObjType blockcipherkey_type = {
134 key_t_free, key_t_dup, key_t_ustr, key_t_sfa
137 static CiphKeyValue *get_key(Tcl_Interp *ip, Tcl_Obj *key_obj,
138 const void *alg, int want_bufferslen) {
142 rc= Tcl_ConvertToType(ip,key_obj,&blockcipherkey_type); if (rc) return 0;
143 key= OBJ_CIPHKEY(key_obj);
145 if (key->alg != alg) {
151 if (key->bufferslen < want_bufferslen) {
153 key->buffers= TALLOC(want_bufferslen);
154 key->bufferslen= want_bufferslen;
159 int do_hbytes_blockcipher(ClientData cd, Tcl_Interp *ip,
160 const BlockCipherOp *op,
161 int objc, Tcl_Obj *const *objv) {
162 return op->func((void*)op,ip,objc,objv);
165 static int blockcipher_prep(Tcl_Interp *ip, Tcl_Obj *key_obj,
166 const HBytes_Value *iv, int decrypt,
167 const BlockCipherAlgInfo *alg,
168 const BlockCipherModeInfo *mode, int data_len,
169 const CiphKeyValue **key_r, const void **sched_r,
170 const Byte **iv_r, int *iv_lenbytes_r,
171 Byte **buffers_r, int *nblocks_r) {
172 void *sched, **schedp;
173 int want_bufferslen, want_iv;
177 if (data_len % alg->blocksize)
178 return staticerr(ip, "block cipher input not whole number of blocks");
180 want_bufferslen= alg->blocksize * (mode->buf_blocks + mode->iv_blocks);
181 key= get_key(ip, key_obj, alg, want_bufferslen); if (!key) return TCL_ERROR;
183 schedp= (alg->decrypt.make_schedule==alg->encrypt.make_schedule
184 || !decrypt) ? &key->alpha : &key->beta;
187 if (key->valuelen < alg->key_min) return staticerr(ip, "key too short");
188 if (key->valuelen > alg->key_max) return staticerr(ip, "key too long");
190 sched= TALLOC(alg->schedule_size);
191 (decrypt ? &alg->decrypt : &alg->encrypt)->make_schedule
192 (sched, key->value, key->valuelen);
196 want_iv= alg->blocksize * mode->iv_blocks;
198 if (!hbytes_issentinel(iv))
199 return staticerr(ip,"iv supplied but mode does not take one");
200 } else if (hbytes_issentinel(iv)) {
201 if (decrypt) return staticerr(ip,"must supply iv when decrypting");
202 rc= get_urandom(ip, key->buffers, want_iv);
205 int iv_supplied= hbytes_len(iv);
206 if (iv_supplied > want_iv)
207 return staticerr(ip, "iv too large for algorithm and mode");
208 memcpy(key->buffers, hbytes_data(iv), iv_supplied);
209 memset(key->buffers + iv_supplied, 0, want_iv - iv_supplied);
216 *iv_lenbytes_r= want_iv;
218 *buffers_r= key->buffers + want_iv;
219 *nblocks_r= data_len / alg->blocksize;
224 int do_blockcipherop_d(ClientData cd, Tcl_Interp *ip,
225 HBytes_Var v, const BlockCipherAlgInfo *alg,
226 Tcl_Obj *key_obj, const BlockCipherModeInfo *mode,
227 HBytes_Value iv, HBytes_Value *result) {
228 return do_blockcipherop_e(cd,ip,v,alg,key_obj,mode,iv,result);
231 int do_blockcipherop_e(ClientData cd, Tcl_Interp *ip,
232 HBytes_Var v, const BlockCipherAlgInfo *alg,
233 Tcl_Obj *key_obj, const BlockCipherModeInfo *mode,
234 HBytes_Value iv, HBytes_Value *result) {
235 const BlockCipherOp *op= (const void*)cd;
236 int encrypt= op->encrypt;
238 const CiphKeyValue *key;
246 return staticerr(ip, "mode does not support encrypt/decrypt");
248 rc= blockcipher_prep(ip,key_obj,&iv,!encrypt,
249 alg,mode, hbytes_len(v.hb),
256 (encrypt ? mode->encrypt : mode->decrypt)
257 (hbytes_data(v.hb), nblocks, ivbuf, buffers, alg, encrypt, sched);
260 return staticerr(ip, failure);
262 hbytes_array(result, ivbuf, iv_lenbytes);
267 int do_blockcipherop_mac(ClientData cd, Tcl_Interp *ip,
268 HBytes_Value msg, const BlockCipherAlgInfo *alg,
269 Tcl_Obj *key_obj, const BlockCipherModeInfo *mode,
270 HBytes_Value iv, HBytes_Value *result) {
271 const CiphKeyValue *key;
276 int nblocks, iv_lenbytes;
280 return staticerr(ip, "mode does not support mac generation");
282 rc= blockcipher_prep(ip,key_obj,&iv,0,
283 alg,mode, hbytes_len(&msg),
289 failure= mode->mac(hbytes_data(&msg), nblocks, ivbuf, buffers, alg, sched);
291 return staticerr(ip,failure);
293 hbytes_array(result, buffers, alg->blocksize * mode->mac_blocks);
298 static void dbuf(const char *m, const Byte *a, int l) {
299 fprintf(stderr,"dbuf %s l=%d ",m,l);
300 while (l-->0) fprintf(stderr,"%02x",*a++);
304 int do_hbytes_hmac(ClientData cd, Tcl_Interp *ip, const HashAlgInfo *alg,
305 HBytes_Value message, Tcl_Obj *key_obj,
306 Tcl_Obj *maclen_obj, HBytes_Value *result) {
307 /* key->alpha = state after H(K XOR ipad <unfinished>
308 * key->beta = state after H(K XOR opad <unfinished>
309 * key->buffers = room for one block, or one state
316 rc= Tcl_GetIntFromObj(ip, maclen_obj, &ml); if (rc) return rc;
317 if (ml<0 || ml>alg->hashsize)
318 return staticerr(ip, "requested hmac output size out of range");
323 key= get_key(ip, key_obj, alg,
324 alg->blocksize > alg->statesize
325 ? alg->blocksize : alg->statesize);
330 if (key->valuelen > alg->blocksize)
331 return staticerr(ip, "key to hmac longer than hash block size");
333 dbuf("start key",key->value,key->valuelen);
334 memcpy(key->buffers, key->value, key->valuelen);
335 memset(key->buffers + key->valuelen, 0, alg->blocksize - key->valuelen);
336 for (i=0; i<alg->blocksize; i++) key->buffers[i] ^= 0x36;
338 key->alpha= TALLOC(alg->statesize);
339 alg->init(key->alpha);
340 dbuf("inner key",key->buffers,alg->blocksize);
341 alg->update(key->alpha, key->buffers, alg->blocksize);
343 key->beta= TALLOC(alg->statesize);
344 alg->init(key->beta);
345 for (i=0; i<alg->blocksize; i++) key->buffers[i] ^= (0x5c ^ 0x36);
346 alg->update(key->beta, key->buffers, alg->blocksize);
347 dbuf("inner key",key->buffers,alg->blocksize);
351 dest= hbytes_arrayspace(result, alg->hashsize);
353 memcpy(key->buffers, key->alpha, alg->statesize);
354 alg->update(key->buffers, hbytes_data(&message), hbytes_len(&message));
355 alg->final(key->buffers, dest);
356 dbuf("inner hash",dest,alg->hashsize);
358 memcpy(key->buffers, key->beta, alg->statesize);
359 alg->update(key->buffers, dest, alg->hashsize);
360 alg->final(key->buffers, dest);
361 dbuf("outer hash",dest,alg->hashsize);
363 hbytes_unappend(result, alg->hashsize - ml);