Mercurial > 510Connectbot

comparison src/com/trilead/ssh2/transport/TransportConnection.java @ 0:0ce5cc452d02

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial version
author Carl Byington <carl@five-ten-sg.com>
date Thu, 22 May 2014 10:41:19 -0700
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:0ce5cc452d02
1
2 package com.trilead.ssh2.transport;
3
4 import java.io.IOException;
5 import java.io.InputStream;
6 import java.io.OutputStream;
7 import java.security.SecureRandom;
8
9 import com.trilead.ssh2.compression.ICompressor;
10 import com.trilead.ssh2.crypto.cipher.BlockCipher;
11 import com.trilead.ssh2.crypto.cipher.CipherInputStream;
12 import com.trilead.ssh2.crypto.cipher.CipherOutputStream;
13 import com.trilead.ssh2.crypto.cipher.NullCipher;
14 import com.trilead.ssh2.crypto.digest.MAC;
15 import com.trilead.ssh2.log.Logger;
16 import com.trilead.ssh2.packets.Packets;
17
18
19 /**
20 * TransportConnection.
21 *
22 * @author Christian Plattner, plattner@trilead.com
23 * @version $Id: TransportConnection.java,v 1.1 2007/10/15 12:49:56 cplattne Exp $
24 */
25 public class TransportConnection {
26 private static final Logger log = Logger.getLogger(TransportConnection.class);
27
28 int send_seq_number = 0;
29
30 int recv_seq_number = 0;
31
32 CipherInputStream cis;
33
34 CipherOutputStream cos;
35
36 boolean useRandomPadding = false;
37
38 /* Depends on current MAC and CIPHER */
39
40 MAC send_mac;
41
42 byte[] send_mac_buffer;
43
44 int send_padd_blocksize = 8;
45
46 MAC recv_mac;
47
48 byte[] recv_mac_buffer;
49
50 byte[] recv_mac_buffer_cmp;
51
52 int recv_padd_blocksize = 8;
53
54 ICompressor recv_comp = null;
55
56 ICompressor send_comp = null;
57
58 boolean can_recv_compress = false;
59
60 boolean can_send_compress = false;
61
62 byte[] recv_comp_buffer;
63
64 byte[] send_comp_buffer;
65
66 /* won't change */
67
68 final byte[] send_padding_buffer = new byte[256];
69
70 final byte[] send_packet_header_buffer = new byte[5];
71
72 final byte[] recv_padding_buffer = new byte[256];
73
74 final byte[] recv_packet_header_buffer = new byte[5];
75
76 boolean recv_packet_header_present = false;
77
78 ClientServerHello csh;
79
80 final SecureRandom rnd;
81
82 public TransportConnection(InputStream is, OutputStream os, SecureRandom rnd) {
83 this.cis = new CipherInputStream(new NullCipher(), is);
84 this.cos = new CipherOutputStream(new NullCipher(), os);
85 this.rnd = rnd;
86 }
87
88 public void changeRecvCipher(BlockCipher bc, MAC mac) {
89 cis.changeCipher(bc);
90 recv_mac = mac;
91 recv_mac_buffer = (mac != null) ? new byte[mac.size()] : null;
92 recv_mac_buffer_cmp = (mac != null) ? new byte[mac.size()] : null;
93 recv_padd_blocksize = bc.getBlockSize();
94
95 if (recv_padd_blocksize < 8)
96 recv_padd_blocksize = 8;
97 }
98
99 public void changeSendCipher(BlockCipher bc, MAC mac) {
100 if ((bc instanceof NullCipher) == false) {
101 /* Only use zero byte padding for the first few packets */
102 useRandomPadding = true;
103 /* Once we start encrypting, there is no way back */
104 }
105
106 cos.changeCipher(bc);
107 send_mac = mac;
108 send_mac_buffer = (mac != null) ? new byte[mac.size()] : null;
109 send_padd_blocksize = bc.getBlockSize();
110
111 if (send_padd_blocksize < 8)
112 send_padd_blocksize = 8;
113 }
114
115 public void changeRecvCompression(ICompressor comp) {
116 recv_comp = comp;
117
118 if (comp != null) {
119 recv_comp_buffer = new byte[comp.getBufferSize()];
120 can_recv_compress |= recv_comp.canCompressPreauth();
121 }
122 }
123
124 public void changeSendCompression(ICompressor comp) {
125 send_comp = comp;
126
127 if (comp != null) {
128 send_comp_buffer = new byte[comp.getBufferSize()];
129 can_send_compress |= send_comp.canCompressPreauth();
130 }
131 }
132
133 public void sendMessage(byte[] message) throws IOException {
134 sendMessage(message, 0, message.length, 0);
135 }
136
137 public void sendMessage(byte[] message, int off, int len) throws IOException {
138 sendMessage(message, off, len, 0);
139 }
140
141 public int getPacketOverheadEstimate() {
142 // return an estimate for the paket overhead (for send operations)
143 return 5 + 4 + (send_padd_blocksize - 1) + send_mac_buffer.length;
144 }
145
146 public void sendMessage(byte[] message, int off, int len, int padd) throws IOException {
147 if (padd < 4)
148 padd = 4;
149 else if (padd > 64)
150 padd = 64;
151
152 if (send_comp != null && can_send_compress) {
153 if (send_comp_buffer.length < message.length + 1024)
154 send_comp_buffer = new byte[message.length + 1024];
155
156 len = send_comp.compress(message, off, len, send_comp_buffer);
157 message = send_comp_buffer;
158 }
159
160 int packet_len = 5 + len + padd; /* Minimum allowed padding is 4 */
161 int slack = packet_len % send_padd_blocksize;
162
163 if (slack != 0) {
164 packet_len += (send_padd_blocksize - slack);
165 }
166
167 if (packet_len < 16)
168 packet_len = 16;
169
170 int padd_len = packet_len - (5 + len);
171
172 if (useRandomPadding) {
173 for (int i = 0; i < padd_len; i = i + 4) {
174 /*
175 * don't waste calls to rnd.nextInt() (by using only 8bit of the
176 * output). just believe me: even though we may write here up to 3
177 * bytes which won't be used, there is no "buffer overflow" (i.e.,
178 * arrayindexoutofbounds). the padding buffer is big enough =) (256
179 * bytes, and that is bigger than any current cipher block size + 64).
180 */
181 int r = rnd.nextInt();
182 send_padding_buffer[i] = (byte) r;
183 send_padding_buffer[i + 1] = (byte)(r >> 8);
184 send_padding_buffer[i + 2] = (byte)(r >> 16);
185 send_padding_buffer[i + 3] = (byte)(r >> 24);
186 }
187 }
188 else {
189 /* use zero padding for unencrypted traffic */
190 for (int i = 0; i < padd_len; i++)
191 send_padding_buffer[i] = 0;
192
193 /* Actually this code is paranoid: we never filled any
194 * bytes into the padding buffer so far, therefore it should
195 * consist of zeros only.
196 */
197 }
198
199 send_packet_header_buffer[0] = (byte)((packet_len - 4) >> 24);
200 send_packet_header_buffer[1] = (byte)((packet_len - 4) >> 16);
201 send_packet_header_buffer[2] = (byte)((packet_len - 4) >> 8);
202 send_packet_header_buffer[3] = (byte)((packet_len - 4));
203 send_packet_header_buffer[4] = (byte) padd_len;
204 cos.write(send_packet_header_buffer, 0, 5);
205 cos.write(message, off, len);
206 cos.write(send_padding_buffer, 0, padd_len);
207
208 if (send_mac != null) {
209 send_mac.initMac(send_seq_number);
210 send_mac.update(send_packet_header_buffer, 0, 5);
211 send_mac.update(message, off, len);
212 send_mac.update(send_padding_buffer, 0, padd_len);
213 send_mac.getMac(send_mac_buffer, 0);
214 cos.writePlain(send_mac_buffer, 0, send_mac_buffer.length);
215 }
216
217 cos.flush();
218
219 if (log.isEnabled()) {
220 log.log(90, "Sent " + Packets.getMessageName(message[off] & 0xff) + " " + len + " bytes payload");
221 }
222
223 send_seq_number++;
224 }
225
226 public int peekNextMessageLength() throws IOException {
227 if (recv_packet_header_present == false) {
228 cis.read(recv_packet_header_buffer, 0, 5);
229 recv_packet_header_present = true;
230 }
231
232 int packet_length = ((recv_packet_header_buffer[0] & 0xff) << 24)
233 | ((recv_packet_header_buffer[1] & 0xff) << 16) | ((recv_packet_header_buffer[2] & 0xff) << 8)
234 | ((recv_packet_header_buffer[3] & 0xff));
235 int padding_length = recv_packet_header_buffer[4] & 0xff;
236
237 if (packet_length > 35000 || packet_length < 12)
238 throw new IOException("Illegal packet size! (" + packet_length + ")");
239
240 int payload_length = packet_length - padding_length - 1;
241
242 if (payload_length < 0)
243 throw new IOException("Illegal padding_length in packet from remote (" + padding_length + ")");
244
245 return payload_length;
246 }
247
248 public int receiveMessage(byte buffer[], int off, int len) throws IOException {
249 if (recv_packet_header_present == false) {
250 cis.read(recv_packet_header_buffer, 0, 5);
251 }
252 else
253 recv_packet_header_present = false;
254
255 int packet_length = ((recv_packet_header_buffer[0] & 0xff) << 24)
256 | ((recv_packet_header_buffer[1] & 0xff) << 16) | ((recv_packet_header_buffer[2] & 0xff) << 8)
257 | ((recv_packet_header_buffer[3] & 0xff));
258 int padding_length = recv_packet_header_buffer[4] & 0xff;
259
260 if (packet_length > 35000 || packet_length < 12)
261 throw new IOException("Illegal packet size! (" + packet_length + ")");
262
263 int payload_length = packet_length - padding_length - 1;
264
265 if (payload_length < 0)
266 throw new IOException("Illegal padding_length in packet from remote (" + padding_length + ")");
267
268 if (payload_length >= len)
269 throw new IOException("Receive buffer too small (" + len + ", need " + payload_length + ")");
270
271 cis.read(buffer, off, payload_length);
272 cis.read(recv_padding_buffer, 0, padding_length);
273
274 if (recv_mac != null) {
275 cis.readPlain(recv_mac_buffer, 0, recv_mac_buffer.length);
276 recv_mac.initMac(recv_seq_number);
277 recv_mac.update(recv_packet_header_buffer, 0, 5);
278 recv_mac.update(buffer, off, payload_length);
279 recv_mac.update(recv_padding_buffer, 0, padding_length);
280 recv_mac.getMac(recv_mac_buffer_cmp, 0);
281
282 for (int i = 0; i < recv_mac_buffer.length; i++) {
283 if (recv_mac_buffer[i] != recv_mac_buffer_cmp[i])
284 throw new IOException("Remote sent corrupt MAC.");
285 }
286 }
287
288 recv_seq_number++;
289
290 if (log.isEnabled()) {
291 log.log(90, "Received " + Packets.getMessageName(buffer[off] & 0xff) + " " + payload_length
292 + " bytes payload");
293 }
294
295 if (recv_comp != null && can_recv_compress) {
296 int[] uncomp_len = new int[] { payload_length };
297 buffer = recv_comp.uncompress(buffer, off, uncomp_len);
298
299 if (buffer == null) {
300 throw new IOException("Error while inflating remote data");
301 }
302 else {
303 return uncomp_len[0];
304 }
305 }
306 else {
307 return payload_length;
308 }
309 }
310
311 /**
312 *
313 */
314 public void startCompression() {
315 can_recv_compress = true;
316 can_send_compress = true;
317 }
318 }