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 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, int encrypt,
159 HBytes_Var v, const BlockCipherAlgInfo *alg,
160 Tcl_Obj *key_obj, const BlockCipherModeInfo *mode,
161 HBytes_Value iv, HBytes_Value *result) {
162 int rc, want_bufferslen, data_len, iv_want;
165 void *sched, **schedp;
167 want_bufferslen= alg->blocksize * (mode->buf_blocks + mode->iv_blocks);
168 key= get_key(ip, key_obj, alg, want_bufferslen);
170 schedp= (alg->decrypt.make_schedule==alg->encrypt.make_schedule
171 || encrypt) ? &key->alpha : &key->beta;
174 if (key->valuelen < alg->key_min) return staticerr(ip, "key too short");
175 if (key->valuelen > alg->key_max) return staticerr(ip, "key too long");
177 sched= TALLOC(alg->schedule_size);
178 (encrypt ? &alg->encrypt : &alg->decrypt)->make_schedule
179 (sched, key->value, key->valuelen);
183 iv_want= alg->blocksize * mode->iv_blocks;
184 if (hbytes_issentinel(&iv)) {
185 if (!encrypt) return staticerr(ip,"must supply iv when decrypting");
186 rc= get_urandom(ip, key->buffers, iv_want);
189 int iv_supplied= hbytes_len(&iv);
190 if (iv_supplied > iv_want)
191 return staticerr(ip, "iv too large for algorithm and mode");
192 memcpy(key->buffers, hbytes_data(&iv), iv_supplied);
193 memset(key->buffers + iv_supplied, 0, iv_want - iv_supplied);
196 data_len= hbytes_len(v.hb);
197 if (data_len % alg->blocksize)
198 return staticerr(ip, "block cipher input not whole number of blocks");
201 (encrypt ? mode->encrypt : mode->decrypt)
202 (hbytes_data(v.hb), data_len / alg->blocksize,
203 key->buffers, key->buffers + iv_want,
205 alg->blocksize, sched);
208 return staticerr(ip, failure);
210 hbytes_array(result, key->buffers, iv_want);
215 static void dbuf(const char *m, const Byte *a, int l) {
216 fprintf(stderr,"dbuf %s l=%d ",m,l);
217 while (l-->0) fprintf(stderr,"%02x",*a++);
221 int do_hbytes_hmac(ClientData cd, Tcl_Interp *ip, const HashAlgInfo *alg,
222 HBytes_Value message, Tcl_Obj *key_obj,
223 Tcl_Obj *maclen_obj, HBytes_Value *result) {
224 /* key->alpha = state after H(K XOR ipad <unfinished>
225 * key->beta = state after H(K XOR opad <unfinished>
226 * key->buffers = room for one block, or one state
233 rc= Tcl_GetIntFromObj(ip, maclen_obj, &ml); if (rc) return rc;
234 if (ml<0 || ml>alg->hashsize)
235 return staticerr(ip, "requested hmac output size out of range");
240 key= get_key(ip, key_obj, alg,
241 alg->blocksize > alg->statesize
242 ? alg->blocksize : alg->statesize);
247 if (key->valuelen > alg->blocksize)
248 return staticerr(ip, "key to hmac longer than hash block size");
250 dbuf("start key",key->value,key->valuelen);
251 memcpy(key->buffers, key->value, key->valuelen);
252 memset(key->buffers + key->valuelen, 0, alg->blocksize - key->valuelen);
253 for (i=0; i<alg->blocksize; i++) key->buffers[i] ^= 0x36;
255 key->alpha= TALLOC(alg->statesize);
256 alg->init(key->alpha);
257 dbuf("inner key",key->buffers,alg->blocksize);
258 alg->update(key->alpha, key->buffers, alg->blocksize);
260 key->beta= TALLOC(alg->statesize);
261 alg->init(key->beta);
262 for (i=0; i<alg->blocksize; i++) key->buffers[i] ^= (0x5c ^ 0x36);
263 alg->update(key->beta, key->buffers, alg->blocksize);
264 dbuf("inner key",key->buffers,alg->blocksize);
268 dest= hbytes_arrayspace(result, alg->hashsize);
270 memcpy(key->buffers, key->alpha, alg->statesize);
271 alg->update(key->buffers, hbytes_data(&message), hbytes_len(&message));
272 alg->final(key->buffers, dest);
273 dbuf("inner hash",dest,alg->hashsize);
275 memcpy(key->buffers, key->beta, alg->statesize);
276 alg->update(key->buffers, dest, alg->hashsize);
277 alg->final(key->buffers, dest);
278 dbuf("outer hash",dest,alg->hashsize);
280 hbytes_unappend(result, alg->hashsize - ml);