WebSVN – Kolibri OS – Diff – /programs/network/ssh/sshlib_transport.inc

-;    ssh_transport.inc - SSH transport layer
+;    sshlib_transport.inc - SSH transport layer
+;
 ;    Copyright (C) 2016-2021 Jeffrey Amelynck
+;
 ;    This program is free software: you can redistribute it and/or modify
 ;    it under the terms of the GNU General Public License as published by
+;
 ;    You should have received a copy of the GNU General Public License
 ;    along with this program.  If not, see .
-struct  ssh_packet_header
-        packet_length   dd ?    ; The length of the packet in bytes, not including 'mac' or the
-                                ; 'packet_length' field itself.
+proc sshlib_padd_null
-        padding_length  db ?    ; Length of 'random padding' (bytes).
+        xor     eax, eax
+        ret
+endp
-        message_code    db ?    ; First byte of payload
 ends
 proc sshlib_crypt_null ctx, src, dst
-proc padding_zero
 ; Assume src == dst !
         xor     eax, eax
-        ret
         ret
-endp
 endp
-proc ssh_recv_packet connection, flags
+proc sshlib_recv_packet con_ptr, flags
-locals
-        data_length     dd ?    ; Total length of packet without MAC
+locals
-        socket_error    dd ?
+        data_length     dd ?    ; Total length of packet without MAC
 endl
+        DEBUGF  3, "> "
+; Receive first block (Read length, padding length, message code)
-        DEBUGF  2, "> "
+        mov     ebx, [con_ptr]
-; Receive first block (Read length, padding length, message code)
+        mov     ecx, [ebx+sshlib_connection.socketnum]
-        mov     ebx, [connection]
+        mov     esi, [ebx+sshlib_connection.rx_crypt_blocksize]
-        mov     ecx, [ebx+ssh_connection.socketnum]
+        lea     edx, [ebx+sshlib_connection.rx_buffer]
-        mov     esi, [ebx+ssh_connection.rx_crypt_blocksize]
+        mov     edi, [flags]
-        lea     edx, [ebx+ssh_connection.rx_buffer]
-        mov     edi, [flags]
         mcall   recv
-        mov     [socket_error], ebx
+        cmp     eax, 0
-        DEBUGF  1, "chunk = %u ", eax
+        jle     .sock_fail
-        mov     ebx, [connection]
+        sub     [ssh_chan.rcv_wnd], eax  ;;; FIXME
-        cmp     eax, [ebx+ssh_connection.rx_crypt_blocksize]
-        jne     .fail
+        DEBUGF  1, "chunk = %u ", eax
+        mov     ebx, [con_ptr]
-; Decrypt first block
+        cmp     eax, [ebx+sshlib_connection.rx_crypt_blocksize]
-        cmp     [ebx+ssh_connection.rx_crypt_proc], 0
+        jne     .proto_fail     ; TODO: handle receives of 1, 2, and 3 bytes correctly
         je      @f
-        pusha
+; Decrypt first block
-        lea     esi, [ebx+ssh_connection.rx_buffer]
+        pusha
-        stdcall [ebx+ssh_connection.rx_crypt_proc], [ebx+ssh_connection.rx_crypt_ctx_ptr], esi, esi
+        lea     esi, [ebx+sshlib_connection.rx_buffer]
-        popa
+        stdcall [ebx+sshlib_connection.rx_crypt_proc], [ebx+sshlib_connection.rx_crypt_ctx_ptr], esi, esi
-  @@:
+        popa
 ; Check data length
-        mov     esi, [ebx+ssh_connection.rx_buffer.packet_length]
+        mov     esi, [ebx + sshlib_connection.rx_buffer.packet_length]
         bswap   esi                                             ; convert length to little endian
-        mov     [ebx+ssh_connection.rx_buffer.packet_length], esi
+        mov     [ebx+sshlib_connection.rx_buffer.packet_length], esi
         DEBUGF  1, "packet length=%u ", esi
         cmp     esi, BUFFERSIZE
-        ja      .fail                                           ; packet is too large
+        ja      .proto_fail                                     ; packet is too large
 ; Calculate amount of remaining data
-; Calculate amount of remaining data
         add     esi, 4                                          ; Packet length field itself is not included in the count
-        sub     esi, [ebx+ssh_connection.rx_crypt_blocksize]    ; Already received this amount of data
+        sub     esi, [ebx+sshlib_connection.rx_crypt_blocksize]    ; Already received this amount of data
+        add     esi, [ebx+sshlib_connection.rx_mac_length]
+        jz      .packet_complete
         add     esi, [ebx+ssh_connection.rx_mac_length]
-        jz      .got_all_data
+; Receive remaining data
         lea     edx, [ebx+sshlib_connection.rx_buffer]
-; Receive remaining data
+        add     edx, [ebx+sshlib_connection.rx_crypt_blocksize]
-        lea     edx, [ebx+ssh_connection.rx_buffer]
+        mov     ecx, [ebx+sshlib_connection.socketnum]
-        add     edx, [ebx+ssh_connection.rx_crypt_blocksize]
-        mov     ecx, [ebx+ssh_connection.socketnum]
         mov     edi, [flags]
   .receive_loop:
-        mcall   recv
+        DEBUGF  3, "want %d bytes.. ", esi
-        DEBUGF  1, "chunk = %u ", eax
+        mcall   recv
         cmp     eax, 0
-        jbe     .fail
+        jle     .sock_fail
-        add     edx, eax
+        sub     [ssh_chan.rcv_wnd], eax             ;;; FIXME
-        sub     esi, eax
+        DEBUGF  3, "got %d bytes\n", eax
-        jnz     .receive_loop
+        add     edx, eax
         sub     esi, eax
-; Decrypt data
+        jnz     .receive_loop
-        mov     ebx, [connection]
-        cmp     [ebx+ssh_connection.rx_crypt_proc], 0
+; Decrypt data
-        je      .decrypt_complete
+        mov     ebx, [con_ptr]
-        mov     ecx, [ebx+ssh_connection.rx_buffer.packet_length]
+        mov     ecx, [ebx + sshlib_connection.rx_buffer.packet_length]
         add     ecx, 4                                          ; Packet_length field itself
-        sub     ecx, [ebx+ssh_connection.rx_crypt_blocksize]    ; Already decrypted this amount of data
+        sub     ecx, [ebx+sshlib_connection.rx_crypt_blocksize]    ; Already decrypted this amount of data
         jz      .decrypt_complete
-        lea     esi, [ebx+ssh_connection.rx_buffer]
+        lea     esi, [ebx+sshlib_connection.rx_buffer]
-        add     esi, [ebx+ssh_connection.rx_crypt_blocksize]
+        add     esi, [ebx+sshlib_connection.rx_crypt_blocksize]
+  .decrypt_loop:
-  .decrypt_loop:
+        pusha
-        pusha
+        stdcall [ebx+sshlib_connection.rx_crypt_proc], [ebx+sshlib_connection.rx_crypt_ctx_ptr], esi, esi
-        stdcall [ebx+ssh_connection.rx_crypt_proc], [ebx+ssh_connection.rx_crypt_ctx_ptr], esi, esi
+        popa
-        popa
+        add     esi, [ebx+sshlib_connection.rx_crypt_blocksize]
+        sub     ecx, [ebx+sshlib_connection.rx_crypt_blocksize]
-        add     esi, [ebx+ssh_connection.rx_crypt_blocksize]
+        jnz     .decrypt_loop
-        sub     ecx, [ebx+ssh_connection.rx_crypt_blocksize]
+  .decrypt_complete:
-        jnz     .decrypt_loop
-  .decrypt_complete:
+; Authenticate message
+        cmp     [ebx+sshlib_connection.rx_mac_proc], 0
-; Authenticate message
+        je      .mac_complete
-        cmp     [ebx+ssh_connection.rx_mac_proc], 0
-        je      .mac_complete
+        lea     esi, [ebx+sshlib_connection.rx_mac_seqnr]
-        lea     esi, [ebx+ssh_connection.rx_seq]
+        mov     ecx, [ebx+sshlib_connection.rx_buffer.packet_length]
-        mov     ecx, [ebx+ssh_connection.rx_buffer.packet_length]
+        add     ecx, 8                                          ; packet_length field itself + sequence number
-        add     ecx, 8                                          ; packet_length field itself + sequence number
+        lea     eax, [ebx+sshlib_connection.rx_mac_ctx]
-        lea     eax, [ebx+ssh_connection.rx_mac_ctx]
+;        push    [ebx+sshlib_connection.rx_buffer.packet_length]
-        mov     edx, [ebx+ssh_connection.rx_buffer.packet_length]
+        mov     edx, [ebx+sshlib_connection.rx_buffer.packet_length]
         bswap   edx                                             ; convert length to big endian
-        mov     [ebx+ssh_connection.rx_buffer.packet_length], edx
+        mov     [ebx+sshlib_connection.rx_buffer.packet_length], edx
-        stdcall [ebx+ssh_connection.rx_mac_proc], eax, esi, ecx
+        stdcall [ebx+sshlib_connection.rx_mac_proc], eax, esi, ecx
-        mov     edx, [ebx+ssh_connection.rx_buffer.packet_length]
+;        pop     [ebx+sshlib_connection.rx_buffer.packet_length]
-        bswap   edx                                             ; convert length to little endian
+        mov     edx, [ebx+sshlib_connection.rx_buffer.packet_length]
-        mov     [ebx+ssh_connection.rx_buffer.packet_length], edx
+        bswap   edx                                             ; convert length to little endian
+        mov     [ebx+sshlib_connection.rx_buffer.packet_length], edx
         lea     esi, [ebx+ssh_connection.rx_mac_ctx]
-        lea     edi, [ebx+ssh_connection.rx_buffer]
+        lea     esi, [ebx+sshlib_connection.rx_mac_ctx]
-        add     edi, [ebx+ssh_connection.rx_buffer.packet_length]
+        lea     edi, [ebx+sshlib_connection.rx_buffer+4]
-        add     edi, 4
+        add     edi, [ebx+sshlib_connection.rx_buffer.packet_length]
-        mov     ecx, [ebx+ssh_connection.rx_mac_length]
+        mov     ecx, [ebx+sshlib_connection.rx_mac_length]
         shr     ecx, 2
+        repe cmpsd
+        jne     .mac_fail
+  .mac_complete:
+        add     byte[ebx+sshlib_connection.rx_mac_seqnr+3], 1      ; Update sequence counter
+        adc     byte[ebx+sshlib_connection.rx_mac_seqnr+2], 0
-        repe cmpsd
+        adc     byte[ebx+sshlib_connection.rx_mac_seqnr+1], 0
-        jne     .mac_failed
+        adc     byte[ebx+sshlib_connection.rx_mac_seqnr+0], 0
-  .mac_complete:
-        add     byte[ebx+ssh_connection.rx_seq+3], 1            ; Update sequence counter
+; Return useful data length to the caller via eax register
-        adc     byte[ebx+ssh_connection.rx_seq+2], 0
+  .packet_complete:
-        adc     byte[ebx+ssh_connection.rx_seq+1], 0
+        mov     eax, [ebx+sshlib_connection.rx_buffer.packet_length]
-        adc     byte[ebx+ssh_connection.rx_seq+0], 0
+        movzx   ebx, [ebx+sshlib_connection.rx_buffer.padding_length]
         sub     eax, ebx
-; Return useful data length to the caller via eax register
+        DEBUGF  1, "useful data length=%u\n", eax
-  .got_all_data:
+        ret
         mov     eax, [ebx+ssh_connection.rx_buffer.packet_length]
-        movzx   ebx, [ebx+ssh_connection.rx_buffer.padding_length]
+  .sock_fail:
-        sub     eax, ebx
+        DEBUGF  3, "ssh_recv_packet failed!\n"
         mov     eax, [payload_size]
         inc     eax                     ; padding length byte
         lea     edx, [eax+4]            ; total packet size (without padding and MAC)
         mov     [packet_size], edx
-        mov     ecx, [connection]
+        mov     ecx, [con_ptr]
-        mov     ebx, [ecx+ssh_connection.tx_pad_size]
+        mov     ebx, [ecx+sshlib_connection.tx_pad_size]
         dec     ebx
         and     edx, ebx
         neg     edx
-        add     edx, [ecx+ssh_connection.tx_pad_size]
+        add     edx, [ecx+sshlib_connection.tx_pad_size]
-        add     edx, [ecx+ssh_connection.tx_pad_size]
+        add     edx, [ecx+sshlib_connection.tx_pad_size]
         DEBUGF  1, "padding %u bytes ", edx
         add     [packet_size], edx      ; total packet size with padding
 ; Start building the packet
 ; First comes the packet length, in network byte order ofcourse.
         add     eax, edx
         DEBUGF  1, "total size: %u ", eax
         bswap   eax
-        lea     edi, [ecx+ssh_connection.tx_buffer]
+        lea     edi, [ecx+sshlib_connection.tx_buffer]
         stosd
 ; Then the padding length
         mov     al, dl
         mov     esi, edx
         shr     esi, 2          ; number dwords
         mov     ebx, edx
         and     ebx, 3
         inc     ebx             ; number bytes in first write (1-4)
-        mov     edx, [connection]
+        mov     edx, [con_ptr]
-        call    [edx+ssh_connection.tx_pad_proc]
+        call    [edx+sshlib_connection.tx_pad_proc]
         mov     dword[edi], eax
         add     edi, ebx
 ; Then, do as many aligned writes as nescessary
-        mov     ebx, [connection]
+        mov     ebx, [con_ptr]
   @@:
-        call    [ebx+ssh_connection.tx_pad_proc]
+        call    [ebx+sshlib_connection.tx_pad_proc]
         stosd
         dec     esi
         jnz     @r
 ; Append the packet with Message Authentication Code
-        mov     edx, [connection]
+        mov     edx, [con_ptr]
-        cmp     [edx+ssh_connection.tx_mac_proc], 0
+        cmp     [edx+sshlib_connection.tx_mac_proc], 0
         je      .mac_complete
-        DEBUGF  1, "MAC sequence number: 0x%x\n", [edx+ssh_connection.tx_seq]
+        DEBUGF  1, "MAC sequence number: 0x%x\n", [edx+sshlib_connection.tx_mac_seqnr]
-        lea     esi, [edx+ssh_connection.tx_seq]
+        lea     esi, [edx+sshlib_connection.tx_mac_seqnr]
         mov     ecx, [packet_size]
         add     ecx, 4                                          ; Sequence number length
-        lea     eax, [edx+ssh_connection.tx_mac_ctx]
+        lea     eax, [edx+sshlib_connection.tx_mac_ctx]
-        stdcall [edx+ssh_connection.tx_mac_proc], eax, esi, ecx
+        stdcall [edx+sshlib_connection.tx_mac_proc], eax, esi, ecx
-        lea     esi, [edx+ssh_connection.tx_mac_ctx]
+        lea     esi, [edx+sshlib_connection.tx_mac_ctx]
-        lea     edi, [edx+ssh_connection.tx_buffer]
+        lea     edi, [edx+sshlib_connection.tx_buffer]
         add     edi, [packet_size]
-        mov     ecx, [edx+ssh_connection.tx_mac_length]
+        mov     ecx, [edx+sshlib_connection.tx_mac_length]
         shr     ecx, 2
         rep movsd
   .mac_complete:
-        add     byte[edx+ssh_connection.tx_seq+3], 1            ; Update sequence counter
+        add     byte[edx+sshlib_connection.tx_mac_seqnr+3], 1      ; Update sequence counter
-        adc     byte[edx+ssh_connection.tx_seq+2], 0
+        adc     byte[edx+sshlib_connection.tx_mac_seqnr+2], 0
-        adc     byte[edx+ssh_connection.tx_seq+1], 0
+        adc     byte[edx+sshlib_connection.tx_mac_seqnr+1], 0
-        adc     byte[edx+ssh_connection.tx_seq+0], 0
-; Now, encrypt everything but MAC
+        adc     byte[edx+sshlib_connection.tx_mac_seqnr+0], 0
         cmp     [edx+ssh_connection.tx_crypt_proc], 0
-        je      .encrypt_complete
+; Now, encrypt everything but MAC
-        lea     esi, [edx+ssh_connection.tx_buffer]
+        lea     esi, [edx+sshlib_connection.tx_buffer]
         mov     ecx, [packet_size]
   .encrypt_loop:
         pusha
-        stdcall [edx+ssh_connection.tx_crypt_proc], [edx+ssh_connection.tx_crypt_ctx_ptr], esi, esi
+        stdcall [edx+sshlib_connection.tx_crypt_proc], [edx+sshlib_connection.tx_crypt_ctx_ptr], esi, esi
         popa
-        add     esi, [edx+ssh_connection.tx_crypt_blocksize]
-        sub     ecx, [edx+ssh_connection.tx_crypt_blocksize]
+        add     esi, [edx+sshlib_connection.tx_crypt_blocksize]
-        jnz     .encrypt_loop
+        sub     ecx, [edx+sshlib_connection.tx_crypt_blocksize]
-  .encrypt_complete:
+        jnz     .encrypt_loop
 ; Send the packet
-        mov     ebx, [connection]
+        mov     ebx, [con_ptr]
-        mov     ecx, [ebx+ssh_connection.socketnum]
+        mov     ecx, [ebx+sshlib_connection.socketnum]
-        lea     edx, [ebx+ssh_connection.tx_buffer]
+        lea     edx, [ebx+sshlib_connection.tx_buffer]
         mov     esi, [packet_size]

Subversion Repositories Kolibri OS

(root)/programs/network/ssh/sshlib_transport.inc – Rev 9071 → 9106