Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/ttssh2/ttxssh/pkt.c

Diff of /trunk/ttssh2/ttxssh/pkt.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 6981 by doda, Sat Nov 25 15:26:26 2017 UTC revision 10960 by zmatsuo, Sat Oct 7 17:40:35 2023 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (c) 1998-2001, Robert O'Callahan   * Copyright (c) 1998-2001, Robert O'Callahan
3   * (C) 2004-2017 TeraTerm Project   * (C) 2004- TeraTerm Project
4   * All rights reserved.   * All rights reserved.
5   *   *
6   * Redistribution and use in source and binary forms, with or without   * Redistribution and use in source and binary forms, with or without
# Line 110  static int recv_line_data(PTInstVar pvar Line 110  static int recv_line_data(PTInstVar pvar
110                  amount_read = (pvar->Precv) (pvar->socket, &buf[i], 1, 0);                  amount_read = (pvar->Precv) (pvar->socket, &buf[i], 1, 0);
111                  if (amount_read != 1) {                  if (amount_read != 1) {
112                          return 0; // error                          return 0; // error
113                  }                  }
114    
115                  pvar->pkt_state.datalen += amount_read;                  pvar->pkt_state.datalen += amount_read;
116    
# Line 174  int PKT_recv(PTInstVar pvar, char *buf, Line 174  int PKT_recv(PTInstVar pvar, char *buf,
174                          pvar->pkt_state.datastart += i;                          pvar->pkt_state.datastart += i;
175                          pvar->pkt_state.datalen -= i;                          pvar->pkt_state.datalen -= i;
176                  }                  }
177                  else if (pvar->pkt_state.seen_server_ID && pvar->pkt_state.datalen >= (unsigned int) SSH_get_min_packet_size(pvar)) {                  else if (pvar->pkt_state.seen_server_ID && pvar->pkt_state.datalen >= SSH_get_min_packet_size(pvar)) {
178                          char *data = pvar->pkt_state.buf + pvar->pkt_state.datastart;                          char *data = pvar->pkt_state.buf + pvar->pkt_state.datastart;
179                          uint32 padding;                          uint32 padding_size = 0;
180                          uint32 pktsize;                          uint32 pktsize = 0;
181                          uint32 total_packet_size;                          uint32 total_packet_size;
182                          struct Mac *mac = &pvar->ssh2_keys[MODE_IN].mac;                          struct Mac *mac = &pvar->ssh2_keys[MODE_IN].mac;
183                          int etm;                          struct Enc *enc = &pvar->ssh2_keys[MODE_IN].enc;
184                            int authlen = 0, aadlen = 0;
185    
186                          etm = mac && mac->enabled && mac->etm;                          if (SSHv2(pvar)) {
187                                    /*
188                                     * pktsize
189                                     *   uint32   packet_length
190                                     * は
191                                     *   byte     padding_length
192                                     *   byte[n1] payload; n1 = packet_length - padding_length - 1
193                                     *   byte[n2] random padding; n2 = padding_length
194                                     * の長さの合計で
195                                     *   byte[m]  mac (Message Authentication Code - MAC); m = mac_length
196                                     * の長さを含まない。
197                                     * cf. RFC 4253 6. Binary Packet Protocol
198                                     */
199    
200                          /*                                  if (enc && enc->auth_len > 0) {
201                           * 通常の MAC 方式 (E&M: Encrypt & MAC) ではパケット長部分も暗号化されているため、                                          authlen = enc->auth_len;
202                           * 先頭の 1 ブロックを復号する。MAC 方式が EtM (Encrypt then MAC) の時は                                  }
                          * パケット長部分は暗号化されていないので復号は必要無い。  
                          */  
                         if (!pvar->pkt_state.predecrypted_packet && !etm) {  
                                 SSH_predecrpyt_packet(pvar, data);  
                                 pvar->pkt_state.predecrypted_packet = TRUE;  
                         }  
203    
204                          if (SSHv1(pvar)) {                                  /*
205                                  uint32 realpktsize = get_uint32_MSBfirst(data);                                   *                      |          | lead 4 bytes are encrypted | aadlen |
206                                     * Encryption type
207                                     *   enc->auth_len >  0 | AEAD     | AES-GCM ... no             | 4      |     (2)
208                                     *                      |          | chacha20-poly1305 ... yes  | 4      | (1) (2)
209                                     *   enc->auth_len == 0 | not AEAD | depends on MAC type        | <-     |
210                                     * MAC type
211                                     *   mac->etm == true   | EtM      | no                         | 4      |
212                                     *   mac->etm == false  | E&M      | yes                        | 0      |
213                                     * (1) lead 4 bytes are encrypted separately from main part.
214                                     * (2) implicit MAC type of AEAD is EtM
215                                     */
216                                    /*
217                                     * aadlen: Additional Authenticated Data Length
218                                     *   MAC の対象となるデータと一緒に暗号化されない、"MAC の対象となるデータの長さ"のサイズ
219                                     *   この部分は packet_length で、uint32 (4バイト)
220                                     *
221                                     * - 通常の MAC 方式 (E&M) ではパケット長部分が一緒に暗号化されるので aadlen は 0 となる。
222                                     * - EtM 方式の MAC や AEAD の AES-GCM では、パケット長部分が暗号化されないので
223                                     * aadlen は 4 となる。
224                                     * - AEAD の chacha20-poly1305 ではパケット長部分が暗号化されるが、MAC の対象となるデータ
225                                     * とは別に暗号化されるので aadlen は 4 となる。
226                                     *
227                                     */
228                                    if ((mac && mac->etm) || authlen > 0) {
229                                            aadlen = 4;
230                                    }
231    
232                                  padding = 8 - (realpktsize % 8);                                  if (authlen > 0 &&
233                                  pktsize = realpktsize + padding;                                      pvar->cc[MODE_IN]->cipher->id == SSH2_CIPHER_CHACHAPOLY) {
234                          } else {                                          /*
235                                  // SSH2 ではパケットの先頭に uint32 (4バイト) のパケット長が来る                                           * AEAD の chacha20-poly1305 ではパケット長部分が別に暗号化されている。
236                                  pktsize = get_uint32_MSBfirst(data);                                           * この処理は長さを取得するが、data は暗号化されたままとなる。
237                                             */
238                                            chachapoly_get_length(pvar->cc[MODE_IN]->cp_ctx, &pktsize,
239                                                                  pvar->ssh_state.receiver_sequence_number,
240                                                                  data, pvar->pkt_state.datalen);
241                                    }
242                                    else if (authlen == 0 &&
243                                             aadlen == 0 &&
244                                             !pvar->pkt_state.predecrypted_packet && aadlen == 0) {
245                                            /*
246                                             * AEAD でなく E&M (aadlen が 0) の時は、暗号化されているパケット長を
247                                             * 知る必要が有るため、先頭の 1 ブロックだけ事前に復号する。
248                                             */
249                                            SSH_predecrypt_packet(pvar, data);
250                                            pvar->pkt_state.predecrypted_packet = TRUE;
251    
252                                  // 続く 1 バイトは padding の長さ                                          pktsize = get_uint32_MSBfirst(data);
                                 if (etm) {  
                                         // EtM では padding length 以降は暗号化されている。  
                                         // この時点ではまだ復号していないので padding length が分からない。  
                                         // 仮に 0 を入れて置く。  
                                         padding = 0;  
253                                  }                                  }
254                                  else {                                  else {
255                                          // E&M では復号済み                                          /*
256                                          padding = (unsigned char) data[4];                                           * EtM 方式の MAC や、AEAD で AES-GCM のときなどはそのまま読める。
257                                             */
258                                            pktsize = get_uint32_MSBfirst(data);
259                                  }                                  }
260                          }                          }
261                            else {
262                                    pktsize = get_uint32_MSBfirst(data);
263                            }
264    
265                            if (SSHv1(pvar)) {
266                                    // SSH1 ではパケット長の値には padding の長さが含まれていない。
267                                    // また padding の長さの情報もパケット上には無いので、パケット長の値から計算する。
268                                    padding_size = 8 - (pktsize % 8);
269    
270                                    // 以降の処理は pktsize に padding_size の値が含まれている事が前提となっている。
271                                    pktsize += padding_size;
272                            }
273    
274                          // パケット(TCPペイロード)の全体のサイズは、SSHペイロード+4（+MAC）となる。                          // パケット(TCPペイロード)の全体のサイズは、
275                          // +4は、SSHペイロードのサイズを格納している部分（int型）。                          // 4（パケット長のサイズ）+パケット長（+MACのサイズ）となる。
276                          total_packet_size = pktsize + 4 + SSH_get_clear_MAC_size(pvar);                          total_packet_size = 4 + pktsize + SSH_get_authdata_size(pvar, MODE_IN);
277    
278                          if (total_packet_size <= pvar->pkt_state.datalen) {                          if (total_packet_size <= pvar->pkt_state.datalen) {
279                                  // 受信済みデータが十分有る場合はパケットの実処理を行う                                  // 受信済みデータが十分有る場合はパケットの実処理を行う
280                                  if (SSHv1(pvar)) {                                  if (SSHv1(pvar)) {
281                                          // SSH1 は EtM 非対応                                          // SSH1 は EtM 非対応 (そもそも MAC ではなく CRC を使う)
282                                          SSH1_handle_packet(pvar, data, pktsize, padding);                                          SSH1_handle_packet(pvar, data, pktsize, padding_size);
283                                  }                                  }
284                                  else {                                  else {
285                                          SSH2_handle_packet(pvar, data, pktsize, padding, etm);                                          // SSH2 ではこの時点では padding 長部分が復号されていない場合があるので、
286                                            // padding 長は渡さずに、必要になった時に内部で取得する。
287                                            SSH2_handle_packet(pvar, data, pktsize, aadlen, authlen);
288                                  }                                  }
289    
290                                  pvar->pkt_state.predecrypted_packet = FALSE;                                  pvar->pkt_state.predecrypted_packet = FALSE;
291                                  pvar->pkt_state.datastart += total_packet_size;                                  pvar->pkt_state.datastart += total_packet_size;
292                                  pvar->pkt_state.datalen -= total_packet_size;                                  pvar->pkt_state.datalen -= total_packet_size;
293    
294                          } else if (total_packet_size > PACKET_MAX_SIZE) {                          }
295                            else if (total_packet_size > PACKET_MAX_SIZE) {
296                                  // パケット長が大きすぎる場合は異常終了する。                                  // パケット長が大きすぎる場合は異常終了する。
297                                  // 実際には何らかの要因で復号失敗⇒パケット長部分が壊れている事が多い。                                  // 実際には何らかの要因で復号失敗⇒パケット長部分が壊れている事が多い。
298                                  UTIL_get_lang_msg("MSG_PKT_OVERSIZED_ERROR", pvar,                                  UTIL_get_lang_msg("MSG_PKT_OVERSIZED_ERROR", pvar,
299                                                    "Oversized packet received from server; connection will close.");                                                    "Oversized packet received from server; connection will close.");
300                                  notify_fatal_error(pvar, pvar->ts->UIMsg, TRUE);                                  notify_fatal_error(pvar, pvar->UIMsg, TRUE);
301                          } else {                          }
302                            else {
303                                  int amount_read = recv_data(pvar, max(total_packet_size, READAMOUNT));                                  int amount_read = recv_data(pvar, max(total_packet_size, READAMOUNT));
304    
305                                  if (amount_read == SOCKET_ERROR) {                                  if (amount_read == SOCKET_ERROR) {
# Line 259  int PKT_recv(PTInstVar pvar, char *buf, Line 318  int PKT_recv(PTInstVar pvar, char *buf,
318                          // パケットの受信                          // パケットの受信
319                          int amount_read;                          int amount_read;
320    
321                            // SCPファイル受信処理を一時停止中ならば、recv()をしない。
322                            if (pvar->recv.suspended) {
323                                    // それまでに受信したデータサイズをTera Term側に返す。
324                                    return amount_in_buf;
325    
326                            }
327    
328                          amount_read = recv_data(pvar, READAMOUNT);                          amount_read = recv_data(pvar, READAMOUNT);
329    
330                          if (amount_read == SOCKET_ERROR) {                          if (amount_read == SOCKET_ERROR) {
Legend:
Removed from v.6981  
changed lines
  Added in v.10960
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help