Forem: Filipe Câncio

Resolvendo o desafio 509. Fibonacci Number

Filipe Câncio — Sun, 23 Nov 2025 17:43:38 +0000

A lógica do fibonacci é bem simples. O número atual é resultado da soma do número anterior mais o seu anterior (n-1)+(n-2). Considerando apenas o conjunto dos números naturais, adicionamos uma regra para os números 0 e 1, cujo os seus correspondentes são eles mesmos f(0) = 0 e f(1)=1 e assim temos a sequência 0 1 1 2 3 5 ...

podemos começar com então com a que representa a função matemática de Fibonacci f(n) = f(n-1) = f(n-2), a solução recursiva.

Solução recursiva

Na solução recursiva vamos colocar:

Nosso caso base n = 0 e n = 1
E a expressão matemática f(n) = f(n-1) = f(n-2)

É uma solução simples e compreensiva, porém acredite não é a das melhores.

Complexity

Vamos pensar em fib(6), e realizar um teste de mesa (não vou trocar fib(1) e fib(0) por 1 e 0 no nosso teste de mesa porque não precisamos nos apegar ao valor mas ao número de instruções):

Valor	Recursão	Total	Intruções
`fib(6)`	`fib(5)` + `fib(4)`	`fib(1) + fib(0) + fib(1) + fib(1) + fib(0) + fib(1) + fib(0) + fib(1)` + `fib(1) + fib(0) + fib(1) + fib(1) + fib(0)`	13
`fib(5)`	`fib(4)` + `fib(3)`	`fib(1) + fib(0) + fib(1) + fib(1) + fib(0)` + `fib(1) + fib(0) + fib(1)`	8
`fib(4)`	`fib(3)` + `fib(2)`	`fib(1) + fib(0) + fib(1)` + `fib(1) + fib(0)`	5
`fib(3)`	`fib(2)` + `fib(1)`	`fib(1) + fib(0)` + `fib(1)`	3
`fib(2)`	`fib(1)` + `fib(0)`		2

Observando o resultado do nosso teste vemos algo assustador. Para exercutarmos essa função, nos a rodamos o número corresponte ao seu valor em finonacci! Ou seja pensando na perspectiva de f(x) = yda matemática, em um número n de entradas levamos exatamente y para retornar o próprio y!
Aproveitando a matemática, a f(x) = yque corresponde à complexidade de Fibonacci é $\phi$ é o Número de Ouro ($\approx 1.618$). Ou seja a complexidade de tempo dessa função é $O(1.618^n)$ mas a gente arredonda para a complexidade assinstótica de $O(2^n)$.
E quanto armazenamento? podemos ver no teste de mesa que nos igualamos as funções (f(3) = f(2)+f(1)), no fim o código recursivo acaba passando por todas as definições de f(n) e igualando ao seu valor, ou seja, para cada n valor temos salvo n definições ocupando um espaço n de memória.

Em resumo:

Time complexity: $O(2^n)$
Space complexity: $O(n)$

Existe um forma mais rápida de solucionar esse caso e é também simples. Muito parecida com o que nos usamos logo quando quando aprendermos fibonacci na escola.

Solução iterativa

No ensino fundamental, quando a professora pedia para calcularmos o valor de de fibonacci de 20, somávamos a sequencia de valores 20 vezes até chegar o valor correspondente, correto? Nessa solução faremos o mesmo! Vamos iterar de 2 a n somando consecutivamente até chegarmos no nosso valor.
Nesa solução iterativa vamos colocar:

Nosso caso base n = 0 e n = 1,
Uma variável i que começa com 2 e incrementa até n,
Duas variáveis, uma para salvar i-1 e outra i-2 no valor correspondente de i

Podemos falar que essas duas variáveis são dois ponteiros, são dois savepoints, onde eu vou deixar resgistrados valores que me importam. No fim da iteração eu apenas retorno o valor do primeiro ponteiro i-1.

Porque?

Bem durante a iteração, você vai:

Colocar o valor de i-1 em um ponteiro temporário, pode ser um c (i-1 seria a e i-2 seria b),
Somar esse dois ponteiros i-1 e i-2 e salvar em i-1
Colocar o valor de c em i-2

c morre no fim de cada ciclo da iteração, ele so serve pra fazer a troca de valores depois da soma. No fim da iteração o valor em i-1 sempre irá corresponder ao f(n) do próximo valor de i e assim que acaba temos de fato f(n).

Você pode ter olhado o código correspondente da sua linguagem e passado reto nas outras, mas se parar e olhar com calma, cada linguagem tem uma forma interessante de iterar os valores e de passar entre os ponteiros a, b e c. Na real, alguns nem tem o ponteiro c, legal né?

Uma característica que essas linguagens tem em comum é o swap, a capacidade de troca de valores entre variáveis. Vou deixar aqui uma listinha de possibilidade de swap entre linguagens.

Linguagem	Atribuição de valores	Troca de valores
Java	`int a = 1; int b = 0;`	`a = (b += a) - a;`
Kotlin	`var (a, b) = 0 to 1`	`var (a, b) = 1 to 0`
Swift	`var (a, b) = (0, 1)`	`(a, b) = (b, a + b)`
Dart	`var (a, b) = (0, 1)`	`(a, b) = (b, a + b)`

Essas sobreposições de valores causam um efeito significativo nessa versão do algoritmo de fibonacci, a solução em termos de espaço passa a ser $O(1)$, já a de tempo, $O(n)$. Porque? Bem, temos os seguintes pontos:

Nossos ponteiros sempre serão 3 (ou 2...). Na duvida, complexidade assintótica de $O(1)$,
Temos um fluxo de iteração de 2 para n, ou seja executamos as instruções de soma n vezes.

assim em resumo:

Time complexity: $O(n)$
Space complexity: $O(1)$

Bem, tudo que é bom, pode melhorar e por mais que um algoritmo $O(n)$ não seja péssimo, existe algumas soluções mais "velozes" em perpectiva de complexidade assintótica. No proximo algorítmo veremos como usar uma propriedade da algebra para resolver o problema de fibonacci, desta vez usaremos matrizes!

Solução com exponenciação de matrizes

Exemplificando SOLID com Jetpack Compose - parte S

Filipe Câncio — Thu, 10 Oct 2024 22:16:27 +0000

Esta é uma nova série de artigos composta em cinco partes, uma para cada princípio do SOLID. Vou deixar o link para uma versão em inglês aqui, quando tiver uma, e vou deixar os artigos seguintes no final deste artigo quando forem feitos também.

Existem tópicos na área de desenvolvimento que são muito importantes de se aprender, e o SOLID é um deles. Às vezes encontramos situações em que não percebemos, à primeira vista, que podemos implementar esses princípios e que poderiam ser um ótimo exemplo de implementação no trabalho ou em uma entrevista de emprego.

Nesta série de artigos, vamos usar os conceitos de SOLID com Jetpack Compose e ver casos onde essa tecnologia performa muito bem com os conceitos apresentados.

O princípio que iremos focar aqui é o S - Single-responsibility principle (SRP) ou Princípio da Responsabilidade Única, que dita que uma classe (no nosso caso, um composable) deve ter apenas uma única responsabilidade, ou seja, deve fazer uma única ação ou mudança.

Em nosso exemplo, vamos analisar o caso de uma HomeScreen:

Em nossa HomeScreen, o designer desenvolveu alguns fluxos na tela para dar comportamentos quando interagida com o usuário. A primeira coisa que acontece é o carregamento dos conteúdos; em seguida, caso o carregamento ocorra bem, é exibida uma lista de conteúdos. O designer acrescentou também alguns elementos na tela caso o carregamento não ocorra bem ou não tenha nenhum conteúdo.

Em um desenvolvimento comum com XML, é esperado que alguns elementos sejam criados em tela e ocultados. Durante a execução das activities, decidimos quando eles devem aparecer. Por exemplo, se a tela tiver uma lista de conteúdos, o botão "new" deve ser pequeno e em formato de losango; quando não houver nenhum conteúdo, ele deve ser um retângulo comum e largo; caso o conteúdo esteja carregando, ele não deve aparecer.

Para esse caso, pode ser uma implementação simples, mas sabemos que em uma tela com diversos comportamentos e casos de exceção isso pode se tornar um pesadelo de condicionais e, devido à complexidade, a cada mudança no código, um novo comportamento inesperado pode ocorrer.

Implementando o Single-responsibility principle(SRP)

No nosso exemplo, iremos dividir cada comportamento de tela em componentes, uma série de funções que definirão o fluxo exibido na tela. Se você já conhece o básico de Jetpack Compose, sabe que podemos criar uma view com uma simples função e a anotação @Composable, então não vamos abordar isso aqui.

Vamos definir cada responsabilidade por:

Loading: carregando conteúdo
Content: foi carregado uma lista de conteúdos
Empty: foi carregado uma lista vazia
Error: houve um erro no carregamento

A solução seria simplesmente criarmos os componentes abaixo:

@Composable
fun HomeLoadingScreen(){...} 

@Composable
fun HomeContentScreen(
   contentList: List<String>
   onNewClick: ()-> Unit
){...}

@Composable
fun HomeEmptyScreen(
   onNewClick: ()-> Unit
){...}

@Composable
fun HomeErrorScreen(
   onOkClick: ()-> Unit
){...}

FIM Brincadeira pessoal, apesar do uso do SRP já estar exposto, vamos dar um sentido para essa separação de responsabilidade, afinal, ainda não sabemos como pode ser útil. Primeiro precisamos entender que existe uma função HomeScreen e que essas funções de comportamento serão renderizadas nela. E isso vai depender de uma mudança de estado. Além da HomeScreen, temos a HomeViewModel que vai criar nossa variável MutableLiveData que vai ficar mutando durante o uso do app.

O tipo do nosso MutableLiveData será uma classe selada HomeUIState que terá classes e objetos filhos representando cada comportamento (ou responsabilidade).

@Composable
fun HomeScreen(viewModel: HomeViewModel){
   val state = viewModel.uiState.colectAsState()
}

class HomeViewModel(): ViewModel() {
   var uiState: MutableLiveData<HomeUIState>()

...


   sealed class HomeUIState() {
      object Loading: HomeUIState()
      data class Content (val contentList: List<String>): HomeUIState()
      object Empty: HomeUIState()
      object Error: HomeUIState()
   }
}

Agora, vamos criar algumas funções que atualizem nosso estado uiState (o MutableLiveData). Funções que representam momentos como o carregamento de uma API, ou uma coleta no sharedPreferences.

class HomeViewModel(): ViewModel() {
   private fun onInit() {
      uiState.postValue(Loading)
   }

   private fun onGetListSuccess(list: List<String>) {
      //verify if is empty
      if(list.isEmpty()){
         uiState.postValue(Empty)
      } else {
         uiState.postValue(Content(list))
      }
   }

   private fun onGetListFailure() {
      uiState.postValue(Error)
   }
}

Por fim, as telas em HomeScreen são renderizadas através de um When:

@Composable
fun HomeScreen(viewModel: HomeViewModel){
   val state = viewModel.uiState.colectAsState()

   when(state) {
      is Loading -> HomeLoadingScreen()
      is Content -> HomeContentScreen(it.contentList){ viewModel.createNewContent()}
      is Empty -> HomeEmptyScreen{ viewModel.createNewContent()}
      is Error -> HomeErrorStreen{ viewModel.loadContents() }
   }
}

Em resumo, definimos uma única responsabilidade para:

HomeLoadingScreen: exibir os componentes correspondentes quando a tela estiver carregando os conteúdos.
HomeContentScreen: exibir os componentes correspondentes quando a tela estiver com a lista de conteúdos.
HomeEmptyScreen: exibir os componentes correspondentes quando a tela estiver com a lista vazia.
HomeErrorScreen: exibir os componentes correspondentes quando tiver algum erro.
HomeScreen: gerenciar os estados recebidos e escolher o que exibir.

No próximo artigo, iremos observar os outros princípios do SOLID usando Jetpack Compose. Vou deixar a listinha aqui abaixo, na medida que os artigos forem criados:

Exemplificando SOLID com Jetpack Compose - parte S
Exemplificando SOLID com Jetpack Compose - parte O
Exemplificando SOLID com Jetpack Compose - parte L
Exemplificando SOLID com Jetpack Compose - parte I
Exemplificando SOLID com Jetpack Compose - parte D

Configurando firewall com Docker

Filipe Câncio — Tue, 05 Dec 2023 16:04:16 +0000

Neste post usaremos o iptables para configurar firewalls usando containers dockers.
O iptables é uma ferramenta para configurar firewalls e Nat disponível para dispositivos linux. Dentre as variadas funcionalidades, iremos configurar aqui no projeto o acesso de um container docker com outro. Para isso, precisaremos duas imagens docker: a filipecancio/kali-iptables e a filipecancio/server-iptables. Vamos fazer o pull das duas.

docker pull filipecancio/kali-iptables
docker pull filipecancio/server-iptables

Criaremos então um máquina com o nome server com o server-iptables e outra client com o kali linux:

# Criando a maquina server
docker run -it --rm --cap-add=NET_ADMIN --cap-add=NET_RAW -d -p 8080:8080 --name server filipecancio/server-iptables

# Criando a maquina client
docker run --name client --cap-add=NET_ADMIN --cap-add=NET_RAW -i -t filipecancio/kali-iptables bash

A máquina server não foi executada automaticamente pelo bash pois ela é uma aplicação nodeJS rodando em uma máquina alpine, então usaremos o comando abaixo para acessá-lo (o mesmo comando pode ser usado para acessar o client posteriormente.

docker exec -it --user root server sh

# caso queira acessar novamente o client via bash
docker exec -it client /bin/bash

Note que usaremos a flag --user root para poder fazer as alterações de root na maquina

Se você usar o navegador com endereço localhost:8080 poderá ver a página inicial da aplicação com informações em JSON, se você acessar a localhost:8080/pikachu verá informações do pokemon pikachu vindas de https://pokeapi.co/. Mas não faremos interações com a máquina física nesse post. Por padrão o docker possui configurações de iptables que permitem criações de containers seguros. os comandos acima possuem algumas flags que modificam algumas regras internas do docker:

-p 8080:80 libera a porta 80 na porta 8080 da maquina física
--cap-add=NET_ADMIN --cap-add=NET_RAW permite que usemos o container como um servidor e configuremos suas próprias regras de firewall. Para simplificar o estudo do iptables nesse post, não iremos fazer configurações avançadas com o docker, apenas as interações simples da máquina client com a server.

Bloqueio de ping

Vamos identificar os ips das máquinas, para isso, com o bash das duas máquinas ligadas vamos digitar o comando ifconfig e pegar os ips no trecho inet. De modo respectivo vamo supor que temos os seguintes ips:

client: 172.17.0.3
server: 172.17.0.2

Vamos testar o ping do client para o servidor:

ping 172.17.0.2

Ele irá normalmente pegar o ping de server.

Com isso vamos adicionar nossa primeira regra em server:

iptables -I INPUT -p ICMP -j DROP

Instantaneamente o ping para. Se excluimos a mesma regra com o comando abaixo, automaticamente o ping volta.

iptables -D INPUT -p ICMP -j DROP

Se usamos a flag REJECT ao inves de DROP o ping sera recusado.

iptables -I INPUT -p ICMP -j REJECT

Bloqueio de TCP

Usando a ferramenta curl podemos acessar a máquina server via http com o comando GET:

curl -X GET "172.17.0.2:8080"

Ele irá apresentar um html semelhante ao visto no localhost:8080. Para bloquear o acesso para client, usaremos seguinte comando em server:

iptables -I INPUT -p TCP -s 172.17.0.3 -j DROP

Ao tentarmos novamente acessar o endereço 172.17.0.2:80 em client, não temos acesso. Para remover a regra basta executar o comando abaixo:

iptables -D INPUT -p TCP -s 172.17.0.3 -j DROP

Bloqueando o ip do site

Lembra que o endereço localhost:8080/pikachu levava à um json com informações detalhadas do pikachu via PokeApi? vamos bloquear o acesso ao ip da PokeApi agora. Digite comando abaixo:

curl -X GET "172.17.0.2:8080/pikachu"

Você verá todas as informações em json do pikachu. Considerando o ip 172.64.201.27 e 172.64.200.27 para o site https://pokeapi.co/. Agora ao tentar novamente, ele irá rejeitar a conexão, mas o 172.17.0.2:8080 funcionará normalmente.

iptables -I INPUT -p TCP -s 172.64.201.27 -j REJECT
iptables -I INPUT -p TCP -s 172.64.200.27 -j REJECT

para desfazer as regras basta digitar os seguintes comandos:

iptables -D INPUT -p TCP -s 172.64.201.27 -j REJECT
iptables -D INPUT -p TCP -s 172.64.200.27 -j REJECT

Realizando ataques de força bruta em containers docker usando hydra

Filipe Câncio — Mon, 20 Nov 2023 22:40:13 +0000

Neste post iremos entender como usar a ferramenta hydra para ataques de força bruta e de dicionário através de um site ou de um computador para outro. Podemos entender por definição:

Um ataque de dicionário é um ataque às senhas que usa palavras ou frases comuns encontradas em dicionários para comprometer credenciais de usuários. Caso seja uma pessoa que usa palavras do dicionário ou frases comuns como senha, você corre o risco de ser vítima de um ataque de dicionário. Fonte: Keeper Security

Brute Force é um ataque “Hacker” usado para tentar descobrir a combinação certa de uma senha, tentando várias combinações diferentes. O ataque pode ser feito de forma manual, colocando as senhas uma por vez até que a verdadeira seja encontrada. Fonte: Brasil Cloud

Para realizar os ataques utilizaremos um ambiente controlado usando containers docker. Para você que é leigo com docker digamos que os dockers podem ser usados como máquinas virtuais mas de uma forma mais simples e leve, como se criar uma máquina vitual fosse como preparar uma lasanha do zero e o docker fosse uma lasanha pronta para esquentar no microondas. Ao invés de gastarmos tempo preparando os ingredientes basta pegar uma imagem pronta (seu sabor de lasanha favorito) e a partir dela preparar o seu almoço (container docker).
A imagem que vamos usar é a cancitoo/kali-linux-ssh-hydra basta ir na sua maquina e digitar o comando abaixo (é preciso ter o docker instalado na sua máquina):

docker pull cancitoo/kali-linux-ssh-hydra

A aqui já temos o necessário para relizar nosso laboratório.

Usando ataque de dicionário em um site

Para esse ataque iremos criar a nossa primeira máquina, aqui no exemplo usaremos o seguinte comando:

docker run --name pc01 -p 6050:22 -i -t cancitoo/kali-linux-ssh-hydra bash

Nesse comando criamos um container chamdo pc01 e sua porta 22 será a 6050 da máquina real, ele também já abre nossa máquina no terminal como um bash. A partir daqui já usando no terminal a nossa máquina pc01. Caso no futuro você queira acessa novamente a pc01 basta digitar o comando abaixo:

#para executar um container ja aberto
docker exec -it pc01 /bin/bash

Pronto! Nossa máquina já está pronta para fazer o ataque! Nesse caso, vamos usar atacar o site http://testphp.vulnweb.com/login.php com o comando abaixo:

hydra testphp.vulnweb.com http-form-post "/userinfo.php:uname=^USER^&pass=^PASS^:login page" -l test -p 0000 -t 10

Aqui podemos observar que o hydra faz o ataque via uma requisição http inserindo os valores de user com a flag -l e senha -P de forma respectiva nos parametros USER e PASS dentro endereço usado. O ataque deu errado pois a senha do comando acima 0000 não é a correta. Agora vamos montar em pc01 nosso próprio dicionário. Digite o comando abaixo:

nano /tmp/pass.txt

vai aparece o editor nano, coloque nele uma lista de possíveis senhas:

0000
1234
4321
3434
4545
teste
nome
nada

Agora vamos rodar novamente o comando mas desta vez com a flag de password em maiusculo usando nosso novo arquivo /tmp/pass.txt:

hydra testphp.vulnweb.com http-form-post "/userinfo.php:uname=^USER^&pass=^PASS^:login page" -l test -P /tmp/pass.txt -t 10

Desta vez o docker irá rodar todo o arquivo /tmp/pass.txt procurando a senha correta. Assim ocorre o ataque de força brutaa. Dest vez vai dar certo o ataque pois a senha correta teste consta no nosso dicionário.

atacando uma maquina para a outra via ssh

Agora vamos criar uma nova máquina pc02 semelhante ao que fizemos com p01:

docker run --name pc02 -p 6051:22 -i -t cancitoo/kali-linux-ssh-hydra bash

#para executar um container ja aberto
docker exec -it pc02 /bin/bash

Repare que dessa vez a porta 22 é a 6051 da maquina real. Vamos adicionar uma camada de segurança em pc02. Por padrão o container não vem com senha, para configurar a senha de pc02 basta digitar o comando abaixo e seguir as instruções:

#para gerar uma senha pro root
passwd

Agora vamos configurar o ssh na máquina pc02. Isso vai permitir conexão ssh de pc01 para pc02:

#definir da chave de acesso remota
ssh-keygen -A

#iniciar o serviço SSH
service ssh start

Voltando para pc01 vamos adicionar senha criada em pc02 no nosso dicionário e criar um novo dicionário com logins:

# Atualizar dicionario com senha
nano /tmp/pass.txt
# criar lista de possíveis usuários
nano /tmp/users.txt

Aqui vai um exemplo para /tmp/users.txt

pedro
carlo
root
admin

Mas ainda falta saber qual o ip de pc02, para isso vamos rodar esse comando em um terminal à parte:
abaixo:

docker inspect -f "{{ .NetworkSettings.IPAddress }}" pc02

Vamos fazer de conta que a respota veio 172.17.0.2. Agora basta executar hydra na porta de ataque

 hydra -L /tmp/users.txt -P /tmp/pass.txt 172.17.0.2 ssh

Renovação de Matrícula 2022.2

Filipe Câncio — Thu, 04 Aug 2022 03:23:28 +0000

Já está disponível a renovação de matrícula para o semestre de 2022.2 para os cursos subsequentes e superiores do IFBA de Vitória da Conquista-BA. Ela estará diponível entre os dias 04 e 07 de agosto de 2022 e para realização basta acessar a plataforma do SUAP clicar em "faça sua matrícula online". O sistema solicitará uma atualização dos dados cadastrais antes da matrícula.
Caso queira consultar a lista de matérias disponíveis para este semestre, basta a acessar a Lista de Horários 2022.2.

O Guia do Estudante do IFBA

Filipe Câncio — Thu, 04 Aug 2022 03:09:19 +0000

Este post é um teste