WebSVN – Kolibri OS – Diff – /programs/network/ssh/ssh.asm


;    ssh.asm - SSH client for KolibriOS
;
;    Copyright (C) 2015-2017 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
;    the Free Software Foundation, either version 3 of the License, or
;    (at your option) any later version.
;
;    This program is distributed in the hope that it will be useful,
;    but WITHOUT ANY WARRANTY; without even the implied warranty of
;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;    GNU General Public License for more details.
;
;    You should have received a copy of the GNU General Public License
;    along with this program.  If not, see .
 
format binary as ""
 
__DEBUG__       = 1
__DEBUG_LEVEL__ = 2             ; 1: Extreme debugging, 2: Debugging, 3: Errors only
 
BUFFERSIZE      = 4096
MAX_BITS        = 8192
 
DH_PRIVATE_KEY_SIZE     = 256
 
use32
 
        db      'MENUET01'      ; signature
        dd      1               ; header version
        dd      start           ; entry point
        dd      i_end           ; initialized size
        dd      mem+65536       ; required memory
        dd      mem+65536       ; stack pointer
        dd      params          ; parameters
        dd      0               ; path
 
include '../../macros.inc'
;include '../../struct.inc'
purge mov,add,sub
include '../../proc32.inc'
include '../../dll.inc'
include '../../debug-fdo.inc'
include '../../network.inc'
include '../../develop/libraries/libcrash/trunk/libcrash.inc'
 
include 'mcodes.inc'
include 'ssh_transport.inc'
 
include 'dh_gex.inc'
 
include 'mpint.inc'
include 'random.inc'
 
include 'aes256.inc'
include 'aes256-ctr.inc'
include 'aes256-cbc.inc'
 
include 'hmac_sha256.inc'
include 'hmac_sha1.inc'
include 'hmac_md5.inc'
 
; macros for network byte order
macro dd_n op {
   dd 0 or (((op) and 0FF000000h) shr 24) or \
           (((op) and 000FF0000h) shr  8) or \
           (((op) and 00000FF00h) shl  8) or \
           (((op) and 0000000FFh) shl 24)
}
 
macro dw_n op {
   dw 0 or (((op) and 0FF00h) shr 8) or \
           (((op) and 000FFh) shl 8)
}
 
proc dump_hex _ptr, _length
if __DEBUG_LEVEL__ <= 1
        pushad
 
        mov     esi, [_ptr]
        mov     ecx, [_length]
  .next_dword:
        lodsd
        bswap   eax
        DEBUGF  1,'%x',eax
        loop    .next_dword
        DEBUGF  1,'\n'
 
        popad
        ret
end if
endp
 
struct  ssh_connection
 
; Connection
 
        hostname                rb 1024
 
        socketnum               dd ?
 
        sockaddr                dw ?            ; Address family
        port                    dw ?
        ip                      dd ?
                                rb 10
 
; Encryption/Decryption
 
        rx_crypt_proc           dd ?
        tx_crypt_proc           dd ?
        rx_crypt_ctx_ptr        dd ?
        tx_crypt_ctx_ptr        dd ?
        rx_crypt_blocksize      dd ?
        tx_crypt_blocksize      dd ?
 
; Message authentication
 
        rx_mac_proc             dd ?
        tx_mac_proc             dd ?
        rx_mac_ctx              hmac_sha256_context
        tx_mac_ctx              hmac_sha256_context
        rx_mac_length           dd ?
        tx_mac_length           dd ?
 
; Buffers
 
        rx_seq                  dd ?            ; Packet sequence number for MAC
        rx_buffer               ssh_packet_header
                                rb BUFFERSIZE-sizeof.ssh_packet_header
 
        tx_seq                  dd ?            ; Packet sequence number for MAC
        tx_buffer               ssh_packet_header
                                rb BUFFERSIZE-sizeof.ssh_packet_header
 
        send_data               dw ?
 
; Output from key exchange
        dh_K                    dd ?            ; Shared Secret (Big endian)
                                rb MAX_BITS/8
        dh_K_length             dd ?            ; Length in little endian
 
        dh_H                    rb 32           ; Exchange Hash
        session_id_prefix       db ?
        session_id              rb 32
        rx_iv                   rb 32           ; Rx initialisation vector
        tx_iv                   rb 32           ; Tx initialisation vector
        rx_enc_key              rb 32           ; Rx encryption key
        tx_enc_key              rb 32           ; Tx encryption key
        rx_int_key              rb 32           ; Rx integrity key
        tx_int_key              rb 32           ; Tx integrity key
 
; Diffie Hellman
        dh_p                    dd ?
                                rb MAX_BITS/8
        dh_g                    dd ?
                                rb MAX_BITS/8
        dh_x                    dd ?
                                rb MAX_BITS/8
        dh_e                    dd ?
                                rb MAX_BITS/8
        dh_f                    dd ?
                                rb MAX_BITS/8
 
        dh_signature            dd ?
                                rb MAX_BITS/8
 
        temp_ctx                ctx_sha224256
        k_h_ctx                 ctx_sha224256
 
        mpint_tmp               dd ?
                                rb MAX_BITS/8
 
ends
 
start:
        mcall   68, 11          ; Init heap
 
        DEBUGF  2, "SSH: Loading libraries\n"
        stdcall dll.Load, @IMPORT
        test    eax, eax
        jnz     exit
 
        DEBUGF  2, "SSH: Init PRNG\n"
        call    init_random
 
        DEBUGF  2, "SSH: Init Console\n"
        invoke  con_start, 1
        invoke  con_init, 80, 25, 80, 25, title
 
; Check for parameters TODO
;        cmp     byte[params], 0
;        jne     resolve
 
main:
        invoke  con_cls
; Welcome user
        invoke  con_write_asciiz, str1
 
prompt:
; write prompt
        invoke  con_write_asciiz, str2
; read string
        mov     esi, con.hostname
        invoke  con_gets, esi, 256
; check for exit
        test    eax, eax
        jz      done
        cmp     byte[esi], 10
        jz      done
 
resolve:
        mov     [con.sockaddr], AF_INET4
        mov     [con.port], 22 shl 8
 
; delete terminating '\n'
        mov     esi, con.hostname
  @@:
        lodsb
        cmp     al, ':'
        je      .do_port
        cmp     al, 0x20
        ja      @r
        mov     byte[esi-1], 0
        jmp     .done
 
  .do_port:
        xor     eax, eax
        xor     ebx, ebx
        mov     byte[esi-1], 0
  .portloop:
        lodsb
        cmp     al, 0x20
        jbe     .port_done
        sub     al, '0'
        jb      hostname_error
        cmp     al, 9
        ja      hostname_error
        lea     ebx, [ebx*4+ebx]
        shl     ebx, 1
        add     ebx, eax
        jmp     .portloop
 
  .port_done:
        xchg    bl, bh
        mov     [con.port], bx
 
  .done:
 
; resolve name
        push    esp     ; reserve stack place
        push    esp
        invoke  getaddrinfo, con.hostname, 0, 0
        pop     esi
; test for error
        test    eax, eax
        jnz     dns_error
 
        invoke  con_cls
        invoke  con_write_asciiz, str3
        invoke  con_write_asciiz, con.hostname
 
; write results
        invoke  con_write_asciiz, str8
 
; convert IP address to decimal notation
        mov     eax, [esi+addrinfo.ai_addr]
        mov     eax, [eax+sockaddr_in.sin_addr]
        mov     [con.ip], eax
        invoke  inet_ntoa, eax
; write result
        invoke  con_write_asciiz, eax
; free allocated memory
        invoke  freeaddrinfo, esi
 
        invoke  con_write_asciiz, str9
 
        mcall   40, EVM_STACK + EVM_KEY
        invoke  con_cls
 
; Create socket
        mcall   socket, AF_INET4, SOCK_STREAM, 0
        cmp     eax, -1
        jz      socket_err
        mov     [con.socketnum], eax
 
; Connect
        DEBUGF  2, "Connecting to server\n"
        mcall   connect, [con.socketnum], con.sockaddr, 18
        test    eax, eax
        jnz     socket_err
 
; Start calculating hash
        invoke  sha256_init, con.temp_ctx
; HASH: string  V_C, the client's version string (CR and NL excluded)
        invoke  sha256_update, con.temp_ctx, ssh_ident_ha, ssh_ident.length+4-2
 
; >> Send our identification string
        DEBUGF  2, "Sending ID string\n"
        mcall   send, [con.socketnum], ssh_ident, ssh_ident.length, 0
        cmp     eax, -1
        je      socket_err
 
; << Check protocol version of server
        mcall   recv, [con.socketnum], con.rx_buffer, BUFFERSIZE, 0
        cmp     eax, -1
        je      socket_err
 
        DEBUGF  2, "Received ID string\n"
        cmp     dword[con.rx_buffer], "SSH-"
        jne     proto_err
        cmp     dword[con.rx_buffer+4], "2.0-"
        jne     proto_err
 
; HASH: string  V_S, the server's version string (CR and NL excluded)
        lea     edx, [eax+2]
        sub     eax, 2
        bswap   eax
        mov     dword[con.rx_buffer-4], eax
        invoke  sha256_update, con.temp_ctx, con.rx_buffer-4, edx
 
; >> Key Exchange init
        mov     [con.rx_seq], 0
        mov     [con.tx_seq], 0
        mov     [con.rx_crypt_blocksize], 4             ; minimum blocksize
        mov     [con.tx_crypt_blocksize], 4
        mov     [con.rx_crypt_proc], 0
        mov     [con.tx_crypt_proc], 0
        mov     [con.rx_mac_proc], 0
        mov     [con.tx_mac_proc], 0
        mov     [con.rx_mac_length], 0
        mov     [con.tx_mac_length], 0
 
        DEBUGF  2, "Sending KEX init\n"
        mov     edi, ssh_kex.cookie
        call    MBRandom
        stosd
        call    MBRandom
        stosd
        call    MBRandom
        stosd
        call    MBRandom
        stosd
        stdcall ssh_send_packet, con, ssh_kex, ssh_kex.length, 0
        cmp     eax, -1
        je      socket_err
 
; HASH: string  I_C, the payload of the client's SSH_MSG_KEXINIT
        mov     eax, dword[con.tx_buffer+ssh_packet_header.packet_length]
        bswap   eax
        movzx   ebx, [con.tx_buffer+ssh_packet_header.padding_length]
        sub     eax, ebx
        dec     eax
        lea     edx, [eax+4]
        bswap   eax
        mov     dword[con.tx_buffer+1], eax
        invoke  sha256_update, con.temp_ctx, con.tx_buffer+1, edx
 
; << Check key exchange init of server
        stdcall ssh_recv_packet, con, 0
        cmp     eax, -1
        je      socket_err
 
        cmp     [con.rx_buffer.message_code], SSH_MSG_KEXINIT
        jne     proto_err
        DEBUGF  2, "Received KEX init\n"
 
        lea     esi, [con.rx_buffer+sizeof.ssh_packet_header+16]
        lodsd
        bswap   eax
        DEBUGF  1, "kex_algorithms: %s\n", esi
        add     esi, eax
        lodsd
        bswap   eax
        DEBUGF  1, "server_host_key_algorithms: %s\n", esi
        add     esi, eax
        lodsd
        bswap   eax
        DEBUGF  1, "encryption_algorithms_client_to_server: %s\n", esi
        add     esi, eax
        lodsd
        bswap   eax
        DEBUGF  1, "encryption_algorithms_server_to_client: %s\n", esi
        add     esi, eax
        lodsd
        bswap   eax
        DEBUGF  1, "mac_algorithms_client_to_server: %s\n", esi
        add     esi, eax
        lodsd
        bswap   eax
        DEBUGF  1, "mac_algorithms_server_to_client: %s\n", esi
        add     esi, eax
        lodsd
        bswap   eax
        DEBUGF  1, "compression_algorithms_client_to_server: %s\n", esi
        add     esi, eax
        lodsd
        bswap   eax
        DEBUGF  1, "compression_algorithms_server_to_client: %s\n", esi
        add     esi, eax
        lodsd
        bswap   eax
        DEBUGF  1, "languages_client_to_server: %s\n", esi
        add     esi, eax
        lodsd
        bswap   eax
        DEBUGF  1, "languages_server_to_client: %s\n", esi
        add     esi, eax
        lodsb
        DEBUGF  1, "KEX First Packet Follows: %u\n", al
 
        ; TODO: parse this structure and init procedures accordingly
 
; HASH: string I_S, the payload of the servers's SSH_MSG_KEXINIT
        mov     eax, dword[con.rx_buffer+ssh_packet_header.packet_length]
        movzx   ebx, [con.rx_buffer+ssh_packet_header.padding_length]
        sub     eax, ebx
        dec     eax
        lea     edx, [eax+4]
        bswap   eax
        mov     dword[con.rx_buffer+sizeof.ssh_packet_header-5], eax
        invoke  sha256_update, con.temp_ctx, con.rx_buffer+sizeof.ssh_packet_header-5, edx
 
; Exchange keys with the server
 
        stdcall dh_gex
        test    eax, eax
        jnz     exit
 
; Set keys
 
        DEBUGF  2, "SSH: Setting encryption keys\n"
 
        stdcall aes256_cbc_init, con.rx_iv
        mov     [con.rx_crypt_ctx_ptr], eax
 
        stdcall aes256_set_decrypt_key, eax, con.rx_enc_key
        mov     [con.rx_crypt_proc], aes256_cbc_decrypt
        mov     [con.rx_crypt_blocksize], AES256_BLOCKSIZE
 
        stdcall aes256_cbc_init, con.tx_iv
        mov     [con.tx_crypt_ctx_ptr], eax
 
        stdcall aes256_set_encrypt_key, eax, con.tx_enc_key
        mov     [con.tx_crypt_proc], aes256_cbc_encrypt
        mov     [con.tx_crypt_blocksize], AES256_BLOCKSIZE
 
        stdcall hmac_sha256_setkey, con.rx_mac_ctx, con.rx_int_key, SHA256_HASH_SIZE
        mov     [con.rx_mac_proc], hmac_sha256
        mov     [con.rx_mac_length], SHA256_HASH_SIZE
 
        stdcall hmac_sha256_setkey, con.tx_mac_ctx, con.tx_int_key, SHA256_HASH_SIZE
        mov     [con.tx_mac_proc], hmac_sha256
        mov     [con.tx_mac_length], SHA256_HASH_SIZE
 
; TODO: erase all keys from memory and free the memory
 
; >> Request service (user-auth)
 
        DEBUGF  2, "SSH: Requesting service\n"
 
        stdcall ssh_send_packet, con, ssh_request_service, ssh_request_service.length, 0
        cmp     eax, -1
        je      socket_err
 
; << Check for service acceptance
 
        stdcall ssh_recv_packet, con, 0
        cmp     eax, -1
        je      socket_err
 
        cmp     [con.rx_buffer.message_code], SSH_MSG_SERVICE_ACCEPT
        jne     proto_err
 
; >> Request user authentication
 
; TODO: Request username from the user
;        invoke  con_write_asciiz, str12
;        invoke  con_gets, username, 256
;        test    eax, eax
;        jz      done
 
; TODO: implement password authentication
 
        DEBUGF  2, "SSH: User authentication\n"
 
        stdcall ssh_send_packet, con, ssh_request_userauth, ssh_request_userauth.length, 0
        cmp     eax, -1
        je      socket_err
 
; << Check for userauth acceptance
 
        stdcall ssh_recv_packet, con, 0
        cmp     eax, -1
        je      socket_err
 
        cmp     [con.rx_buffer.message_code], SSH_MSG_USERAUTH_SUCCESS
        jne     proto_err
 
; >> Open channel
 
        DEBUGF  2, "SSH: Open channel\n"
 
        stdcall ssh_send_packet, con, ssh_channel_open, ssh_channel_open.length, 0
        cmp     eax, -1
        je      socket_err
 
; << Check for channel open confirmation
 
        stdcall ssh_recv_packet, con, 0
        cmp     eax, -1
        je      socket_err
 
        cmp     [con.rx_buffer.message_code], SSH_MSG_CHANNEL_OPEN_CONFIRMATION
        jne     proto_err
 
; >> Channel request: pty
 
        DEBUGF  2, "SSH: Request pty\n"
 
        stdcall ssh_send_packet, con, ssh_channel_request, ssh_channel_request.length, 0
        cmp     eax, -1
        je      socket_err
 
; << Check for channel request confirmation
 
        stdcall ssh_recv_packet, con, 0
        cmp     eax, -1
        je      socket_err
 
        cmp     [con.rx_buffer.message_code], SSH_MSG_CHANNEL_SUCCESS
        jne     proto_err
 
; >> Channel request: shell
 
        DEBUGF  2, "SSH: Request shell\n"
 
        stdcall ssh_send_packet, con, ssh_shell_request, ssh_shell_request.length, 0
        cmp     eax, -1
        je      socket_err
 
; << Check for channel request confirmation (FIXME: this may not be first packet!)
 
;        stdcall ssh_recv_packet, con, 0
;        cmp     eax, -1
;        je      socket_err
 
;        cmp     [con.rx_buffer.message_code], SSH_MSG_CHANNEL_SUCCESS
;        jne     proto_err
 
; Launch network thread
        mcall   18, 7
        push    eax
        mcall   51, 1, thread, mem - 2048
        pop     ecx
        mcall   18, 3
 
mainloop:
        call    [con_get_flags]
        test    eax, 0x200                      ; con window closed?
        jnz     exit
 
        stdcall ssh_recv_packet, con, 0
        cmp     eax, 0
        jbe     closed
 
        cmp     [con.rx_buffer.message_code], SSH_MSG_CHANNEL_DATA
        jne     .dump
 
        mov     eax, dword[con.rx_buffer.message_code+5]
        bswap   eax
        DEBUGF  1, 'SSH: got %u bytes of data !\n', eax
 
        lea     esi, [con.rx_buffer.message_code+5+4]
        mov     ecx, eax
        lea     edi, [esi + eax]
        mov     byte [edi], 0
        invoke  con_write_asciiz, esi
        jmp     mainloop
 
  .dump:
        lea     esi, [con.rx_buffer]
        mov     ecx, eax
        pusha
@@:
        lodsb
        DEBUGF  1, "%x ", eax:2
        dec     ecx
        jnz     @r
        popa
        DEBUGF  1, "\n"
        jmp     mainloop
 
 
proto_err:
        DEBUGF  3, "SSH: protocol error\n"
        invoke  con_write_asciiz, str7
        jmp     prompt
 
socket_err:
        DEBUGF  3, "SSH: socket error %d\n", ebx
        invoke  con_write_asciiz, str6
        jmp     prompt
 
dns_error:
        DEBUGF  3, "SSH: DNS error %d\n", eax
        invoke  con_write_asciiz, str5
        jmp     prompt
 
hostname_error:
        invoke  con_write_asciiz, str10
        jmp     prompt
 
closed:
        invoke  con_write_asciiz, str11
        jmp     prompt
 
done:
        invoke  con_exit, 1
exit:
        DEBUGF  3, "SSH: Exiting\n"
        mcall   close, [con.socketnum]
        mcall   -1
 
 
thread:
        mcall   40, 0
  .loop:
        invoke  con_getch2
        mov     [ssh_channel_data+9], al
        stdcall ssh_send_packet, con, ssh_channel_data, ssh_channel_data.length, 0
 
        invoke  con_get_flags
        test    eax, 0x200                      ; con window closed?
        jz      .loop
        mcall   -1
 
; data
title   db      'Secure Shell',0
str1    db      'SSH client for KolibriOS',10,10,\
                'Please enter URL of SSH server (host:port)',10,10,0
str2    db      '> ',0
str3    db      'Connecting to ',0
str4    db      10,0
str5    db      'Name resolution failed.',10,10,0
str6    db      'A socket error occured.',10,10,0
str7    db      'A protocol error occured.',10,10,0
str8    db      ' (',0
str9    db      ')',10,0
str10   db      'Invalid hostname.',10,10,0
str11   db      10,'Remote host closed the connection.',10,10,0
str12   db      'Enter username: ',0
 
ssh_ident_ha:
        dd_n (ssh_ident.length-2)
ssh_ident:
        db "SSH-2.0-KolibriOS_SSH_0.02",13,10
  .length = $ - ssh_ident
 
ssh_kex:
        db SSH_MSG_KEXINIT
  .cookie:
        rd 4
  .kex_algorithms:
        dd_n .server_host_key_algorithms - .kex_algorithms - 4
        db "diffie-hellman-group-exchange-sha256" ; diffie-hellman-group-exchange-sha1
  .server_host_key_algorithms:
        dd_n .encryption_algorithms_client_to_server - .server_host_key_algorithms - 4
        db "ssh-rsa"                    ;,ssh-dss
  .encryption_algorithms_client_to_server:
        dd_n .encryption_algorithms_server_to_client - .encryption_algorithms_client_to_server - 4
        db "aes256-cbc"                 ;,aes256-ctr,aes256-cbc,rijndael-cbc@lysator.liu.se,aes192-ctr,aes192-cbc,aes128-ctr,aes128-cbc,blowfish-ctr,blowfish-cbc,3des-ctr,3des-cbc,arcfour256,arcfour128"
  .encryption_algorithms_server_to_client:
        dd_n .mac_algorithms_client_to_server - .encryption_algorithms_server_to_client - 4
        db "aes256-cbc"                 ;,aes256-ctr,aes256-cbc,rijndael-cbc@lysator.liu.se,aes192-ctr,aes192-cbc,aes128-ctr,aes128-cbc,blowfish-ctr,blowfish-cbc,3des-ctr,3des-cbc,arcfour256,arcfour128"
  .mac_algorithms_client_to_server:
        dd_n .mac_algorithms_server_to_client - .mac_algorithms_client_to_server - 4
        db "hmac-sha2-256"              ;,hmac-sha1,hmac-sha1-96,hmac-md5"
  .mac_algorithms_server_to_client:
        dd_n .compression_algorithms_client_to_server - .mac_algorithms_server_to_client - 4
        db "hmac-sha2-256"              ;,hmac-sha1,hmac-sha1-96,hmac-md5"
  .compression_algorithms_client_to_server:
        dd_n .compression_algorithms_server_to_client - .compression_algorithms_client_to_server - 4
        db "none"                       ;,zlib"
  .compression_algorithms_server_to_client:
        dd_n .languages_client_to_server - .compression_algorithms_server_to_client - 4
        db "none"                       ;,zlib"
  .languages_client_to_server:
        dd_n .languages_server_to_client - .languages_client_to_server - 4
        db ""
  .languages_server_to_client:
        dd_n .first_kex_packet_follows - .languages_server_to_client - 4
        db ""
  .first_kex_packet_follows:
        db 0
  .reserved:
        dd_n 0
  .length = $ - ssh_kex
 
 
ssh_gex_req:
        db SSH_MSG_KEX_DH_GEX_REQUEST
        dd_n 8192/4                      ; DH GEX min
        dd_n 8192/2                      ; DH GEX number of bits
        dd_n 8192                        ; DH GEX Max
  .length = $ - ssh_gex_req
 
 
ssh_new_keys:
        db SSH_MSG_NEWKEYS
  .length = $ - ssh_new_keys
 
 
ssh_request_service:
        db SSH_MSG_SERVICE_REQUEST
        dd_n 12                         ; String length
        db "ssh-userauth"               ; Service name
  .length = $ - ssh_request_service
 
 
ssh_request_userauth:
        db SSH_MSG_USERAUTH_REQUEST
        dd_n 12
        dd_n 8
        db "username"                   ; user name in ISO-10646 UTF-8 encoding [RFC3629]
        dd_n 14
        db "ssh-connection"             ; service name in US-ASCII
        dd_n 4
        db "none"                       ; method name in US-ASCII
; Other options: publickey, password, hostbased
  .length = $ - ssh_request_userauth
 
 
ssh_channel_open:
        db SSH_MSG_CHANNEL_OPEN
        dd_n 7
        db "session"
        dd_n 0                          ; Sender channel
        dd_n 1024                       ; Initial window size
        dd_n 1024                       ; maximum packet size
  .length = $ - ssh_channel_open
 
ssh_channel_request:
        db SSH_MSG_CHANNEL_REQUEST
        dd_n 0                          ; Recipient channel
        dd_n 7
        db "pty-req"
        db 1                            ; Bool: want reply
        dd_n 5
        db "xterm"
        dd_n 80                         ; terminal width (rows)
        dd_n 25                         ; terminal height (rows)
        dd_n 0                          ; terminal width (pixels)
        dd_n 0                          ; terminal height (pixels)
 
        dd_n 0                          ; list of supported opcodes
  .length = $ - ssh_channel_request
 
ssh_shell_request:
        db SSH_MSG_CHANNEL_REQUEST
        dd_n 0                          ; Recipient channel
        dd_n 5
        db "shell"
        db 1                            ; Bool: want reply
  .length = $ - ssh_shell_request
 
ssh_channel_data:
        db SSH_MSG_CHANNEL_DATA
        dd_n 0                          ; Sender channel
        dd_n 1
        db ?
  .length = $ - ssh_channel_data
 
 
include_debug_strings
 
align 4
@IMPORT:
 
library network, 'network.obj', \
        console, 'console.obj', \
        libcrash, 'libcrash.obj'
 
import  network, \
        getaddrinfo, 'getaddrinfo', \
        freeaddrinfo, 'freeaddrinfo', \
        inet_ntoa, 'inet_ntoa'
 
import  console, \
        con_start, 'START', \
        con_init, 'con_init', \
        con_write_asciiz, 'con_write_asciiz', \
        con_exit, 'con_exit', \
        con_gets, 'con_gets', \
        con_cls, 'con_cls', \
        con_getch2, 'con_getch2', \
        con_set_cursor_pos, 'con_set_cursor_pos', \
        con_write_string, 'con_write_string', \
        con_get_flags,  'con_get_flags'
 
import  libcrash, \
        sha256_init, 'sha256_init', \
        sha256_update, 'sha256_update', \
        sha256_final, 'sha256_final',\
        sha1_init, 'sha1_init', \
        sha1_update, 'sha1_update', \
        sha1_final, 'sha1_final', \
        md5_init, 'md5_init', \
        md5_update, 'md5_update', \
        md5_final, 'md5_final'
 
IncludeIGlobals
 
i_end:
 
IncludeUGlobals
 
params          rb 1024
 
con             ssh_connection
 
 
 
 
 
mem:

Rev 6469	Rev 6922
1	; ssh.asm - SSH client for KolibriOS	1	; ssh.asm - SSH client for KolibriOS
2	;	2	;
3	; Copyright (C) 2015-2016 Jeffrey Amelynck	3	; Copyright (C) 2015-2017 Jeffrey Amelynck
4	;	4	;
5	; This program is free software: you can redistribute it and/or modify	5	; This program is free software: you can redistribute it and/or modify
6	; it under the terms of the GNU General Public License as published by	6	; it under the terms of the GNU General Public License as published by
7	; the Free Software Foundation, either version 3 of the License, or	7	; the Free Software Foundation, either version 3 of the License, or
8	; (at your option) any later version.	8	; (at your option) any later version.
9	;	9	;
10	; This program is distributed in the hope that it will be useful,	10	; This program is distributed in the hope that it will be useful,
11	; but WITHOUT ANY WARRANTY; without even the implied warranty of	11	; but WITHOUT ANY WARRANTY; without even the implied warranty of
12	; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	12	; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	; GNU General Public License for more details.	13	; GNU General Public License for more details.
14	;	14	;
15	; You should have received a copy of the GNU General Public License	15	; You should have received a copy of the GNU General Public License
16	; along with this program. If not, see .	16	; along with this program. If not, see .
17		17
18	format binary as ""	18	format binary as ""
19		19
20	__DEBUG__ = 1	20	__DEBUG__ = 1
21	__DEBUG_LEVEL__ = 2 ; 1: Extreme debugging, 2: Debugging, 3: Errors only	21	__DEBUG_LEVEL__ = 2 ; 1: Extreme debugging, 2: Debugging, 3: Errors only
22		22
23	BUFFERSIZE = 4096	23	BUFFERSIZE = 4096
24	MAX_BITS = 8192	24	MAX_BITS = 8192
25		25
26	DH_PRIVATE_KEY_SIZE = 256	26	DH_PRIVATE_KEY_SIZE = 256
27		27
28	use32	28	use32
29		29
30	db 'MENUET01' ; signature	30	db 'MENUET01' ; signature
31	dd 1 ; header version	31	dd 1 ; header version
32	dd start ; entry point	32	dd start ; entry point
33	dd i_end ; initialized size	33	dd i_end ; initialized size
34	dd mem+4096 ; required memory	34	dd mem+65536 ; required memory
35	dd mem+4096 ; stack pointer	35	dd mem+65536 ; stack pointer
36	dd params ; parameters	36	dd params ; parameters
37	dd 0 ; path	37	dd 0 ; path
38		38
39	include '../../macros.inc'	39	include '../../macros.inc'
40	;include '../../struct.inc'	40	;include '../../struct.inc'
41	purge mov,add,sub	41	purge mov,add,sub
42	include '../../proc32.inc'	42	include '../../proc32.inc'
43	include '../../dll.inc'	43	include '../../dll.inc'
44	include '../../debug-fdo.inc'	44	include '../../debug-fdo.inc'
45	include '../../network.inc'	45	include '../../network.inc'
46	include '../../develop/libraries/libcrash/trunk/libcrash.inc'	46	include '../../develop/libraries/libcrash/trunk/libcrash.inc'
47		47
48	include 'mcodes.inc'	48	include 'mcodes.inc'
49	include 'ssh_transport.inc'	49	include 'ssh_transport.inc'
-		50
50	include 'dh_gex.inc'	51	include 'dh_gex.inc'
51		52
52	include 'mpint.inc'	53	include 'mpint.inc'
53	include 'random.inc'	54	include 'random.inc'
-		55
54	include 'aes256.inc'	56	include 'aes256.inc'
55	include 'aes256-ctr.inc'	57	include 'aes256-ctr.inc'
56	include 'aes256-cbc.inc'	58	include 'aes256-cbc.inc'
-		59
57	include 'hmac_sha256.inc'	60	include 'hmac_sha256.inc'
-		61	include 'hmac_sha1.inc'
-		62	include 'hmac_md5.inc'
58		63
59	; macros for network byte order	64	; macros for network byte order
60	macro dd_n op {	65	macro dd_n op {
61	dd 0 or (((op) and 0FF000000h) shr 24) or \	66	dd 0 or (((op) and 0FF000000h) shr 24) or \
62	(((op) and 000FF0000h) shr 8) or \	67	(((op) and 000FF0000h) shr 8) or \
63	(((op) and 00000FF00h) shl 8) or \	68	(((op) and 00000FF00h) shl 8) or \
64	(((op) and 0000000FFh) shl 24)	69	(((op) and 0000000FFh) shl 24)
65	}	70	}
66		71
67	macro dw_n op {	72	macro dw_n op {
68	dw 0 or (((op) and 0FF00h) shr 8) or \	73	dw 0 or (((op) and 0FF00h) shr 8) or \
69	(((op) and 000FFh) shl 8)	74	(((op) and 000FFh) shl 8)
70	}	75	}
71		76
72	proc dump_hex _ptr, _length	77	proc dump_hex _ptr, _length
73	if __DEBUG_LEVEL__ <= 1	78	if __DEBUG_LEVEL__ <= 1
74	pushad	79	pushad
75		80
76	mov esi, [_ptr]	81	mov esi, [_ptr]
77	mov ecx, [_length]	82	mov ecx, [_length]
78	.next_dword:	83	.next_dword:
79	lodsd	84	lodsd
80	bswap eax	85	bswap eax
81	DEBUGF 1,'%x',eax	86	DEBUGF 1,'%x',eax
82	loop .next_dword	87	loop .next_dword
83	DEBUGF 1,'\n'	88	DEBUGF 1,'\n'
84		89
85	popad	90	popad
86	ret	91	ret
87	end if	92	end if
88	endp	93	endp
89		94
90	struct ssh_connection	95	struct ssh_connection
91		96
92	; Connection	97	; Connection
93		98
94	hostname rb 1024	99	hostname rb 1024
95		100
96	socketnum dd ?	101	socketnum dd ?
97		102
98	sockaddr dw ? ; Address family	103	sockaddr dw ? ; Address family
99	port dw ?	104	port dw ?
100	ip dd ?	105	ip dd ?
101	rb 10	106	rb 10
102		107
103	; Encryption/Decryption	108	; Encryption/Decryption
104		109
105	rx_crypt_proc dd ?	110	rx_crypt_proc dd ?
106	tx_crypt_proc dd ?	111	tx_crypt_proc dd ?
107	rx_crypt_ctx_ptr dd ?	112	rx_crypt_ctx_ptr dd ?
108	tx_crypt_ctx_ptr dd ?	113	tx_crypt_ctx_ptr dd ?
109	rx_crypt_blocksize dd ?	114	rx_crypt_blocksize dd ?
110	tx_crypt_blocksize dd ?	115	tx_crypt_blocksize dd ?
111		116
112	; Message authentication	117	; Message authentication
113		118
114	rx_mac_proc dd ?	119	rx_mac_proc dd ?
115	tx_mac_proc dd ?	120	tx_mac_proc dd ?
116	rx_mac_ctx hmac_sha256_context	121	rx_mac_ctx hmac_sha256_context
117	tx_mac_ctx hmac_sha256_context	122	tx_mac_ctx hmac_sha256_context
118	rx_mac_length dd ?	123	rx_mac_length dd ?
119	tx_mac_length dd ?	124	tx_mac_length dd ?
120		125
121	; Buffers	126	; Buffers
122		127
123	rx_seq dd ? ; Packet sequence number for MAC	128	rx_seq dd ? ; Packet sequence number for MAC
124	rx_buffer ssh_packet_header	129	rx_buffer ssh_packet_header
125	rb BUFFERSIZE-sizeof.ssh_packet_header	130	rb BUFFERSIZE-sizeof.ssh_packet_header
126		131
127	tx_seq dd ? ; Packet sequence number for MAC	132	tx_seq dd ? ; Packet sequence number for MAC
128	tx_buffer ssh_packet_header	133	tx_buffer ssh_packet_header
129	rb BUFFERSIZE-sizeof.ssh_packet_header	134	rb BUFFERSIZE-sizeof.ssh_packet_header
130		135
131	send_data dw ?	136	send_data dw ?
132		137
133	; Output from key exchange	138	; Output from key exchange
134	dh_K dd ? ; Shared Secret (Big endian)	139	dh_K dd ? ; Shared Secret (Big endian)
135	rb MAX_BITS/8	140	rb MAX_BITS/8
136	dh_K_length dd ? ; Length in little endian	141	dh_K_length dd ? ; Length in little endian
137		142
138	dh_H rb 32 ; Exchange Hash	143	dh_H rb 32 ; Exchange Hash
139	session_id_prefix db ?	144	session_id_prefix db ?
140	session_id rb 32	145	session_id rb 32
141	rx_iv rb 32 ; Rx initialisation vector	146	rx_iv rb 32 ; Rx initialisation vector
142	tx_iv rb 32 ; Tx initialisation vector	147	tx_iv rb 32 ; Tx initialisation vector
143	rx_enc_key rb 32 ; Rx encryption key	148	rx_enc_key rb 32 ; Rx encryption key
144	tx_enc_key rb 32 ; Tx encryption key	149	tx_enc_key rb 32 ; Tx encryption key
145	rx_int_key rb 32 ; Rx integrity key	150	rx_int_key rb 32 ; Rx integrity key
146	tx_int_key rb 32 ; Tx integrity key	151	tx_int_key rb 32 ; Tx integrity key
147		152
148	; Diffie Hellman	153	; Diffie Hellman
149	dh_p dd ?	154	dh_p dd ?
150	rb MAX_BITS/8	155	rb MAX_BITS/8
151	dh_g dd ?	156	dh_g dd ?
152	rb MAX_BITS/8	157	rb MAX_BITS/8
153	dh_x dd ?	158	dh_x dd ?
154	rb MAX_BITS/8	159	rb MAX_BITS/8
155	dh_e dd ?	160	dh_e dd ?
156	rb MAX_BITS/8	161	rb MAX_BITS/8
157	dh_f dd ?	162	dh_f dd ?
158	rb MAX_BITS/8	163	rb MAX_BITS/8
159		164
160	dh_signature dd ?	165	dh_signature dd ?
161	rb MAX_BITS/8	166	rb MAX_BITS/8
162		167
163	temp_ctx ctx_sha224256	168	temp_ctx ctx_sha224256
164	k_h_ctx ctx_sha224256	169	k_h_ctx ctx_sha224256
-		170
-		171	mpint_tmp dd ?
-		172	rb MAX_BITS/8
165		173
166	ends	174	ends
167		175
168	start:	176	start:
169	mcall 68, 11 ; Init heap	177	mcall 68, 11 ; Init heap
170		178
171	DEBUGF 2, "SSH: Loading libraries\n"	179	DEBUGF 2, "SSH: Loading libraries\n"
172	stdcall dll.Load, @IMPORT	180	stdcall dll.Load, @IMPORT
173	test eax, eax	181	test eax, eax
174	jnz exit	182	jnz exit
175		183
176	DEBUGF 2, "SSH: Init PRNG\n"	184	DEBUGF 2, "SSH: Init PRNG\n"
177	call init_random	185	call init_random
178		186
179	DEBUGF 2, "SSH: Init Console\n"	187	DEBUGF 2, "SSH: Init Console\n"
180	invoke con_start, 1	188	invoke con_start, 1
181	invoke con_init, 80, 25, 80, 25, title	189	invoke con_init, 80, 25, 80, 25, title
182		190
183	; Check for parameters TODO	191	; Check for parameters TODO
184	; cmp byte[params], 0	192	; cmp byte[params], 0
185	; jne resolve	193	; jne resolve
186		194
187	main:	195	main:
188	invoke con_cls	196	invoke con_cls
189	; Welcome user	197	; Welcome user
190	invoke con_write_asciiz, str1	198	invoke con_write_asciiz, str1
191		199
192	prompt:	200	prompt:
193	; write prompt	201	; write prompt
194	invoke con_write_asciiz, str2	202	invoke con_write_asciiz, str2
195	; read string	203	; read string
196	mov esi, con.hostname	204	mov esi, con.hostname
197	invoke con_gets, esi, 256	205	invoke con_gets, esi, 256
198	; check for exit	206	; check for exit
199	test eax, eax	207	test eax, eax
200	jz done	208	jz done
201	cmp byte[esi], 10	209	cmp byte[esi], 10
202	jz done	210	jz done
203		211
204	resolve:	212	resolve:
205	mov [con.sockaddr], AF_INET4	213	mov [con.sockaddr], AF_INET4
206	mov [con.port], 22 shl 8	214	mov [con.port], 22 shl 8
207		215
208	; delete terminating '\n'	216	; delete terminating '\n'
209	mov esi, con.hostname	217	mov esi, con.hostname
210	@@:	218	@@:
211	lodsb	219	lodsb
212	cmp al, ':'	220	cmp al, ':'
213	je .do_port	221	je .do_port
214	cmp al, 0x20	222	cmp al, 0x20
215	ja @r	223	ja @r
216	mov byte[esi-1], 0	224	mov byte[esi-1], 0
217	jmp .done	225	jmp .done
218		226
219	.do_port:	227	.do_port:
220	xor eax, eax	228	xor eax, eax
221	xor ebx, ebx	229	xor ebx, ebx
222	mov byte[esi-1], 0	230	mov byte[esi-1], 0
223	.portloop:	231	.portloop:
224	lodsb	232	lodsb
225	cmp al, 0x20	233	cmp al, 0x20
226	jbe .port_done	234	jbe .port_done
227	sub al, '0'	235	sub al, '0'
228	jb hostname_error	236	jb hostname_error
229	cmp al, 9	237	cmp al, 9
230	ja hostname_error	238	ja hostname_error
231	lea ebx, [ebx*4+ebx]	239	lea ebx, [ebx*4+ebx]
232	shl ebx, 1	240	shl ebx, 1
233	add ebx, eax	241	add ebx, eax
234	jmp .portloop	242	jmp .portloop
235		243
236	.port_done:	244	.port_done:
237	xchg bl, bh	245	xchg bl, bh
238	mov [con.port], bx	246	mov [con.port], bx
239		247
240	.done:	248	.done:
241		249
242	; resolve name	250	; resolve name
243	push esp ; reserve stack place	251	push esp ; reserve stack place
244	push esp	252	push esp
245	invoke getaddrinfo, con.hostname, 0, 0	253	invoke getaddrinfo, con.hostname, 0, 0
246	pop esi	254	pop esi
247	; test for error	255	; test for error
248	test eax, eax	256	test eax, eax
249	jnz dns_error	257	jnz dns_error
250		258
251	invoke con_cls	259	invoke con_cls
252	invoke con_write_asciiz, str3	260	invoke con_write_asciiz, str3
253	invoke con_write_asciiz, con.hostname	261	invoke con_write_asciiz, con.hostname
254		262
255	; write results	263	; write results
256	invoke con_write_asciiz, str8	264	invoke con_write_asciiz, str8
257		265
258	; convert IP address to decimal notation	266	; convert IP address to decimal notation
259	mov eax, [esi+addrinfo.ai_addr]	267	mov eax, [esi+addrinfo.ai_addr]
260	mov eax, [eax+sockaddr_in.sin_addr]	268	mov eax, [eax+sockaddr_in.sin_addr]
261	mov [con.ip], eax	269	mov [con.ip], eax
262	invoke inet_ntoa, eax	270	invoke inet_ntoa, eax
263	; write result	271	; write result
264	invoke con_write_asciiz, eax	272	invoke con_write_asciiz, eax
265	; free allocated memory	273	; free allocated memory
266	invoke freeaddrinfo, esi	274	invoke freeaddrinfo, esi
267		275
268	invoke con_write_asciiz, str9	276	invoke con_write_asciiz, str9
269		277
270	mcall 40, EVM_STACK + EVM_KEY	278	mcall 40, EVM_STACK + EVM_KEY
271	invoke con_cls	279	invoke con_cls
272		280
273	; Create socket	281	; Create socket
274	mcall socket, AF_INET4, SOCK_STREAM, 0	282	mcall socket, AF_INET4, SOCK_STREAM, 0
275	cmp eax, -1	283	cmp eax, -1
276	jz socket_err	284	jz socket_err
277	mov [con.socketnum], eax	285	mov [con.socketnum], eax
278		286
279	; Connect	287	; Connect
280	DEBUGF 2, "Connecting to server\n"	288	DEBUGF 2, "Connecting to server\n"
281	mcall connect, [con.socketnum], con.sockaddr, 18	289	mcall connect, [con.socketnum], con.sockaddr, 18
282	test eax, eax	290	test eax, eax
283	jnz socket_err	291	jnz socket_err
284		292
285	; Start calculating hash	293	; Start calculating hash
286	invoke sha256_init, con.temp_ctx	294	invoke sha256_init, con.temp_ctx
287	; HASH: string V_C, the client's version string (CR and NL excluded)	295	; HASH: string V_C, the client's version string (CR and NL excluded)
288	invoke sha256_update, con.temp_ctx, ssh_ident_ha, ssh_ident.length+4-2	296	invoke sha256_update, con.temp_ctx, ssh_ident_ha, ssh_ident.length+4-2
289		297
290	; >> Send our identification string	298	; >> Send our identification string
291	DEBUGF 2, "Sending ID string\n"	299	DEBUGF 2, "Sending ID string\n"
292	mcall send, [con.socketnum], ssh_ident, ssh_ident.length, 0	300	mcall send, [con.socketnum], ssh_ident, ssh_ident.length, 0
293	cmp eax, -1	301	cmp eax, -1
294	je socket_err	302	je socket_err
295		303
296	; << Check protocol version of server	304	; << Check protocol version of server
297	mcall recv, [con.socketnum], con.rx_buffer, BUFFERSIZE, 0	305	mcall recv, [con.socketnum], con.rx_buffer, BUFFERSIZE, 0
298	cmp eax, -1	306	cmp eax, -1
299	je socket_err	307	je socket_err
300		308
301	DEBUGF 2, "Received ID string\n"	309	DEBUGF 2, "Received ID string\n"
302	cmp dword[con.rx_buffer], "SSH-"	310	cmp dword[con.rx_buffer], "SSH-"
303	jne proto_err	311	jne proto_err
304	cmp dword[con.rx_buffer+4], "2.0-"	312	cmp dword[con.rx_buffer+4], "2.0-"
305	jne proto_err	313	jne proto_err
306		314
307	; HASH: string V_S, the server's version string (CR and NL excluded)	315	; HASH: string V_S, the server's version string (CR and NL excluded)
308	lea edx, [eax+2]	316	lea edx, [eax+2]
309	sub eax, 2	317	sub eax, 2
310	bswap eax	318	bswap eax
311	mov dword[con.rx_buffer-4], eax	319	mov dword[con.rx_buffer-4], eax
312	invoke sha256_update, con.temp_ctx, con.rx_buffer-4, edx	320	invoke sha256_update, con.temp_ctx, con.rx_buffer-4, edx
313		321
314	; >> Key Exchange init	322	; >> Key Exchange init
315	mov [con.rx_seq], 0	323	mov [con.rx_seq], 0
316	mov [con.tx_seq], 0	324	mov [con.tx_seq], 0
317	mov [con.rx_crypt_blocksize], 4 ; minimum blocksize	325	mov [con.rx_crypt_blocksize], 4 ; minimum blocksize
318	mov [con.tx_crypt_blocksize], 4	326	mov [con.tx_crypt_blocksize], 4
319	mov [con.rx_crypt_proc], 0	327	mov [con.rx_crypt_proc], 0
320	mov [con.tx_crypt_proc], 0	328	mov [con.tx_crypt_proc], 0
321	mov [con.rx_mac_proc], 0	329	mov [con.rx_mac_proc], 0
322	mov [con.tx_mac_proc], 0	330	mov [con.tx_mac_proc], 0
323	mov [con.rx_mac_length], 0	331	mov [con.rx_mac_length], 0
324	mov [con.tx_mac_length], 0	332	mov [con.tx_mac_length], 0
325		333
326	DEBUGF 2, "Sending KEX init\n"	334	DEBUGF 2, "Sending KEX init\n"
327	mov edi, ssh_kex.cookie	335	mov edi, ssh_kex.cookie
328	call MBRandom	336	call MBRandom
329	stosd	337	stosd
330	call MBRandom	338	call MBRandom
331	stosd	339	stosd
332	call MBRandom	340	call MBRandom
333	stosd	341	stosd
334	call MBRandom	342	call MBRandom
335	stosd	343	stosd
336	stdcall ssh_send_packet, con, ssh_kex, ssh_kex.length, 0	344	stdcall ssh_send_packet, con, ssh_kex, ssh_kex.length, 0
337	cmp eax, -1	345	cmp eax, -1
338	je socket_err	346	je socket_err
339		347
340	; HASH: string I_C, the payload of the client's SSH_MSG_KEXINIT	348	; HASH: string I_C, the payload of the client's SSH_MSG_KEXINIT
341	mov eax, dword[con.tx_buffer+ssh_packet_header.packet_length]	349	mov eax, dword[con.tx_buffer+ssh_packet_header.packet_length]
342	bswap eax	350	bswap eax
343	movzx ebx, [con.tx_buffer+ssh_packet_header.padding_length]	351	movzx ebx, [con.tx_buffer+ssh_packet_header.padding_length]
344	sub eax, ebx	352	sub eax, ebx
345	dec eax	353	dec eax
346	lea edx, [eax+4]	354	lea edx, [eax+4]
347	bswap eax	355	bswap eax
348	mov dword[con.tx_buffer+1], eax	356	mov dword[con.tx_buffer+1], eax
349	invoke sha256_update, con.temp_ctx, con.tx_buffer+1, edx	357	invoke sha256_update, con.temp_ctx, con.tx_buffer+1, edx
350		358
351	; << Check key exchange init of server	359	; << Check key exchange init of server
352	stdcall ssh_recv_packet, con, 0	360	stdcall ssh_recv_packet, con, 0
353	cmp eax, -1	361	cmp eax, -1
354	je socket_err	362	je socket_err
355		363
356	cmp [con.rx_buffer.message_code], SSH_MSG_KEXINIT	364	cmp [con.rx_buffer.message_code], SSH_MSG_KEXINIT
357	jne proto_err	365	jne proto_err
358	DEBUGF 2, "Received KEX init\n"	366	DEBUGF 2, "Received KEX init\n"
359		367
360	lea esi, [con.rx_buffer+sizeof.ssh_packet_header+16]	368	lea esi, [con.rx_buffer+sizeof.ssh_packet_header+16]
361	lodsd	369	lodsd
362	bswap eax	370	bswap eax
363	DEBUGF 1, "kex_algorithms: %s\n", esi	371	DEBUGF 1, "kex_algorithms: %s\n", esi
364	add esi, eax	372	add esi, eax
365	lodsd	373	lodsd
366	bswap eax	374	bswap eax
367	DEBUGF 1, "server_host_key_algorithms: %s\n", esi	375	DEBUGF 1, "server_host_key_algorithms: %s\n", esi
368	add esi, eax	376	add esi, eax
369	lodsd	377	lodsd
370	bswap eax	378	bswap eax
371	DEBUGF 1, "encryption_algorithms_client_to_server: %s\n", esi	379	DEBUGF 1, "encryption_algorithms_client_to_server: %s\n", esi
372	add esi, eax	380	add esi, eax
373	lodsd	381	lodsd
374	bswap eax	382	bswap eax
375	DEBUGF 1, "encryption_algorithms_server_to_client: %s\n", esi	383	DEBUGF 1, "encryption_algorithms_server_to_client: %s\n", esi
376	add esi, eax	384	add esi, eax
377	lodsd	385	lodsd
378	bswap eax	386	bswap eax
379	DEBUGF 1, "mac_algorithms_client_to_server: %s\n", esi	387	DEBUGF 1, "mac_algorithms_client_to_server: %s\n", esi
380	add esi, eax	388	add esi, eax
381	lodsd	389	lodsd
382	bswap eax	390	bswap eax
383	DEBUGF 1, "mac_algorithms_server_to_client: %s\n", esi	391	DEBUGF 1, "mac_algorithms_server_to_client: %s\n", esi
384	add esi, eax	392	add esi, eax
385	lodsd	393	lodsd
386	bswap eax	394	bswap eax
387	DEBUGF 1, "compression_algorithms_client_to_server: %s\n", esi	395	DEBUGF 1, "compression_algorithms_client_to_server: %s\n", esi
388	add esi, eax	396	add esi, eax
389	lodsd	397	lodsd
390	bswap eax	398	bswap eax
391	DEBUGF 1, "compression_algorithms_server_to_client: %s\n", esi	399	DEBUGF 1, "compression_algorithms_server_to_client: %s\n", esi
392	add esi, eax	400	add esi, eax
393	lodsd	401	lodsd
394	bswap eax	402	bswap eax
395	DEBUGF 1, "languages_client_to_server: %s\n", esi	403	DEBUGF 1, "languages_client_to_server: %s\n", esi
396	add esi, eax	404	add esi, eax
397	lodsd	405	lodsd
398	bswap eax	406	bswap eax
399	DEBUGF 1, "languages_server_to_client: %s\n", esi	407	DEBUGF 1, "languages_server_to_client: %s\n", esi
400	add esi, eax	408	add esi, eax
401	lodsb	409	lodsb
402	DEBUGF 1, "KEX First Packet Follows: %u\n", al	410	DEBUGF 1, "KEX First Packet Follows: %u\n", al
403		411
404	; TODO: parse this structure and init procedures accordingly	412	; TODO: parse this structure and init procedures accordingly
405		413
406	; HASH: string I_S, the payload of the servers's SSH_MSG_KEXINIT	414	; HASH: string I_S, the payload of the servers's SSH_MSG_KEXINIT
407	mov eax, dword[con.rx_buffer+ssh_packet_header.packet_length]	415	mov eax, dword[con.rx_buffer+ssh_packet_header.packet_length]
408	movzx ebx, [con.rx_buffer+ssh_packet_header.padding_length]	416	movzx ebx, [con.rx_buffer+ssh_packet_header.padding_length]
409	sub eax, ebx	417	sub eax, ebx
410	dec eax	418	dec eax
411	lea edx, [eax+4]	419	lea edx, [eax+4]
412	bswap eax	420	bswap eax
413	mov dword[con.rx_buffer+sizeof.ssh_packet_header-5], eax	421	mov dword[con.rx_buffer+sizeof.ssh_packet_header-5], eax
414	invoke sha256_update, con.temp_ctx, con.rx_buffer+sizeof.ssh_packet_header-5, edx	422	invoke sha256_update, con.temp_ctx, con.rx_buffer+sizeof.ssh_packet_header-5, edx
415		423
416	; Exchange keys with the server	424	; Exchange keys with the server
417		425
418	stdcall dh_gex	426	stdcall dh_gex
419	test eax, eax	427	test eax, eax
420	jnz exit	428	jnz exit
421		429
422	; Set keys	430	; Set keys
423		431
424	DEBUGF 2, "SSH: Setting encryption keys\n"	432	DEBUGF 2, "SSH: Setting encryption keys\n"
425		433
426	stdcall aes256_cbc_init, con.rx_iv	434	stdcall aes256_cbc_init, con.rx_iv
427	mov [con.rx_crypt_ctx_ptr], eax	435	mov [con.rx_crypt_ctx_ptr], eax
428		436
429	stdcall aes256_set_decrypt_key, eax, con.rx_enc_key	437	stdcall aes256_set_decrypt_key, eax, con.rx_enc_key
430	mov [con.rx_crypt_proc], aes256_cbc_decrypt	438	mov [con.rx_crypt_proc], aes256_cbc_decrypt
431	mov [con.rx_crypt_blocksize], AES256_BLOCKSIZE	439	mov [con.rx_crypt_blocksize], AES256_BLOCKSIZE
432		440
433	stdcall aes256_cbc_init, con.tx_iv	441	stdcall aes256_cbc_init, con.tx_iv
434	mov [con.tx_crypt_ctx_ptr], eax	442	mov [con.tx_crypt_ctx_ptr], eax
435		443
436	stdcall aes256_set_encrypt_key, eax, con.tx_enc_key	444	stdcall aes256_set_encrypt_key, eax, con.tx_enc_key
437	mov [con.tx_crypt_proc], aes256_cbc_encrypt	445	mov [con.tx_crypt_proc], aes256_cbc_encrypt
438	mov [con.tx_crypt_blocksize], AES256_BLOCKSIZE	446	mov [con.tx_crypt_blocksize], AES256_BLOCKSIZE
439		447
440	stdcall hmac_sha256_setkey, con.rx_mac_ctx, con.rx_int_key, SHA256_HASH_SIZE	448	stdcall hmac_sha256_setkey, con.rx_mac_ctx, con.rx_int_key, SHA256_HASH_SIZE
441	mov [con.rx_mac_proc], hmac_sha256	449	mov [con.rx_mac_proc], hmac_sha256
442	mov [con.rx_mac_length], SHA256_HASH_SIZE	450	mov [con.rx_mac_length], SHA256_HASH_SIZE
443		451
444	stdcall hmac_sha256_setkey, con.tx_mac_ctx, con.tx_int_key, SHA256_HASH_SIZE	452	stdcall hmac_sha256_setkey, con.tx_mac_ctx, con.tx_int_key, SHA256_HASH_SIZE
445	mov [con.tx_mac_proc], hmac_sha256	453	mov [con.tx_mac_proc], hmac_sha256
446	mov [con.tx_mac_length], SHA256_HASH_SIZE	454	mov [con.tx_mac_length], SHA256_HASH_SIZE
447		455
448	; TODO: erase all keys from memory and free the memory	456	; TODO: erase all keys from memory and free the memory
449		457
450	; >> Request service (user-auth)	458	; >> Request service (user-auth)
451		459
452	DEBUGF 2, "SSH: Requesting service\n"	460	DEBUGF 2, "SSH: Requesting service\n"
453		461
454	stdcall ssh_send_packet, con, ssh_request_service, ssh_request_service.length, 0	462	stdcall ssh_send_packet, con, ssh_request_service, ssh_request_service.length, 0
455	cmp eax, -1	463	cmp eax, -1
456	je socket_err	464	je socket_err
457		465
458	; << Check for service acceptance	466	; << Check for service acceptance
459		467
460	stdcall ssh_recv_packet, con, 0	468	stdcall ssh_recv_packet, con, 0
461	cmp eax, -1	469	cmp eax, -1
462	je socket_err	470	je socket_err
463		471
464	cmp [con.rx_buffer.message_code], SSH_MSG_SERVICE_ACCEPT	472	cmp [con.rx_buffer.message_code], SSH_MSG_SERVICE_ACCEPT
465	jne proto_err	473	jne proto_err
466		474
467	; >> Request user authentication	475	; >> Request user authentication
468		476
469	; TODO: Request username from the user	477	; TODO: Request username from the user
470	; invoke con_write_asciiz, str12	478	; invoke con_write_asciiz, str12
471	; invoke con_gets, username, 256	479	; invoke con_gets, username, 256
472	; test eax, eax	480	; test eax, eax
473	; jz done	481	; jz done
474		482
475	; TODO: implement password authentication	483	; TODO: implement password authentication
476		484
477	DEBUGF 2, "SSH: User authentication\n"	485	DEBUGF 2, "SSH: User authentication\n"
478		486
479	stdcall ssh_send_packet, con, ssh_request_userauth, ssh_request_userauth.length, 0	487	stdcall ssh_send_packet, con, ssh_request_userauth, ssh_request_userauth.length, 0
480	cmp eax, -1	488	cmp eax, -1
481	je socket_err	489	je socket_err
482		490
483	; << Check for userauth acceptance	491	; << Check for userauth acceptance
484		492
485	stdcall ssh_recv_packet, con, 0	493	stdcall ssh_recv_packet, con, 0
486	cmp eax, -1	494	cmp eax, -1
487	je socket_err	495	je socket_err
488		496
489	cmp [con.rx_buffer.message_code], SSH_MSG_USERAUTH_SUCCESS	497	cmp [con.rx_buffer.message_code], SSH_MSG_USERAUTH_SUCCESS
490	jne proto_err	498	jne proto_err
491		499
492	; >> Open channel	500	; >> Open channel

Subversion Repositories Kolibri OS

(root)/programs/network/ssh/ssh.asm – Rev 6469 → 6922