welcome 3des-cbc.

it took me some time to figure out what "triple des with outer chaining" was. luckily i have a copy of applied cryptography and the pictured data flow had all the info.

Mechiel Lukkien committed 17 years ago

Commit 4be69ee1 parent 01423274 files · +41 −16Browse files

Unified · Split

4 files

README +1 −1
appl/cmd/mkfile +1 −0
appl/lib/sshlib.b +36 −13
appl/lib/sshlib.m +3 −2

README+1−1

@@ -39,7 +39,7 @@ shell, file server, network. · 38 unmodified lines
39	39	- make api easier to use. perhaps parse connection-level packets
40	40	into an adt. make the packet parsing code simpler to use too?
41	41	- do auth keyboard-interactive? is there a generic challenge-response method in factotum?
42		−- other ciphers: 3dec-cbc, blowfish-cbc
	42	+- other ciphers: blowfish-cbc
43	43	- make padding random length? and for interactive ssh, do some random sleep before sending?
44	44	- think about sshnet
45	45	- manual pages

appl/cmd/mkfile+1−0

@@ -8,6 +8,7 @@ TARG=\ · 7 unmodified lines
8	8
9	9	MODULES=\
10	10	sftp.m\
	11	+ ../lib/sshlib.m\
11	12
12	13	SYSMODULES=\
13	14	arg.m\

appl/lib/sshlib.b+36−13

@@ -43,6 +43,8 @@ knownenc := array[] of { · 42 unmodified lines
43	43	"aes256-ctr",
44	44	"arcfour128",
45	45	"arcfour256",
	46	+ "3des-cbc",
	47	+ # "blowfish-cbc", # doesn't work
46	48	};
47	49	knownmac := array[] of {
48	50	"none",
@@ -58,7 +60,7 @@ knowncompr := array[] of { · 9 unmodified lines
58	60	# what we want to do by default, first is preferred
59	61	defkex := array[] of {Dgroupexchange, Dgroup14, Dgroup1};
60	62	defhostkey := array[] of {Hrsa, Hdss};
61		−defenc := array[] of {Eaes128cbc, Eaes192cbc, Eaes256cbc, Eaes128ctr, Eaes192ctr, Eaes256ctr, Earcfour128, Earcfour256, Earcfour};
	63	+defenc := array[] of {Eaes128cbc, Eaes192cbc, Eaes256cbc, Eaes128ctr, Eaes192ctr, Eaes256ctr, Earcfour128, Earcfour256, Earcfour, E3descbc};
62	64	defmac := array[] of {Msha1_96, Msha1, Mmd5, Mmd5_96};
63	65	defcompr := array[] of {Cnone};
64	66
@@ -558,13 +560,10 @@ Cryptalg.new(t: int): ref Cryptalg · 493 unmodified lines
558	560	Eaes128cbc => return ref Cryptalg.Aes (kr->AESbsize, 128, nil);
559	561	Eaes192cbc => return ref Cryptalg.Aes (kr->AESbsize, 192, nil);
560	562	Eaes256cbc => return ref Cryptalg.Aes (kr->AESbsize, 256, nil);
561		− Eblowfish => return ref Cryptalg.Blowfish (kr->BFbsize, 128, nil);
	563	+ Eblowfish => return ref Cryptalg.Blowfish (kr->BFbsize, 128, nil); # broken!
562	564	Eidea => return ref Cryptalg.Idea (kr->IDEAbsize, 128, nil);
563	565	Earcfour => return ref Cryptalg.Arcfour (8, 128, nil);
564		− Etripledes =>
565		− # of 192 bits, only 168 are used!
566		− #return ref Cryptalg.Tripledes (kr->DESbsize, 192, nil);
567		− raise "not yet implemented";
	566	+ E3descbc => return ref Cryptalg.Tripledes (kr->DESbsize, 192, nil, nil); # 168 bits are used
568	567	Eaes128ctr => return ref Cryptalg.Aesctr (kr->AESbsize, 128, nil, nil);
569	568	Eaes192ctr => return ref Cryptalg.Aesctr (kr->AESbsize, 192, nil, nil);
570	569	Eaes256ctr => return ref Cryptalg.Aesctr (kr->AESbsize, 256, nil, nil);
@@ -613,16 +612,19 @@ Cryptalg.setup(cc: self ref Cryptalg, key, ivec: array of byte) · 42 unmodified lines
613	612	pick c := cc {
614	613	None => ;
615	614	Aes => c.state = kr->aessetup(key, ivec);
616		− Blowfish => c.state = kr->blowfishsetup(key, ivec);
	615	+ Blowfish => c.state = kr->blowfishsetup(key, ivec); # broken!
617	616	Idea => c.state = kr->ideasetup(key, ivec);
618	617	Arcfour => c.state = kr->rc4setup(key);
619		− Tripledes => raise "not yet implemented";
	618	+ Tripledes =>
	619	+ c.states = array[] of {
	620	+ kr->dessetup(key[0:8], nil),
	621	+ kr->dessetup(key[8:16], nil),
	622	+ kr->dessetup(key[16:24], nil)
	623	+ };
	624	+ c.iv = ivec[:8];
620	625	Aesctr =>
621	626	c.counter = array[kr->AESbsize] of byte;
622	627	c.counter[:] = ivec[:kr->AESbsize];
623		− #say("aesctr x:");
624		− #hexdump(c.x);
625		−
626	628	c.key = array[len key] of byte;
627	629	c.key[:] = key;
628	630	Arcfour2 =>
@@ -636,11 +638,32 @@ Cryptalg.crypt(cc: self ref Cryptalg, buf: array of byte, n, direction: int) · 7 unmodified lines
636	638	pick c := cc {
637	639	None => ;
638	640	Aes => kr->aescbc(c.state, buf, n, direction);
639		− Blowfish => kr->blowfishcbc(c.state, buf, n, direction);
	641	+ Blowfish => kr->blowfishcbc(c.state, buf, n, direction); # broken!
640	642	Idea => kr->ideacbc(c.state, buf, n, direction);
641	643	Arcfour or
642	644	Arcfour2 => kr->rc4(c.state, buf, n);
643		− Tripledes => raise "not yet implemented";
	645	+ Tripledes =>
	646	+ buf = buf[:n];
	647	+ while(len buf > 0) {
	648	+ block := buf[:kr->DESbsize];
	649	+ if(direction == kr->Encrypt) {
	650	+ bufxor(block, c.iv);
	651	+ kr->desecb(c.states[0], block, len block, kr->Encrypt);
	652	+ kr->desecb(c.states[1], block, len block, kr->Decrypt);
	653	+ kr->desecb(c.states[2], block, len block, kr->Encrypt);
	654	+ c.iv[:] = block;
	655	+ buf = buf[len block:];
	656	+ } else {
	657	+ orig := array[len block] of byte;
	658	+ orig[:] = block;
	659	+ kr->desecb(c.states[2], block, len block, kr->Decrypt);
	660	+ kr->desecb(c.states[1], block, len block, kr->Encrypt);
	661	+ kr->desecb(c.states[0], block, len block, kr->Decrypt);
	662	+ bufxor(block, c.iv);
	663	+ c.iv[:] = orig;
	664	+ buf = buf[len block:];
	665	+ }
	666	+ }
644	667	Aesctr =>
645	668	key := array[kr->AESbsize] of byte;
646	669	for(o := 0; o < n; o += kr->AESbsize) {

appl/lib/sshlib.m+3−2

@@ -103,7 +103,7 @@ Sshlib: module { · 102 unmodified lines
103	103
104	104	Dgroup1, Dgroup14, Dgroupexchange: con iota;
105	105	Hdss, Hrsa: con iota;
106		− Enone, Eaes128cbc, Eaes192cbc, Eaes256cbc, Eidea, Earcfour, Eaes128ctr, Eaes192ctr, Eaes256ctr, Earcfour128, Earcfour256, Eblowfish, Etripledes: con iota;
	106	+ Enone, Eaes128cbc, Eaes192cbc, Eaes256cbc, Eidea, Earcfour, Eaes128ctr, Eaes192ctr, Eaes256ctr, Earcfour128, Earcfour256, E3descbc, Eblowfish: con iota;
107	107	Mnone, Msha1, Msha1_96, Mmd5, Mmd5_96: con iota;
108	108	Cnone: con iota;
109	109
@@ -121,7 +121,8 @@ Sshlib: module { · 11 unmodified lines
121	121	Arcfour =>
122	122	state: ref Keyring->RC4state;
123	123	Tripledes =>
124		− state: ref Keyring->DESstate;
	124	+ states: array of ref Keyring->DESstate;
	125	+ iv: array of byte;
125	126	Aesctr =>
126	127	counter, key: array of byte;
127	128	Arcfour2 => # rfc4345, discarding first 1536 bytes of key stream