<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>luidiblu</title><description>Artigos técnicos de luidiblu sobre software, segurança, sistemas e redes.</description><link>https://luidiblu.com/</link><language>pt-BR</language><item><title>Entendendo as Tecnologias de Autenticação e Autorização Federada (SAML, SCIM, OIDC)</title><link>https://luidiblu.com/posts/autenticacao-federada/</link><guid isPermaLink="true">https://luidiblu.com/posts/autenticacao-federada/</guid><description>Entendendo as tecnologias de autenticação e autorização federada: SAML, SCIM e OpenID Connect.</description><pubDate>Sun, 01 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;h2&gt;O que é Autenticação Federada?&lt;/h2&gt;
&lt;p&gt;A Autenticação Federada é um modelo de gestão de identidades que permite que entidades independentes compartilhem credenciais e informações de autenticação de forma segura.&lt;/p&gt;
&lt;p&gt;Neste modelo, usuários de um domínio podem acessar recursos e serviços em outro domínio sem a necessidade de criar novas contas ou credenciais.&lt;/p&gt;
&lt;p&gt;Isso é possível através do estabelecimento de uma relação de confiança mútua entre provedores de identidade e provedores de serviços, e é fundamentado em padrões e protocolos estabelecidos como SAML, OAuth e OpenID Connect.&lt;/p&gt;
&lt;h2&gt;Autenticação Federada é a mesma coisa que SSO?&lt;/h2&gt;
&lt;p&gt;Não! Embora frequentemente confundidos ou usados de maneira intercambiável, a autenticação federada e o Single Sign-On (SSO) não são o mesmo conceito.&lt;/p&gt;
&lt;p&gt;O SSO é um processo pelo qual um usuário pode utilizar um conjunto de credenciais para acessar múltiplas aplicações ou sistemas, reduzindo a necessidade de autenticações múltiplas.&lt;/p&gt;
&lt;p&gt;Por outro lado, autenticação federada é um modelo mais abrangente de gestão de identidade que pode incluir SSO como um dos seus componentes, especialmente em cenários onde a autenticação precisa ser compartilhada entre sistemas separados e possivelmente operados por diferentes entidades organizacionais.&lt;/p&gt;
&lt;h2&gt;Qual a diferença entre Autenticação Federada e Autenticação Delegada?&lt;/h2&gt;
&lt;p&gt;A principal diferença entre autenticação federada e autenticação delegada reside na propriedade e na gestão das credenciais.&lt;/p&gt;
&lt;p&gt;Na autenticação federada, não há transferência ou exposição das credenciais do usuário para os provedores de serviço. Em contraste, na autenticação delegada, uma terceira parte confiável (como Google ou Facebook) é responsável por autenticar o usuário e então comunicar essa autenticação ao provedor de serviço solicitante.&lt;/p&gt;
&lt;p&gt;Assim, a autenticação delegada pode ser considerada um subconjunto da autenticação federada, onde um sistema confia na autenticação realizada por outro sistema.&lt;/p&gt;
&lt;h2&gt;SAML (Security Assertion Markup Language)&lt;/h2&gt;
&lt;p&gt;O SAML é uma estrutura XML utilizada para intercâmbio de dados de autenticação e autorização entre partes confiáveis, frequentemente utilizada para a implementação de Single Sign-On (SSO) em sistemas corporativos.&lt;/p&gt;
&lt;p&gt;Ele permite que os usuários acessem múltiplos serviços online com uma única sessão de autenticação, aprimorando a experiência do usuário e incrementando a segurança.&lt;/p&gt;
&lt;figure&gt;&lt;img src=&quot;/images/saml.png&quot; alt=&quot;Representação gráfica do SAML&quot; width=&quot;800&quot; height=&quot;480&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;h2&gt;SCIM (System for Cross-domain Identity Management)&lt;/h2&gt;
&lt;p&gt;O SCIM é um padrão aberto que facilita a gestão automática de identidades de usuários em aplicações e serviços baseados em nuvem.&lt;/p&gt;
&lt;p&gt;Ele foi projetado para promover a integração e interoperabilidade entre diferentes sistemas de gerenciamento de identidade (IDM) e aplicações SaaS, permitindo que mudanças, como criação ou deleção de usuários, sejam sincronizadas automaticamente por meio da nuvem.&lt;/p&gt;
&lt;figure&gt;&lt;img src=&quot;/images/scim.png&quot; alt=&quot;Representação gráfica do SCIM&quot; width=&quot;985&quot; height=&quot;397&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;h2&gt;OIDC (OpenID Connect)&lt;/h2&gt;
&lt;p&gt;OpenID Connect é um protocolo de identidade em camada baseado no OAuth 2.0.&lt;/p&gt;
&lt;p&gt;Ele permite que clientes verifiquem a identidade do usuário final com base na autenticação realizada por um provedor de identidades autorizado, assim como para obter informações básicas de perfil sobre o usuário final.&lt;/p&gt;
&lt;p&gt;Estende o OAuth 2.0 para permitir a autenticação de usuários, fornecendo um mecanismo que permite que as aplicações confiem nas assertivas de identidades fornecidas.&lt;/p&gt;
&lt;figure&gt;&lt;img src=&quot;/images/oidc.png&quot; alt=&quot;Representação gráfica do OIDC&quot; width=&quot;800&quot; height=&quot;422&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;h2&gt;Como Implementar Essas Tecnologias?&lt;/h2&gt;
&lt;p&gt;A implementação da autenticação federada e do OAuth em aplicativos e serviços requer um planejamento e compreensão cuidadosos dos princípios subjacentes. Organizações precisam escolher os protocolos certos para suas necessidades, configurar infraestruturas de forma segura e trabalhar para garantir a melhor experiência possível do usuário.&lt;/p&gt;
&lt;p&gt;Este processo começa com a definição dos requisitos de negócios e de segurança e segue com a integração das tecnologias de autenticação corretas. Uma implementação bem-sucedida também deve considerar a conformidade com regulamentos de privacidade e proteção de dados, garantindo que as práticas de autenticação estejam em linha com as expectativas e requerimentos legais.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Definição clara dos requisitos e escopo do sistema.&lt;/li&gt;
&lt;li&gt;Escolha do protocolo adequado (SAML, OAuth, OpenID Connect, etc.)&lt;/li&gt;
&lt;li&gt;Configuração de uma infraestrutura segura, incluindo servidores, chaves e certificados.&lt;/li&gt;
&lt;li&gt;Desenvolvimento ou adaptação de aplicativos e interfaces de usuário para uma autenticação sem falhas.&lt;/li&gt;
&lt;li&gt;Testes rigorosos e repetitivos para garantir a segurança e a eficácia.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;Combinando Forças para uma Segurança Robusta&lt;/h2&gt;
&lt;p&gt;A adoção dessas tecnologias de forma combinada permite que as organizações estabeleçam um sistema de segurança digital mais robusto. A capacidade de gerir identidades de forma consistente e segura, além de fornecer acesso simplificado a diversas aplicações, é a base para um ambiente digital moderno e eficiente.&lt;/p&gt;
&lt;p&gt;A implementação bem-sucedida de SAML, SCIM e OIDC depende do entendimento das particularidades de cada padrão e da composição de uma arquitetura que os utilize em harmonia para maximizar os benefícios e a segurança para a organização e seus usuários.&lt;/p&gt;
</content:encoded><category>identidade</category><category>saml</category><category>scim</category><category>oidc</category></item><item><title>Fundamentos da programação</title><link>https://luidiblu.com/posts/fundamentos-da-programacao/</link><guid isPermaLink="true">https://luidiblu.com/posts/fundamentos-da-programacao/</guid><description>Uma introdução a instruções, intenção e automatização.</description><pubDate>Sun, 01 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Primeiramente, quando falamos sobre programação, precisamos entender o que
programação significa.&lt;/p&gt;
&lt;p&gt;No final das contas, programação é uma série de instruções. Você escreve
essa série de intruções e passa para o computador executar essas instruções.&lt;/p&gt;
&lt;p&gt;E quando o computador executar, dependendo do seu código, o computador te retornará
um output ou só continuará trabalhando.&lt;/p&gt;
&lt;p&gt;O ato de escrever essa série de instruções chama-se &quot;codificar&quot; ou &quot;codar&quot;
&quot;programar&quot; é uma forma abstrata de dizer que você está falando ao computador
o que deve ser feito. Se você escrever uma receita, você está programando
outra pessoa à fazer essa receita. O que é totalmente diferente de codificar algo.&lt;/p&gt;
&lt;p&gt;Tá, mas Diego, por que queremos que os computadores façam coisas para nós?
Bom... Humanos e computadores são bem diferentes, se você pedir para um computador
fazer mil tarefas, ele irá fazer exatamente a mesma coisa mil vezes.
Comparado à um humano, por exemplo, se você pedir para esse humano fazer 20 hamburgueres
os 20 hamburgueres não sairão iguais.&lt;/p&gt;
&lt;p&gt;Qual o motivo disso? Humanos são inconsistentes, ficam entediados repetindo a mesma coisa
é humanamente impossível sempre ser consistente, sempre terá uma falha, algum erro.
Inversamente, os computadores não ficam entediados, então se você pedir para um computador
fazer hamburgueres, por exemplo, esses hamburgueres ficarão iguais.&lt;/p&gt;
&lt;p&gt;Do começo ao fim, isso que escrevi até então é o princípio da automatização
nós delegamos chatas e repetitivas para o computador, para que ele continue fazendo
os hamburgueres.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Então, temos um ponto que humanos - ficam com tédio e computadores - não ficam com tédio.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Mas os humanos, são criativos, como humano, se você me perguntar &quot;pegue um presente p/ sua mãe&quot;
nós podemos pegar várias coisas, pois temos um contexto, sentimentos e experiência.
Se você pedir para um computador, ele provavelmente não saberá como responder isso.&lt;/p&gt;
&lt;p&gt;Computadores não tem criatividade. Uma calculadora não pode criar uma nova receita culinária
mas ela pode multiplicar 2 números mais rápido que qualquer humano existente.
Isso significa que os computadores são ótimos em - Computação, e nós somos bons em - Detectar Padrões.&lt;/p&gt;
&lt;p&gt;Olhar para uma pessoa e entender quais emoções ela está sentindo, isso é um padrão.
(Não vou entrar em Inteligência Artificial agora, mas Inteligência Artificial detecta padrões MUITO bem)&lt;/p&gt;
&lt;p&gt;Então temos humanos, com várias coisas criativas, mas eles não são bons em repetir tarefas,
o que podemos fazer, é dar ao computador essas tarefas. Já que eles fazem perfeitamente e super rápido.&lt;/p&gt;
&lt;p&gt;Outra coisa interessante dos computadores, é que eles seguem exatamente o que você ordenou
e humanos podem inferir coisas.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Uma piada que você já pode entender sobre inferir coisas, é a seguinte:&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&quot;Uma mulher manda seu marido programador para o Mercado&quot;&lt;/p&gt;
&lt;p&gt;Ela fala pra ele:&lt;/p&gt;
&lt;p&gt;&quot;Eu preciso de manteiga, açucar e olho de cozinha.&quot;&lt;/p&gt;
&lt;p&gt;&quot;Também, pegue pão, &lt;em&gt;se eles tiverem ovos, pegue 6&lt;/em&gt;&quot;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;O marido chega em cara com: manteiga, açucar, olho de cozinha e 6 pães franceses&lt;/li&gt;
&lt;li&gt;A mulher pergunta: Pq caralhos tu trouxe 6 pães franceses?&lt;/li&gt;
&lt;li&gt;Ele responde: Eles tinham ovos.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Obviamente, na frase &lt;em&gt;&quot;Também pegue pão, se eles tiverem ovos, pegue 6&quot;&lt;/em&gt;, ela queria 6 ovos.
Mas esse marido programador estáva pegando a sentença literal da coisa, então significa
que quando chega na parte do 6, ele pergunta &quot;6 o que?&quot; &quot;6 pães franceses,
é o que eles tavam falando&quot;.&lt;/p&gt;
&lt;p&gt;Computadores não cometem esses erros, não porque são computadores, mas pela forma
que nós nos comunicamos com eles.&lt;/p&gt;
&lt;p&gt;Já que precisamos ser precisamente precisos com os computadores, para não cometermos erros.&lt;/p&gt;
</content:encoded><category>fundamentos</category><category>programacao</category></item><item><title>A Arte da Guerra em Aplicações: Estratégias de Sun Tzu aplicadas em AppSec</title><link>https://luidiblu.com/posts/a-arte-da-guerra-em-aplicacoes/</link><guid isPermaLink="true">https://luidiblu.com/posts/a-arte-da-guerra-em-aplicacoes/</guid><description>Estratégias de Sun Tzu aplicadas à segurança de aplicações, do planejamento à defesa em profundidade.</description><pubDate>Fri, 24 Nov 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Em uma era em que as batalhas são travadas não com espadas, mas com códigos, invocamos a sabedoria do antigo general Sun Tzu para guiar o cenário moderno das batalhas de aplicativos. Suas máximas, testadas pelo tempo, ressoam com clareza surpreendente em um contexto de AppSec onde cada linha de código pode ser um campo de batalha potencial.&lt;/p&gt;
&lt;h2&gt;“Conhece-te a ti mesmo e ao teu inimigo”: Avaliação e Consciência Contínua&lt;/h2&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/a4e2a0fc0af910334424.webp&quot; alt=&quot;&quot; width=&quot;1024&quot; height=&quot;585&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;A análise estática de código (&lt;strong&gt;SAST&lt;/strong&gt;), um pouco como revisar uma planta de construção antes de construir uma casa, busca por problemas no seu código-fonte antes que o software seja lançado ou mesmo executado. É como fazer um check-up completo para se certificar de que tudo está em ordem. Esse processo ajuda a pegar erros cedo, para que eles possam ser corrigidos sem grandes dores de cabeça.&lt;/p&gt;
&lt;p&gt;Em contraste, a análise dinâmica de aplicações (&lt;strong&gt;DAST&lt;/strong&gt;) é como testar o alarme de incêndio apertando o botão de teste para garantir que ele realmente funciona quando necessário. Ela testa o software enquanto ele está rodando para encontrar falhas que só aparecem quando o sistema está ativo — como um alarme que só dispara quando já existe um incêndio real.&lt;/p&gt;
&lt;p&gt;Juntando as duas, temos a Análise Interativa (&lt;strong&gt;IAST&lt;/strong&gt;), que é como ter um inspetor que verifica a construção enquanto ela está sendo erguida, garantindo que tudo está seguro e funcionando como deveria ao longo do processo. Isso oferece uma visão mais completa, porque você está verificando a integridade do produto tanto por dentro quanto por fora e em diferentes estágios.&lt;/p&gt;
&lt;p&gt;Além dessas análises, saber o que os hackers estão fazendo por aí ajuda muito. Isso é chamado de inteligência sobre ameaças (&lt;strong&gt;Threat Intelligence&lt;/strong&gt;) e envolve coletar informações sobre as últimas técnicas que os invasores podem usar para atacar. Manter-se informado sobre esses métodos ajuda a equipe de segurança de aplicações a se preparar para enfrentar ameaças novas e inesperadas.&lt;/p&gt;
&lt;p&gt;No fim das contas, a ideia é ter um entendimento claro sobre a segurança da sua aplicação e o que está acontecendo no mundo dos ataques cibernéticos. Dessa maneira, você pode ajustar suas defesas para estar sempre um passo à frente dos invasores.&lt;/p&gt;
&lt;h2&gt;“Toda batalha é ganha antes de ser travada”: A Arte da Preparação&lt;/h2&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/efbca25bf6befeb4f543.jpg&quot; alt=&quot;&quot; width=&quot;1024&quot; height=&quot;585&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;Sun Tzu ensina que a vitória é alcançada através de meticuloso planejamento e preparação. Na segurança de aplicações, a preparação previne contra ameaças futuras, estabelecendo um fundamento sólido de segurança no início do ciclo de desenvolvimento do software.&lt;/p&gt;
&lt;p&gt;Adotar a abordagem &lt;strong&gt;Secure by Design&lt;/strong&gt; significa incorporar princípios de segurança desde a fase de concepção do aplicativo. Cada característica, função e linha de código é criada com a segurança como uma consideração intrínseca, seguindo padrões e melhores práticas que minimizam a probabilidade de vulnerabilidades.&lt;/p&gt;
&lt;p&gt;A Modelagem de Ameaças (&lt;strong&gt;Threat Modeling&lt;/strong&gt;) é uma atividade proativa que antecipa possíveis vetores de ataque. Desenvolvedores e analistas de segurança trabalham em conjunto para identificar e avaliar riscos potenciais e estruturar medidas de defesa apropriadas. Como um role-play estratégico, isso permite uma simulação de cenários de ataque e a criação de contramedidas eficazes.&lt;/p&gt;
&lt;p&gt;Realizar a Revisão Segura de Código (&lt;strong&gt;Secure Code Review&lt;/strong&gt;) é semelhante a uma inspeção detalhada de uma fortificação para identificar pontos fracos. Por meio da análise sistemática do código-fonte, é possível identificar e corrigir vulnerabilidades antes que se tornem uma ameaça real para a segurança operacional do software.&lt;/p&gt;
&lt;p&gt;Ao fundamentar o desenvolvimento de software nestas práticas rigorosas, as probabilidades de sucesso no campo de batalha da segurança cibernética são consideravelmente melhoradas. Isto alinha as equipes de segurança e desenvolvimento em um objetivo comum: lançar aplicações robustas que já são seguras por natureza e que podem resistir a ataques antes mesmo que eles se materializem.&lt;/p&gt;
&lt;h2&gt;“A suprema arte da guerra é subjugar o inimigo sem lutar”: A Defesa Invisível&lt;/h2&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/882607b38e576c25e2b0.webp&quot; alt=&quot;&quot; width=&quot;1024&quot; height=&quot;585&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;Esta frase resume a ideia de vencer sem que seja necessário um confronto direto. No mundo de AppSec, isso se significa criar várias camadas de segurança que trabalham juntas para proteger o sistema sem que um invasor sequer perceba sua presença.&lt;/p&gt;
&lt;p&gt;Imagine a Defense in Depth como um castelo com várias muralhas. Mesmo se um inimigo conseguir passar pela primeira, ainda há muitas outras proteções que ele não espera e que vão pará-lo. É como ter múltiplos sistemas de segurança, uns visíveis e outros invisíveis, que juntos criam um escudo robusto em volta das suas aplicações.&lt;/p&gt;
&lt;p&gt;Quando falamos sobre proteções que agem sem que o invasor saiba, podemos mencionar a proteção de aplicações em tempo de execução, conhecida como &lt;strong&gt;RASP&lt;/strong&gt; (Runtime Application Self-Protection). Ela é como um guarda-costas discreto que está sempre pronto para agir se algo der errado, bloqueando ataques enquanto a aplicação está rodando.&lt;/p&gt;
&lt;p&gt;E, por fim, os **WAFs (**Web Application Firewalls) funcionam como sentinelas que detectam e impedem tentativas de invasão, cuidando do seu software contra ataques conhecidos e os não tão conhecidos também. Eles são uma linha de frente na defesa do seu aplicativo na web, filtrando o tráfego suspeito antes mesmo de chegar perto do seu castelo.&lt;/p&gt;
&lt;p&gt;O ponto central aqui é que, ao estabelecer essas múltiplas camadas de defesa, você pode efetivamente neutralizar muitas ameaças antes delas se tornarem um problema sério, mantendo as aplicações seguras e operando suavemente. E o melhor de tudo é que isso pode ser feito de maneira tão sutil que os invasores nem saberão por que seus ataques não estão funcionando.&lt;/p&gt;
&lt;h2&gt;“Seja extremamente sutil, ao ponto de não ter forma”: A Enganação Como Tática&lt;/h2&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/da48f4136ba743c65302.webp&quot; alt=&quot;&quot; width=&quot;1024&quot; height=&quot;585&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;Nas estratégias de segurança de aplicações, a discrição e a indetectabilidade são elementos fundamentais. Tecnicamente, isso se manifesta no uso da ofuscação de código, um processo que embaralha o código-fonte, mantendo sua funcionalidade, mas dificultando a compreensão por parte de atacantes. É uma maneira de esconder as instruções verdadeiras do seu software em plena vista.&lt;/p&gt;
&lt;p&gt;A técnica de minificação complementa a ofuscação, reduzindo o código-fonte ao essencial, removendo espaços em branco, comentários e outros elementos que não são necessários para sua execução. Isso não apenas torna o código mais difícil de ler para quem tem intenções maliciosas, mas também pode melhorar o desempenho ao reduzir o tamanho dos arquivos.&lt;/p&gt;
&lt;p&gt;Além desses métodos, a adoção de uma arquitetura baseada em microsserviços e APIs internas que não são expostas externamente protege o sistema como um todo. Ao segmentar a funcionalidade em partes menores, cada uma operando isoladamente, a arquitetura geral do aplicativo torna-se um enigma para os atacantes. Sem uma visão clara de todos os componentes e como eles interagem, fica muito mais difícil para eles encontrarem um ponto fraco para explorar.&lt;/p&gt;
&lt;p&gt;Empregando essas táticas, as aplicações assumem uma postura de segurança fluida e camuflada, que confunde ativamente os adversários e protege contra interceptações indesejadas. Ao ser “sutil ao ponto de não ter forma”, você cria um ambiente onde os invasores têm dificuldade em identificar alvos claros, o que ajuda a afastar ameaças e manter a integridade do sistema.&lt;/p&gt;
&lt;h2&gt;“Deixe seu caminho ser imprevisível”: A Dinâmica das Defesas&lt;/h2&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/8b4c2fb6921b50666cf3.webp&quot; alt=&quot;&quot; width=&quot;1024&quot; height=&quot;585&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;Criar defesas que são difíceis de prever e reagir pode ser um grande trunfo na proteção de aplicações. Uma das maneiras de fazer isso é utilizando &lt;a href=&quot;https://en.wikipedia.org/wiki/Honeypot_(computing)&quot;&gt;honeypots&lt;/a&gt;, que são sistemas ou partes de uma rede desenhados para parecerem atraentes para invasores, mas na verdade são uma armadilha. Como uma isca, eles desviam a atenção e os esforços dos atacantes para um local onde não podem causar dano real, e ao mesmo tempo, permitem que os especialistas em segurança observem os invasores em ação e aprendam com suas abordagens.&lt;/p&gt;
&lt;p&gt;Além do mais, a automação na aplicação de correções de segurança, conhecidas como patches, ajuda a manter o software atualizado e menos vulnerável a ataques conhecidos. Mas não se trata apenas de automatizar correções simples; mudanças estratégicas e frequentes na infraestrutura, como alternar os endereços de IP e as portas dos servidores, confundem os invasores e atrapalham os padrões de ataque que eles poderiam estar tentando usar.&lt;/p&gt;
&lt;p&gt;Esses movimentos imprevisíveis tornam o trabalho dos atacantes mais complexo e incerto. Em vez de um alvo estático e previsível, sua infraestrutura se assemelha a um alvo em constante movimento, difícil de atingir. Dessa forma, as defesas dinâmicas não só protegem suas aplicações como também fornecem informações valiosas sobre as estratégias dos atacantes, que podem ser usadas para fortalecer ainda mais a segurança do sistema.&lt;/p&gt;
&lt;h2&gt;“O ápice da habilidade é atingir o inimigo sem combate”: O Triunfo da Inteligência&lt;/h2&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/8c5585a10f0503db4844.webp&quot; alt=&quot;&quot; width=&quot;1024&quot; height=&quot;585&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;Alcançar a excelência em AppSec frequentemente significa identificar e neutralizar as ameaças antes que elas se materializem em ataques. Isso é conseguido através do uso inteligente de ferramentas de monitoramento comportamental e de resposta a incidentes. Por exemplo, sistemas de Detecção e Resposta a Endpoint (&lt;strong&gt;EDR&lt;/strong&gt;) e plataformas de Orquestração, Automação e Resposta de Segurança (&lt;strong&gt;SOAR&lt;/strong&gt;) são vitais para essa abordagem proativa. Eles trabalham constantemente nos bastidores, analisando o tráfego e as atividades dos usuários em busca de sinais de alarme.&lt;/p&gt;
&lt;p&gt;Esse tipo de tecnologia é a personificação do “combate sem combate”, pois ela permite que as organizações fiquem à frente dos invasores, identificando e corrigindo as vulnerabilidades antes que sejam exploradas. Anomalias e padrões suspeitos são detectados rapidamente, possibilitando que ajustes sejam feitos automaticamente, seja nas regras de aplicativos ou nas defesas perimetrais.&lt;/p&gt;
&lt;p&gt;Adicionalmente, técnicas como o sandboxing ajudam a tirar os possíveis problemas de cena, confinando processos e execuções em ambientes seguros e controlados. Isso permite que o comportamento suspeito seja observado e estudado sem risco ao restante do sistema, facilitando a construção de defesas mais efetivas sem o confronto direto.&lt;/p&gt;
&lt;p&gt;Por meio desse conjunto de estratégias e tecnologias, é possível não apenas bloquear os adversários, mas também aprender com suas tentativas de intrusão, aprimorando continuamente as medidas de segurança e mantendo a infraestrutura sempre um passo à frente dos atacantes.&lt;/p&gt;
&lt;h2&gt;“Seja rápido como o vento, compacto como a floresta”: A Sinergia do DevSecOps&lt;/h2&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/1e5dad56deeb9bcf162d.webp&quot; alt=&quot;&quot; width=&quot;1024&quot; height=&quot;585&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;A velocidade e a eficiência no desenvolvimento andam juntas com uma estrutura bem organizada e resiliente. Com um foco na entrega rápida, mas sem comprometer a segurança, os princípios do &lt;strong&gt;DevSecOps&lt;/strong&gt; incentivam a construção de aplicações que podem se adaptar e responder tão rapidamente quanto necessário — como o vento que muda de direção em um instante.&lt;/p&gt;
&lt;p&gt;A prática de conteinerização exemplifica esta abordagem, pois ela permite que partes de um sistema sejam isoladas em contêineres individuais. Isso não só acelera a distribuição e a escalabilidade dos serviços, como também facilita a atualização isolada de segurança de cada contêiner, reduzindo o tempo de inatividade e a interrupção de serviços — uma estratégia parecida com uma floresta, onde cada árvore pode crescer e se adaptar individualmente, mas juntas formam um ecossistema robusto.&lt;/p&gt;
&lt;p&gt;A integração contínua e a entrega contínua (&lt;strong&gt;CI/CD&lt;/strong&gt;) são também peças fundamentais desse quebra-cabeça, permitindo que o código seja desenvolvido, testado e lançado de forma mais eficiente. As pipelines incorporam uma série de testes automatizados, que incluem análise estática e dinâmica do código, bem como verificação de dependências, para assegurar que qualquer alteração feita seja segura e não introduza novos riscos.&lt;/p&gt;
&lt;p&gt;Essa sinergia de desenvolvimento rápido, infraestrutura ágil e segurança incorporada coloca o &lt;strong&gt;DevSecOps&lt;/strong&gt; na vanguarda da inovação em segurança cibernética, onde a aplicação está sempre pronta para enfrentar desafios sem perder o passo diante das demandas do mercado ou das ameaças emergentes.&lt;/p&gt;
&lt;h2&gt;“Um bom guerreiro é cauteloso”: Prudência na Governança de Acesso&lt;/h2&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/3d4e9be1c2e2b5c42e8f.webp&quot; alt=&quot;&quot; width=&quot;1024&quot; height=&quot;585&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;O cuidado meticuloso é um aspecto crítico na proteção de aplicações, onde a gestão de identidades e acesso (&lt;strong&gt;Identity and Access Management — IAM&lt;/strong&gt;) se apresenta como um pilar central. Esta disciplina abarca estratégias, tecnologias e processos desenhados para garantir que apenas entidades credenciadas — sejam elas indivíduos ou sistemas — possam acessar os recursos corretos nas condições apropriadas.&lt;/p&gt;
&lt;p&gt;A consolidação dos princípios do &lt;strong&gt;Zero Trust&lt;/strong&gt; reflete um novo paradigma na governança de segurança: a negação de confiança por padrão e a necessidade de verificação rigorosa antes da concessão de qualquer acesso. No lugar do tradicional perímetro de segurança, destaca-se a verificação contínua de credenciais, o que adiciona uma camada crítica de segurança em um mundo onde as ameaças podem surgir de qualquer lugar.&lt;/p&gt;
&lt;p&gt;Ferramentas e protocolos como &lt;strong&gt;OAuth&lt;/strong&gt; e &lt;strong&gt;OpenID Connect&lt;/strong&gt; são exemplos de mecanismos utilizados pelos sistemas &lt;strong&gt;IAM&lt;/strong&gt; modernos para facilitar o gerenciamento de acesso baseado em token. Estes padrões não apenas autenticam usuários, mas também definem políticas de acesso detalhadas e adaptativas, tendo em vista o contexto da solicitação de acesso, a geolocalização e o comportamento do usuário.&lt;/p&gt;
&lt;p&gt;O Controle de Acesso Baseado em Funções (&lt;strong&gt;RBAC&lt;/strong&gt;) permite uma alinhamento fino entre os direitos de acesso e as responsabilidades do usuário, garantindo que os indivíduos tenham apenas as permissões necessárias para desempenhar suas funções. Já o Gerenciamento de Acesso Privilegiado (&lt;strong&gt;PAM&lt;/strong&gt;) visa a regulamentação e o monitoramento do acesso a credenciais de alto nível, protegendo contra o mau uso de privilégios essenciais.&lt;/p&gt;
&lt;h2&gt;Conclusão: A União entre Sabedoria Antiga e Segurança Moderna.&lt;/h2&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/0922000461fb51da63ac.webp&quot; alt=&quot;&quot; width=&quot;1024&quot; height=&quot;585&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;Assim como o general Sun Tzu traçou estratégias milenares ainda válidas nos combates de hoje, as batalhas digitais em AppSec são vencidas com planejamento, inteligência e adaptação. No mundo virtual, as espadas são substituídas por bits e bytes, mas os conceitos de vigilância, preparo e astúcia permanecem tão vitais quanto no campo de batalha clássico.&lt;/p&gt;
&lt;p&gt;“&lt;strong&gt;Avaliação e Consciência Contínua&lt;/strong&gt;” ensinam-nos a conhecer os pontos fortes e fracos de nossas aplicações, assim como as técnicas de nossos inimigos. As armas modernas para tal empreitada são análises de código e inteligência sobre ameaças, que, quando aplicadas, blindam nossas fortalezas digitais antes que o inimigo chegue aos portões.&lt;/p&gt;
&lt;p&gt;“&lt;strong&gt;A Arte da Preparação&lt;/strong&gt;”, onde aprendemos que o embate é decidido muito antes de começar, manifesta-se na antecipação de riscos e na integração de medidas de segurança desde a concepção do projeto. “Secure by Design”, modelagem de ameaças e revisões de código são pilares desse planejamento meticuloso, promovendo um desenvolvimento onde cada linha de código é um bastião defensivo.&lt;/p&gt;
&lt;p&gt;A maximização de “&lt;strong&gt;A Defesa Invisível&lt;/strong&gt;” e “&lt;strong&gt;A Enganação Como Tática&lt;/strong&gt;” nos ensina a arte de vencer sem ser visto e sem confronto direto. Estratégias de defesa marcam o território onde os atacantes percebem barreiras de segurança sem identificar a origem de sua falha, desistindo sem conhecer a profundidade das defesas que os subjugam.&lt;/p&gt;
&lt;p&gt;Na premissa de que a “&lt;strong&gt;Dinâmica das Defesas&lt;/strong&gt;” deve ser imprevisível, encaramos o constante movimento e inovação como essenciais. Honeypots e mudanças estratégicas em infraestrutura fazem com que nossos sistemas não só resistam aos avanços dos adversários, mas também recolham informações vitais para fortalecimentos futuros.&lt;/p&gt;
&lt;p&gt;E finalmente, atingimos “&lt;strong&gt;O Triunfo da Inteligência&lt;/strong&gt;”, em que a maestria de AppSec é demonstrada pela capacidade de neutralizar ameaças sem a necessidade de confronto. Vigilância, resposta automática a incidentes e sandboxing são exemplos da supremacia da astúcia e previsão sobre a força bruta.&lt;/p&gt;
&lt;p&gt;A rapidez e a resiliência de &lt;strong&gt;DevSecOps&lt;/strong&gt;, “&lt;strong&gt;rápido como o vento, compacto como a floresta&lt;/strong&gt;”, combinadas à prudência na governança de acesso, refletem a imagem de um “&lt;strong&gt;bom guerreiro&lt;/strong&gt;”, sempre cauteloso e preparado.&lt;/p&gt;
</content:encoded><category>appsec</category><category>sast</category><category>dast</category><category>modelagem-de-ameacas</category></item><item><title>A Autenticação Federada e o SSO (Ou: “Vocês Esqueceram o ‘Crachá’?”)</title><link>https://luidiblu.com/posts/autenticacao-federada-e-sso/</link><guid isPermaLink="true">https://luidiblu.com/posts/autenticacao-federada-e-sso/</guid><description>SAML, SCIM, OpenID Connect e OAuth explicados a partir da autenticação federada e do SSO.</description><pubDate>Tue, 21 Nov 2023 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Imagine um grande aeroporto internacional: um hub de atividades, onde milhares de passageiros, funcionários e clientes se movimentam diariamente. Cada indivíduo nesse espaço possui uma identidade e um propósito específico, e a segurança é primordial. Tomemos o exemplo e um piloto, uma figura central neste cenário.&lt;/p&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/cbcd7c73eefbb1d8ab3b.jpg&quot; alt=&quot;&quot; width=&quot;1024&quot; height=&quot;683&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;Um piloto precisa acessar diversas áreas restritas do aeroporto — desde salas de briefing de voo até pistas de decolagem. No passado, diferentes áreas requeriam diferentes formas de identificação, como crachás físicos ou códigos de acesso. No entanto, a adoção de uma Autenticação Federada simplifica este processo. Com ela, o piloto utiliza um único crachá de identificação — uma credencial unificada que é reconhecida por todos os sistemas de segurança do aeroporto. Essa credencial é validada por um sistema central, que autentica a identidade do piloto e fornece acesso às áreas necessárias com base em seu perfil e necessidades do dia.&lt;/p&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/5ef667f0af083de141f5.jpg&quot; alt=&quot;&quot; width=&quot;860&quot; height=&quot;572&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;Além disso, as permissões de acesso do piloto não são estáticas. Dependendo do voo do dia, destinos ou níveis de segurança, o sistema, apoiado pelo protocolo OAuth, pode ajustar dinamicamente os níveis de acesso. Isso significa que, em um dia, o piloto pode ter acesso à uma sala de briefing internacional, enquanto em outro, seu acesso é restrito a voos domésticos. O &lt;strong&gt;OAuth&lt;/strong&gt; permite essa flexibilidade, gerenciando o acesso com base em parâmetros que mudam em tempo real, garantindo que o acesso seja concedido apenas às informações e áreas relevantes para o piloto naquele momento específico.&lt;/p&gt;
&lt;p&gt;Assim como um piloto navega por diferentes áreas de um aeroporto, usuários da internet transitam entre diversos serviço e plataformas online. À medida que o tecido do ciberespaço se expande, a Autenticação Federada emerge não apenas como uma solução, mas como um imperativo estratégico. A era do “Big Data” e do “IoT” não apenas ampliou o escopo de gerenciamento de identidades, mas também complicou suas nuances.&lt;/p&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/c607dc8c638959d79d0e.jpg&quot; alt=&quot;&quot; width=&quot;1000&quot; height=&quot;667&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;Esta complexidade é causada pelo avanço de padrões como &lt;strong&gt;SAML 2.0&lt;/strong&gt;, que agora se integra de forma mais profunda com tecnologias na cloud, e &lt;strong&gt;OpenID Connect&lt;/strong&gt;, que evoluiu para abraçar padrões de &lt;strong&gt;JWT&lt;/strong&gt;, facilitando flexibilidade e segurança. Dê uma olhada:&lt;/p&gt;
&lt;h2&gt;A Evolução de SAML: Do XML para a Nuvem&lt;/h2&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/37a05f815bfb78cd6c55.png&quot; alt=&quot;&quot; width=&quot;850&quot; height=&quot;567&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;O &lt;strong&gt;SAML&lt;/strong&gt; (&lt;em&gt;Security Assertation Markup Language&lt;/em&gt;) é um protocolo baseado em &lt;strong&gt;XML&lt;/strong&gt; desenvolvido para facilitar a comunicação segura de autenticação e autorização entre domínios distintos — essencial para viabilizar a implementação do &lt;strong&gt;SSO&lt;/strong&gt; (&lt;em&gt;Single Sign-On&lt;/em&gt;).&lt;/p&gt;
&lt;p&gt;Com &lt;strong&gt;SSO&lt;/strong&gt; baseado em &lt;strong&gt;SAML&lt;/strong&gt;, usuários podem fazer login uma única vez e obter acesso a diversos sistemas, serviços e aplicações sem a necessidade de autenticação repetida. Isso não apenas enriquece a experiência do usuário, mas também fortalece a postura de segurança ao diminuir a superfice de ataque através de menos pontos de autenticação.&lt;/p&gt;
&lt;p&gt;Ao integrar &lt;strong&gt;SSO&lt;/strong&gt; via &lt;strong&gt;SAML&lt;/strong&gt; com controles modernos de segurança e governança de identidade, as organizações podem proporcionar acesso simplificado e protegido, em linha com os mais altos padrões de compliance e melhores práticas.&lt;/p&gt;
&lt;h2&gt;SCIM: Sincronização de Identidade na Cloud&lt;/h2&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/7199fe004ac249b44db8.png&quot; alt=&quot;&quot; width=&quot;600&quot; height=&quot;350&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;O &lt;strong&gt;SCIM&lt;/strong&gt; (&lt;em&gt;System for Cross-domain Identity Management&lt;/em&gt;) é uma especificação aberta que permite a manutenção automatizada de identidades de usuários em diversas plataformas na internet.&lt;/p&gt;
&lt;p&gt;Ele serve como uma linguagem comum que facilita a automação de trocas de informações de identidade dentre as plataformas.&lt;/p&gt;
&lt;p&gt;Contendo uma abordagem baseada em &lt;em&gt;REST&lt;/em&gt;, oferece um &lt;em&gt;CRUD&lt;/em&gt; para as identidades dos usuários, facilitando a integração com &lt;strong&gt;IDaaS&lt;/strong&gt; (&lt;em&gt;Identity-as-a-Service&lt;/em&gt;) como &lt;strong&gt;&lt;em&gt;Okta&lt;/em&gt;&lt;/strong&gt; ou &lt;strong&gt;&lt;em&gt;Azure AD&lt;/em&gt;&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;Isso permite que as empresas automatizem os processos de provisionamento e desligamento de usuários, adaptando rapidamente as autorizações conforme as mudanças nos papéis dos funcionários, etc…&lt;/p&gt;
&lt;p&gt;Esta automação é muito benéfica em ambientes que requerem sincronização contínua de identidades entre sistemas &lt;em&gt;on-premise&lt;/em&gt; e serviços na nuvem, ajudando a reduzir a carga admnistrativa e minimizar os erros humanos.&lt;/p&gt;
&lt;h2&gt;OIDC e a Convergência com tecnologias Blockchain&lt;/h2&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/96a5d141038d8a708a24.png&quot; alt=&quot;&quot; width=&quot;1024&quot; height=&quot;593&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;&lt;strong&gt;OIDC (&lt;em&gt;OpenID Connect&lt;/em&gt;&lt;/strong&gt;) é uma camada de autenticação construída em cima do protocolo &lt;strong&gt;OAuth&lt;/strong&gt;, permitindo de forma simples e segura que clientes de todos os tipos, seja em aplicações web, móveis ou desktop, verifiquem a identidade do usuário. A utilização de tokens padronizados em formato &lt;strong&gt;JWT&lt;/strong&gt; (&lt;em&gt;JSON Web Token&lt;/em&gt;), que contém as informações sobre a identidade do usuário, torna o &lt;strong&gt;OIDC&lt;/strong&gt; uma solução poderosa e flexível para gerenciarmos identidade digitais.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Aspectos Detalhados do OIDC:&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Fluxo do Protocolo OIDC:&lt;/strong&gt; Utilizando o fluxo de toques do &lt;strong&gt;OAuth 2.0&lt;/strong&gt;, &lt;strong&gt;OIDC&lt;/strong&gt; adiciona o token de ID, um tipo de token assinado digitalmente que contém as reivindicações sobre a autenticação do usuário. Esse token é enviado ao cliente após um processo bem-sucedido de autenticação conduzido pelo servidor de autorização.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Conformidade e Segurança:&lt;/strong&gt; &lt;strong&gt;OIDC&lt;/strong&gt; cumpre um papel fundamental ao fornecer uma identidade verificável em diferentes domínios. Isso é essencial para cumprir com regulamentações globais, como a &lt;strong&gt;GDPR&lt;/strong&gt;, que requer clientes capazes de confirmar a identidade, a origem e o tempo da autenticação do usuário.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;OpenID Provider (OP):&lt;/strong&gt; Serviço que autentica o usuário e emite token de ID. O OP pode ser um serviço de identidade já conhecido, como Google ou um sistema de gerenciamento de identidade corporativa personalizado.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;Exemplos Atuais de Implantação do OIDC:&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Login de mídias sociais:&lt;/strong&gt; Serviços como &lt;strong&gt;&lt;em&gt;Google&lt;/em&gt;&lt;/strong&gt; e &lt;strong&gt;&lt;em&gt;Facebook&lt;/em&gt;&lt;/strong&gt; usam &lt;strong&gt;OIDC&lt;/strong&gt; para oferecer uma experiência de login consistente e autenticação segura em diferentes serviços, tanto para aplicações nativas como para websites.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Aplicações Governamentais:&lt;/strong&gt; Agências governamentais utilizam &lt;strong&gt;OIDC&lt;/strong&gt; para fornecer acessos a portais e sistemas, garantindo uma camada extra de segurança e traçabilidade.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Saúde:&lt;/strong&gt; &lt;strong&gt;OIDC&lt;/strong&gt; pode ser usado em plataformas de saúde para proteger os dados sensíveis dos pacientes, permitindo o acesso apenas para usuários e aplicações autenticadas e autorizadas.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;IoT e Smart Devices:&lt;/strong&gt; Em um contexto onde dispositivos inteligentes necessitam autenticar-se para acessar serviços na nuvem, &lt;strong&gt;OIDC&lt;/strong&gt; proporciona um meio adequado, seguro e padronizado de autenticação.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;A inserção estratégica de &lt;strong&gt;OIDC&lt;/strong&gt; no ecossistema de autenticação e acesso não só proporciona flexibilidade e abertura ao mundo digital, mas também atende à crescente demanda por &lt;strong&gt;métodos de autenticação descentralizados&lt;/strong&gt; quando combinado com tecnologias como blockchain, potencializando as capacidades de autenticação federada com maior transparência e redução de riscos associados à centralização de dados.&lt;/p&gt;
&lt;p&gt;Com sua adaptabilidade a diferentes cenários de aplicação e seu alinhamento aos avanços tecnológicos, &lt;strong&gt;OIDC&lt;/strong&gt; é indispensável para arquitetar uma infraestrutura digital que seja ao mesmo tempo segura, escalável e centrada no usuário.&lt;/p&gt;
&lt;h2&gt;OAuth 2.0: Do Acesso às APIs à Economia de Tokens&lt;/h2&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/76648ff59fbf041d1a86.png&quot; alt=&quot;&quot; width=&quot;624&quot; height=&quot;268&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;&lt;strong&gt;OAuth 2.0&lt;/strong&gt; é um protocolo de autorização que se tornou o padrão para autenticação segura e delegada na web. Com sua abordagem flexível, permite que aplicações solicitem tokens de acesso limitados, oferecendo maneiras seguras de conceder aos usuários controle sobre o acesso a seus dados sem compartilhar suas credenciais.&lt;/p&gt;
&lt;p&gt;O sucesso do &lt;strong&gt;OAuth 2.0&lt;/strong&gt; reside em sua simplicidade e poder de adaptação. Ele fornece distintos fluxos de concessão para se adaptar a uma variedade de cenários de aplicativos, desde servidores back-end até clientes de navegadores da web e aplicações nativas. Isso possibilita uma implementação personalizada que melhor atenda às necessidades de segurança de cada caso.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Exemplos Práticos de Uso:&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Integrações de Aplicativos Third-party:&lt;/strong&gt; Permite que serviços como Spotify ou PayPal integrem-se com outras aplicações, concedendo acesso a dados selecionados sem expor credenciais de usuário.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Mobile e Desktop Apps:&lt;/strong&gt; Habilita aplicações para solicitar acessos a recursos como contatos e arquivos em serviços como Google e Microsoft OneDrive de maneira controlada.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Com sua abordagem modular e extensível, &lt;strong&gt;OAuth 2.0&lt;/strong&gt; serve como base confiável para complexas estratégias de gestão de autenticação e autorização em uma ampla variedade de aplicações, simplificando e padronizando como os acessos a dados e serviços são gerenciados online.&lt;/p&gt;
&lt;h2&gt;Resumo da Ópera&lt;/h2&gt;
&lt;p&gt;As tecnologias que discutimos — Autenticação Federada, &lt;strong&gt;SAML&lt;/strong&gt;, &lt;strong&gt;SCIM&lt;/strong&gt;, &lt;strong&gt;OIDC&lt;/strong&gt; e &lt;strong&gt;OAuth 2.0&lt;/strong&gt; — formam uma espinha dorsal da segurança, da mesma forma que os sistemas de identificação e acesso controlam o fluxo de pessoas em um aeroporto movimentado. Assim como um único crachá pode fornecer a um piloto acesso a várias áreas do aeroporto, do briefing de vôo à pista, a Autenticação Federada permite que os usuários transitem sem esforço pela internet, acessando uma variedade de serviços com um único conjunto de credenciais.&lt;/p&gt;
&lt;p&gt;A dinâmica e eficiência do protocolo &lt;strong&gt;OAuth 2.0&lt;/strong&gt; espelham a flexibilidade com que a segurança do aeroporto deve operar — ajustando o acesso com precisão conforme as necessidades e circunstâncias variam. Cada tecnologia abordada é como uma parte vital no complexo sistema do aeroporto, essencial para manter a ordem, eficiência e segurança.&lt;/p&gt;
&lt;p&gt;Com avanços contínuos e inovações como essas, estamos construindo a infraestrutura necessária para um ecossistema digital que seja seguro e acessível, onde a liberdade de movimento para dados e aplicações é tão fundamental quanto a de pessoas em um aeroporto.&lt;/p&gt;
</content:encoded><category>identidade</category><category>saml</category><category>scim</category><category>oidc</category></item><item><title>Você é familiar com todos os sistemas operacionais?</title><link>https://luidiblu.com/posts/sistemas-operacionais/</link><guid isPermaLink="true">https://luidiblu.com/posts/sistemas-operacionais/</guid><description>Kernel, espaço do usuário e as diferenças entre Windows, macOS, Linux e Unix.</description><pubDate>Mon, 05 Oct 2020 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Primeiramente, um sistema operacional é um software que gerencia tudo que está acontecendo no computador, ele lê, escreve e deleta arquivos do seu HD. Ele também gerencia como um processo será iniciado, como os processos conversarão entre sí e como eles serão terminados. O sistema operacional também manuseia como a memória é alocada em processos diferentes, como os pacotes de redes são enviados e recebidos e como cada programa pode ler cada componente do hardware.&lt;/p&gt;
&lt;p&gt;Existem duas principais partes de um sistema operacional: O kernel e o espaço do usuário. O kernel é o componente principal de um OS, ele conversa diretamente com nosso hardware e manuseia os recursos do sistema.&lt;/p&gt;
&lt;p&gt;Como um usuário, nós não interagimos diretamente com o Kernel. Ao invés disso nós interagimos com outra parte chamada “espaço do usuário”. Esse espaço é basicamente tudo fora do Kernel.&lt;/p&gt;
&lt;p&gt;Como você provavelmente sabe, existem vários sistemas operacionais diferentes por ai, os mais conhecidos, são: Windows, Mac OS e Linux.&lt;/p&gt;
&lt;p&gt;O Windows é desenvolvido pela Microsoft e é muito usado para empresas e usuários comuns. Vários computadores costumam vir com Windows como sistema operacional padrão.&lt;/p&gt;
&lt;p&gt;Se você comprar um computador da Apple, ele virá com Mac Os de fábrica.&lt;/p&gt;
&lt;p&gt;Linux é um sistema operacional de código aberto. Softwares de código aberto, são livres para distribuir, modificar e compartilhar. Linux é fortemente usado em infraestruturas. Grande parte dos servidores do mundo estão rodando Linux, desenvolvido pelo &lt;em&gt;Linus Torvalds.&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;Normalmente usamos a palavra “Linux” para falar tanto do Kernel quanto do sistema operacional. Atualmente, Linux tem uma comunidade enorme de desenvolvedores pelo mundo contribuindo com o sistema.&lt;/p&gt;
&lt;p&gt;Algumas distribuições mais comuns do Linux são: Ubuntu, Debian e Red Hat. (Até mesmo o Chrome OS é baseado em Linux)&lt;/p&gt;
&lt;p&gt;Você também pode ter escutado sobre Unix. Unix é um OS desenvolvido nos anos 70’s, antes do seu lançamento oficial, o OS passou por várias modificações. As principais ideias do Linux hoje, foram baseadas nos princípios do Unix. Muitas ferramentas que usamos hoje, foram referenciadas do Unix.&lt;/p&gt;
&lt;p&gt;As ferramentas do kernel e o user space do Mac Os são baseadas em um “primo” do Unix, chamado BSD. Por mais que a interfáce gráfica seja extremamente diferente, suas CLI’s são bem parecidas.&lt;/p&gt;
&lt;p&gt;Particularmente uso muito o Linux, ele é um mundo totalmente diferente…. Cheio de possíbilidades e customizações. E você? Já experimentou o Linux hoje?&lt;/p&gt;
</content:encoded><category>sistemas</category><category>linux</category><category>unix</category></item><item><title>Como funciona a priorização de projetos?</title><link>https://luidiblu.com/posts/priorizacao-de-projetos/</link><guid isPermaLink="true">https://luidiblu.com/posts/priorizacao-de-projetos/</guid><description>Uma reflexão sobre tempo, recursos e a escolha do que importa na priorização de projetos.</description><pubDate>Fri, 25 Sep 2020 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Um dos problemas mais cabulosos que eu vi durante minha carreira de programação, é a capacidade das pessoas de fugir da priorização.&lt;/p&gt;
&lt;p&gt;O modo mais normal das pessoas é ligar o automático ou “alguém escolhe por mim e eu faço”.&lt;/p&gt;
&lt;p&gt;Os programadores não entendem que é fácil demais postar no Twitter como a gerência do projeto é horrível ou da empresa é ruim. Mas nenhum desses já assumiram a responsabilidade de ter um projeto para, ai sim, criticar com tanta razão. Não é dificil criticar e apontar dedos, difícil é executar e mostrar resultado. Eu, particularmente, não costumo escutar alguém que não tem resutlados mensuráveis para mostrar.&lt;/p&gt;
&lt;p&gt;Você não precisa ser um SCRUM MASTER ou ter um certificado de gestão de projetos para entender os conceitos normais sobre priorização.&lt;/p&gt;
&lt;p&gt;Existe uma commoditie que é rara e finita que costumamos vender por pouco dinheiro, e essa commoditie é o nosso Tempo. Tempo, Recursos, Dinheiro e Pessoas são coisas finitas.&lt;/p&gt;
&lt;p&gt;Sabendo que essas coisas são finitas, você precisa escolher o que fazer, claro, se o tempo fosse infinito, você poderia empurrar tudo com a barriga que seu pé de meia ficaria garantido. A primeira coisa que normalmente fazemos quando escolhermos algo para fazer, é planejar, como uma história, seu projeto precisa ter começo, meio e fim.&lt;/p&gt;
&lt;p&gt;Priorizar, funciona da seguinte forma: Quando você tem inúmeros tipos de tarefas, grandes, pequenas, complexas, etc… Se você não se cuidar, ou não falar não, você acaba empurrando essas tarefas com a barriga e isso resulta em começar as tarefas fáceis e menores primeiro, e, só quando o projeto começa a tomar forma, você percebe que é tarde demais e que as principais tarefas ficaram no papel. Ou seja, você gastou seu tempo fazendo o que não era importante.&lt;/p&gt;
&lt;p&gt;Gosto de um exemplo que vi na internet, onde uma pessoa precisa colocar dois tipos de bolas dentro de um pote, várias bolinhas pequenas e 4 bolas grandes, se a pessoa colocar primeiro as bolinhas pequenas, as grandes não terão espaço e isso resulta nas bolas saindo do pote, porém, com a priorização, quando colocam-se as bolas grandes antes das pequenas, todo o material cabe dentro do copo.&lt;/p&gt;
&lt;p&gt;E isso sim é um bom exemplo de gerencia de projetos. Ter uma boa gestão, é você garantir que o 1% dos 1% de erros, não vai comprometer o sistema inteiro, ou então o sprint todo.&lt;/p&gt;
&lt;p&gt;Parar uma sprint no meio, é um exemplo. Você, sabendo que o tempo é finito, prefere continuar até finalizar o sprint para somente no próximo você arrumar algo, ou cancelar imediatamente e poupar seu tempo?&lt;/p&gt;
</content:encoded><category>projetos</category><category>priorizacao</category></item><item><title>Qual a verdade do Sidekiq?</title><link>https://luidiblu.com/posts/a-verdade-do-sidekiq/</link><guid isPermaLink="true">https://luidiblu.com/posts/a-verdade-do-sidekiq/</guid><description>Filas, workers e o processamento assíncrono de tarefas com Sidekiq e Ruby on Rails.</description><pubDate>Sat, 29 Aug 2020 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Normalmente, quando falamos sobre a arquitetura padrão (MVC, RAILS + HEROKU), temos uma longa caminhada de tráfego. Durante toda essa caminhada (Do request até a response) bloqueamos nossa UX de retornar &lt;strong&gt;absolutamente qualquer coisa.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;O processo padrão do heroku que lida com essas requisições também é bloqueado. Se a aplicação demorar mais de 30 segundos, ele encerra a conexão te retornando um &lt;strong&gt;TIMED OUT&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;Ele(Heroku) faz isso, pois o que você verdadeiramente paga no Heroku, são os números de processamentos de aplicações (conhecidos como Dynos).&lt;/p&gt;
&lt;p&gt;Existem &lt;strong&gt;DOIS TIPOS&lt;/strong&gt; de Dynos:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Web Dyno&lt;/li&gt;
&lt;li&gt;Worker Dyno&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Em alto nível, um Dyno é um processo que roda na sua aplicação Rails.&lt;br /&gt;
Um Web Dyno, é um subtópico especialmente feito para lidar com tráfego web.&lt;/p&gt;
&lt;p&gt;O Heroku coloca todos os Web Dynos atrás de algo que chamamos de “Routing Mash”&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Request -&amp;gt; HTTP Reverse Proxy -&amp;gt; HTTP cache -&amp;gt; Routing Mash -&amp;gt; Dyno Grid&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;No caso, ao invés de demorar 30 segundos, podemos adicionar o request dentro de uma lista e retornar imediatamente pro usuário uma mensagem do tipo “Adicionamos sua requisição na nossa lista.”&lt;/p&gt;
&lt;p&gt;Basicamente, é um key value sem precisar modelar os dados com um banco sequencial (Sim, redis.)&lt;/p&gt;
&lt;p&gt;Então, no caso, ao invés de chamar o model.rb para gerar o report, colocamos uma mensagem na fila e ele retornará imediatamente ao usuário. Enquanto isso, nossa fila também se comunica com um worker.&lt;/p&gt;
&lt;p&gt;Um worker é um &lt;strong&gt;objeto em Ruby&lt;/strong&gt; que está num processo diferente do que está no mesmo deploy do &lt;strong&gt;Web Request&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;Pelo fato do serviço estar separado da Web, ele não está registrado nas regras de 30 segundos, ou seja, quando o Worker finalizar o processo, podemos tomar alguma decisão com os dados. Como, por exemplo, mandar um email pro usuário ou subir no Bucket.&lt;/p&gt;
&lt;p&gt;Normalmente, adicionamos os dados no cache, para que o usuário veja na Web sem precisar recalcular.&lt;/p&gt;
&lt;p&gt;Normalmente usamos sempre o Redis com o Sidekiq….&lt;/p&gt;
&lt;p&gt;Redis =&amp;gt; Banco de Dados.&lt;br /&gt;
Sidekiq =&amp;gt; Lib para manusear os processos e aplicações Rails.&lt;/p&gt;
&lt;p&gt;Ps: O Sidekiq vêm com sua própria UI, que é feita em Sinatra, logo, você precisa importar o Sinatra.&lt;/p&gt;
&lt;p&gt;Exemplos:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#routes.rb

require ‘sidekiq/web’
mount Sidekiq::Web =&amp;gt; “/sidekiq”

$ mkdir workers
$ cd workers &amp;amp;&amp;amp; touch report_worker.rb

#report_worker.rb

class ReportWorker
  include Sidekiq::worker
  sidekiq_options retry:false

  def perform(start_date, end_date)
    puts(&quot;#{start_date} até #{end_date}&quot;)
  end
end
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;No caso acima, usamos o retry: false pois por padrão, se o worker falhar, ele tentará executar o processo até dar certo.&lt;br /&gt;
Todo Sidekiq Woker tem um método chamado “Perform”. Ele que é chamado quando algo da fila é processado.&lt;/p&gt;
&lt;p&gt;Você pode colocar paramêtros na fila ;).&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#controller.rb

def report
  ReportWorker.perform_async(&quot;01-01-2020&quot;, &quot;01-01-2021&quot;)
  render text: &quot;Request Comum&quot;
end
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;E por último, para sabermos pelo menos como funciona a execução do Sidekiq, para rodarmos ele no terminal, usamos:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;sidekiq -c 1&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Ele roda todos os processos com uma Thresh (padrão), Mas você pode aumentar esse número.&lt;br /&gt;
Por padrão, ele sabe que a fila está no Redis, pois, ele lê a porta 6379 (Padrão do Redis)&lt;/p&gt;
&lt;p&gt;Tá Diego, mas como posso dar deploy disso na núvem?&lt;/p&gt;
&lt;p&gt;Eu te respondo meu caro:&lt;/p&gt;
&lt;p&gt;Na sua aplicação Rails, faça o seguinte:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#procfile

reportworker: bundle sidekiq -c 1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Assim, ele irá executar o mesmo comando que fizemos no nosso terminal local.&lt;/p&gt;
&lt;p&gt;:) Não sei finalizar um texto, então….&lt;/p&gt;
&lt;p&gt;$ systemctl stop medium-text&lt;/p&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/f3b36ea2eb9f8db78764.jpg&quot; alt=&quot;&quot; width=&quot;480&quot; height=&quot;360&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;</content:encoded><category>sidekiq</category><category>filas</category><category>ruby</category></item><item><title>Como gerar um código QR usando Python</title><link>https://luidiblu.com/posts/qr-code-com-python/</link><guid isPermaLink="true">https://luidiblu.com/posts/qr-code-com-python/</guid><description>Um pequeno experimento para gerar um QR Code usando Python e a biblioteca qrcode.</description><pubDate>Fri, 12 Jun 2020 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;O QR-Code desperta muito interesse e ao mesmo tempo dúvidas nos usuários.&lt;/p&gt;
&lt;p&gt;Logo, decidi criar um pequeno tutorial de como criar/gerar um desses códigos.&lt;/p&gt;
&lt;p&gt;(Usaremos as libs qrcode e OpenCV)&lt;/p&gt;
&lt;p&gt;Dependencias:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;pip3 install pillow qrcode
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Agora podemos gerar nosso QR Code!&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import qrcode

# Exemplo de data
data = &quot;https://www.linkedin.com/in/diegopisani/&quot;

# Nomeamos o arquivo 
filename = &apos;qrcode.png&apos;

# Geramos o QR Code
img = qrcode.make(data)

# Salvamos a img num file
img.save(filename)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Esse código irá gerar um QR Code apontando para o LinkedIn (No caso, meu perfil)&lt;/p&gt;
&lt;p&gt;E esse é o tutorial o/&lt;/p&gt;
</content:encoded><category>python</category><category>qr-code</category></item><item><title>Como funciona um ataque básico via SQL Injection?</title><link>https://luidiblu.com/posts/sql-injection-basico/</link><guid isPermaLink="true">https://luidiblu.com/posts/sql-injection-basico/</guid><description>Uma introdução aos riscos de consultas SQL construídas com entradas não tratadas.</description><pubDate>Sat, 28 Mar 2020 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Primeiramente, precisamos saber o que é SQL e banco de dados. Um banco de dados é uma coleção de informações organizadas em colunas e linhas, formando uma tabela. A linguagem SQL é muito poderosa e precisamos ter conhecimento sobre ela para entender o ataque. No exemplo abaixo, observamos que é normal que existe uma página onde o usuário digite o login e senha para acessar sua conta. Abaixo podemos ver uma consulta simples de SQL:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;select * from login where usuario = &apos;Luke&apos; and senha = &apos;skyw@lk3r!&apos;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;A consulta SQL acima mostra a tabela onde existe um usuário chamado Luke, e sua respectiva senha. Mas o que aconteceria se você só tivesse acesso ao nome do usuário? Talvez você tenha pensado que não conseguiríamos acessar a tabela, porém, podemos comentar a parte que pede a senha do usuário, comentando esse pequeno trecho do código, usando: ‘ — ‘.&lt;/p&gt;
&lt;p&gt;Injetando esse comentário, tudo que estiver escrito após os sinais será desconsiderado e ignorado.&lt;/p&gt;
&lt;p&gt;No caso, percebe-se que mesmo digitando uma senha diferente do banco de dados, poderíamos acessar a tabela da mesma forma, pois o trecho que solicita a senha seria ignorado por causa do código que serve com comentário.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;select * from login where usuario = &apos;Luke&apos; -- and senha = &apos;skyw@lk3r!&apos;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Outra forma de conseguir acesso via SQL Injection, é quando não possuímos usuário e nem a senha. Usamos então a seguinte string no código no campo do nome e também no campo da senha: &lt;strong&gt;‘or’ 1 = 1 —&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;A instrução &lt;strong&gt;or&lt;/strong&gt; diz ao banco que se alguma condição não puder ser completada, outra pode ser feita.&lt;/p&gt;
&lt;p&gt;Usando esse código, nossa query ficaria assim:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;select * from login where usuario = &apos;&apos; or 1 = 1 -- and senha = &apos;teste senha&apos;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Verficamos que como o nome está vazio passará para a instrução or, que vai perguntar se 1 é igual a 1. (Óbvio que é) Ela, assim, acessará o primeiro usuário que estiver cadastrado e ignorará a senha.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;STRINGS DE ATAQUE PARA COLOCAR NOS CAMPOS:&lt;br /&gt;
1º) — ‘&lt;br /&gt;
2º) ‘ — ‘&lt;br /&gt;
3º) ‘or’ 1=1&lt;br /&gt;
4º) ‘or’ 1=1 —&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Atualmente, as empresas de softwares, junto aos seus programadores, já fazem o tratamento desse tipo de falha. Porém, ainda são comuns falhas como essas em aplicações criadas por iniciantes ou pessoas que focam na usabilidade sem pensar na segurança.&lt;/p&gt;
</content:encoded><category>seguranca</category><category>sql-injection</category></item><item><title>Como fazer uma varredura básica com NMAP</title><link>https://luidiblu.com/posts/varredura-basica-com-nmap/</link><guid isPermaLink="true">https://luidiblu.com/posts/varredura-basica-com-nmap/</guid><description>Uma introdução a conexões TCP, portas e inventário de serviços em redes com Nmap.</description><pubDate>Thu, 27 Feb 2020 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;O NMAP é um scan baseado em TCP Connect, ou seja, uma conexão TCP. Quando usamos o scan, ele tenta fechar uma conexão com a máquina alvo seguindo o protocolo TCP de 3 vias. Quando usamos uma conexão TCP, nosso computador faz essa conexão de 3 vias que chamamos de Handshake (aperto de mãos). Se o computador 1 quer conversar com o computador 2, ele manda um pacote SYN para o computador 2, que responde com um pacote SYN/ACK. O computador 1 então recebe o pacote SYN/ACK e responde com ACK, fechando assim a conexão dos computadores.&lt;/p&gt;
&lt;p&gt;Tendo isso em mente, o NMAP então envia um pacote SYN e recebe um pacote SYN/ACK do alvo e a conexão é fechada com um pacote ACK. Com base nessa informação, ele consegue verificar quais portas estão abertas.&lt;br /&gt;
Exemplo:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;nmap -sT -p- 192.168.0.1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;No comando acima, o -sT significa que vamos usar um scan com base na conexão TCP, o -p- significa que vamos varrer todas as portas. Podemos fazer uma varredura em uma porta específica, o que é recomendado, já que geraria menos tráfego na rede. Então, se quiséssemos varrer pela porta 80, trocaríamos o -p- por -p80.&lt;br /&gt;
Exemplo:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;nmap -sT -p80 192.168.0.1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Caso precisemos varrer vários IPs, podemos colocá-los entre vírgulas ou com um traço para fazer a varredura em uma range de IPs.&lt;br /&gt;
Exemplo:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# Sintaxe abaixo escaneia do 192.168.0.1 até 192.168.0.253

nmap -sT -p80 192.168.0.1-253
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;O scan retornará algo do tipo:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;root@root:/home# nmap -sT -p- 192.168.0.13
Starting Nmap 7.60 ( http://nmap.org ) at 2020-02-26 19:56 BRST
mass_dns: warning: Unable to determine any DNS servers. Reverse DNS is disabled. Try using --system-dns or specify valid servers with --dns-servers
Nmap scan report for 192.168.0.13
Host is up (0.00066s latency).
Not shown: 65528 closed ports
PORT   STATE SERVICE
22/tcp   open ssh
80/tcp   open http
111/tcp   open rpcbind
139/tcp   open netbios-ssn
445/tcp   open microsoft-ds
3790/tcp   open quickbooksrds
53668/tcp   open unknown
Nmap done 1 IP address ( 1 host up ) scanned in 3.29 seconds
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Podemos reparar que ao utilizarmos um scan na máquina, obtemos vários serviços com a identificação de portas abertas, e são essas portas que poderemos futuramente atacar.&lt;/p&gt;
</content:encoded><category>redes</category><category>nmap</category><category>tcp</category></item><item><title>O bug aeroespacial</title><link>https://luidiblu.com/posts/o-bug-aeroespacial/</link><guid isPermaLink="true">https://luidiblu.com/posts/o-bug-aeroespacial/</guid><description>A história do Ariane 5 e como uma pequena decisão no software pode ter grandes consequências.</description><pubDate>Thu, 10 Oct 2019 00:00:00 GMT</pubDate><content:encoded>&lt;h2&gt;O bug que explodiu um foguete&lt;/h2&gt;
&lt;p&gt;Explorar o espaço virou uma rotina tão comum, que os avanços tecnológicos feitos não são mais noticiados com tanta ênfase. Só no final de 2018, por exemplo, a NASA conseguiu pousar a sonda Insight em Marte,que agora está atuando como uma base pra estudar seu interior.&lt;/p&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/27ade6cbc6726ef272b9.jpg&quot; alt=&quot;&quot; width=&quot;660&quot; height=&quot;360&quot; loading=&quot;lazy&quot; /&gt;&lt;figcaption&gt;Sonda Insight, em Marte.&lt;/figcaption&gt;&lt;/figure&gt;
&lt;p&gt;Usamos um braço robótico pra colocar um sismômetro no solo de Marte, que não só vai ouvir, mas também medir impactos de asteroides, deslizamentos de terra e terremotos. Saber a frequência e a intensidade de martemotos é algo importantíssimo pra que a gente possa começar a pensar sobre como vamos construir os nossos conjuntos habitacionais por lá em breve.&lt;br /&gt;
Além disso, a Insight cavou um buraco de 5 metros de profundidade durante 3 meses para verificar quanto calor Marte deixa escapar.&lt;/p&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/f927a0cb77109bb50521.jpg&quot; alt=&quot;&quot; width=&quot;602&quot; height=&quot;338&quot; loading=&quot;lazy&quot; /&gt;&lt;figcaption&gt;Ilustração de como a Insight mediu o calor de Marte.&lt;/figcaption&gt;&lt;/figure&gt;
&lt;p&gt;Aqui na terra bastante coisa também aconteceu: a Estação Espacial foi reabastecida com os foguetes da SpaceX, e em Alcântra a Força Aérea Brasileira levou cinco experimentos a 120km de altitude com sucesso. O que não deu muito certo foi a volta do foguete que foi à Estação Espacial, que ao tentar pousar, &lt;a href=&quot;https://www.youtube.com/watch?v=ewxM7_RqBaQ&quot;&gt;&lt;strong&gt;teve um problema em um dos estabilizadores e começou a sair de controle&lt;/strong&gt;&lt;/a&gt;. Devido a uma incrível resistência estrutural e algoritmos de controle, no entanto, o foguete se dirigiu ao mar onde foi então recuperado sem maiores danos.&lt;/p&gt;
&lt;p&gt;Esses acontecimentos, servem como lembrete do quão difícil é explorar o espaço, com coisas inesperadas podendo acontecer a qualquer momento e pelas mais fúteis razões. Nesse texto, vou retratar um caso que aconteceu com a Ariane 5, um foguete que custou 7 bilhões de dólares para ser construído e que &lt;a href=&quot;https://www.youtube.com/watch?v=PK_yguLapgA&quot;&gt;&lt;strong&gt;explodiu após 39 segundos de seu primeiro voo&lt;/strong&gt;&lt;/a&gt;, um prejuízo absurdo, que poderia ter sido salvo com algumas linhas de código a mais.&lt;/p&gt;
&lt;p&gt;Para entender como lidar com falhas inesperadas, vamos começar escrevendo um programinha simples, que irá pegar dois números inteiros e então dividi-los pra nos dar um resultado. Com isso, já temos tudo que precisamos para escrever um método em Java que calcula exatamente isso:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public class Div {

  static int divisao(int a, int b) {
    return (a/b);
  }

  public static void main(String args[]) {
    System.out.println(divisao(25, 5));
    System.out.println(divisao(40, 2));
    System.out.println(divisao(100, 10));
  }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;No código acima, fazemos uma divisão comum, (25 por 5, 40 por 2 e 100 por 10). Como você pode ver, o nosso programa parece estar funcionando. O problema é que esquecemos de certos detalhes! Por exemplo: ao digitar 1 dividido por 2, obtemos 0 ao invés de 0.5 porque a divisão de números inteiros em Java sempre arredonda para baixo.&lt;/p&gt;
&lt;p&gt;Para resolver o problema acima, vamos introduzir no nosso código números flutuantes, que são abreviados como “floats”. Números salvos dessa forma conseguem representar números racionais através do deslocamento do “.” que separa a parte inteira da parte fracionária de um número, usando a notação científica. O código vai ficar assim:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public class Div {

  static float divisao(float a, float b) {
    return (a/b);
  }

  public static void main(String args[]) {
    System.out.println(divisao(25, 5));
    System.out.println(divisao(40, 2));
    System.out.println(divisao(100, 10));
  
    System.out.println(divisao(1, 2));
  }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;No nosso exemplo, o ponto flutua completamente para fora e no lugar é feita uma multiplicação com 10 elevado a -1, nos dando o resultado esperado: 0.5. Aumentamos a precisão dos resultados no nosso programa usando floats. Se você souber como contar em binário, e isso é importante agora no sentido de que quanto mais bits temos para representar um número float, maior será sua precisão também. No momento estamos programando com um float de 32 bits, mas Java nos dá a possibilidade de umsar um “double”, que tem 64.&lt;/p&gt;
&lt;p&gt;Similarmente, existe um tipo de número inteiro chamado “short” (curto, em inglês) que usa 2 bytes ao invés de 4. Transformar um número de um tipo para outro é possivel, mas pode levar a imprevistos que vamos entender agora.&lt;/p&gt;
&lt;p&gt;Como cada bit pode segurar 0 ou 1, dois bytes, 16 bits, servem para descrever 2¹⁶ números distintos. Dividindo essas 65,536 possibilidades por dois, conseguimos descrever valores que vão de -32,768 a 32,767. Simplismente fingimos que números maiores do que isso não existem. Mas se por algum motivo nosso programa retornar um valor maior do que isso, como por exemplo 42 mil, temos que realizar uma operação chamada casting, que pega nosso short de 2 bytes e transforma em um int de 32. Magicamente, temos um novo intervalo muito maior no qual 42 mil se encontra, e seguimos felizes.&lt;br /&gt;
Sem essa operação, nosso número teria estourado os limites estabelecidos, transbordando pra território desconhecido. (chmam isso de overflow)&lt;/p&gt;
&lt;p&gt;Em programação nossa linha númerica na realidade é um círculo, então esses 32,767 + 1 resultariam em -32,768. É por causa desse círculo que fazer o contrário (o casting de 42 mil para um short, no qual ele não cabe) resulta em um número negativo. Os primeiros 32 mil dos 42 mil cabem, e o resto transborda para outra metade negativa do círculo. Uma forma de lidar com isso é com exceções.&lt;/p&gt;
&lt;p&gt;Uma condição da qual não nos protegemos ainda é o que ocorre ao dividir por 0, um erro fatal acontece. Portanto, podemos envolver essas linhas em um bloco que vai tentar executar nosso código, mas se algo der errado, dizer que algo inesperado aconteceu e terminar o programa de forma segura.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public class Div {
    static float divisao(float a, float b) {
        try {
              return (a/b);
        } catch (Exception e) {
            System.out.println(&quot;Deu ruim, você dividiu por 0!&quot;);
            return Integer.MAX_VALUE;
        }
    }

    public static void main(String args[]) {
       System.out.println(divisao(1, 0));
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Agora o nosso programa finalmente funciona da maneira esperada! Esses blocos que cuidam de exceções conseguem nos proteger de diversos bugs, e a falta deles foi em parte responsável pelo acidente da Ariane 5.&lt;/p&gt;
&lt;p&gt;A ideia por trás do desenvolvimento da Ariane 5 pela Agência Espacial Europeia foi substituir a Ariane 4 com um foguete mais potente, capaz de levar cargas muito maiores ao espaço como por exemplo dois satélites de três toneladas cada. Com isso, a Europa estava prestes a se tornar referência na exploração espacial comercial após o investimento de 7 bilhões de dólares (27 bilhões de reais) e 10 anos de pesquisa. Nesse primeiro voo, quatro satélites sem seguro no valor de 500 milhões de dólares estavam sendo levados. A trajetória do voo em si estava sendo controlada por um computador a bordo, que 36.7 segundos após o lançamento pensou que uma correção de curso precisava ser feita devido a dados muito estranhos que o sistema de orientação inercial estava recebendo, vindos de instrumentos como acelerômetros e giroscópios. Esses dados bizarros e impossíveis na realidade eram uma mensagem de erro que foi interpretada como informação válida, o sistema em si tinha caído e estava inoperante.&lt;/p&gt;
&lt;p&gt;Esse desligamento foi causado por um overflow na conversão da velocidade horizontal do foguete (que estava sendo salva em um float de precisão dupla, com 64 bits) para um numero inteiro de 16. Imitando esse mesmo problema no nosso programa com 84 mil dividido por 2, por exemplo, vemos que recebemos esse mesmo resultado absurdo de antes ao invés de 42mil pois o valor simplesmente não cabe em 16 bits.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public class Div {
    static short divisao(double a, double b) {
        return (short) (a/b);
    }

public static void main(String args[]) {
       System.out.println(divisao(84000, 2));
    }
}

#Exemplo do código do foguete
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Essa parte do código do foguete não estava protegida por exceções porque os engenheiros basicamente reaproveitaram o código da Ariane 4, que era fisicamente incapaz de alcançar uma velocidade horizontal tão alta!&lt;/p&gt;
&lt;p&gt;E o pior: esse cálculo todo em si não tinha mais utilidade nenhuma após a decolagem, sua função era de apenas garantir que tudo estava em ordem antes do lançamento. Mas já nas versões anteriores da Ariane os programadores decidiram dar uma tolerância de 40 segundos, para facilitar reinicializações do sistema caso houvesse pequenos atrasos durante a contagem regressiva. Ou seja: durante o desenvolvimento dos foguetes mais antigos, ninguém imaginava que o código fonte seria simplesmente reutilizado nas versões seguintes.&lt;br /&gt;
E os cientistas trabalhando no foguete mais moderno, vendo porçoes de um programa que não é usado, deixaram de testar essa parte mas também não a tiraram porque isso pode causar uma série de problemas adicionais. Com o processador da nave já tão sobrecarregado, para que gastar recursos computacionais cuidando de exceções em trechos que não deviam nem ser executados em primeiro lugar?&lt;/p&gt;
&lt;p&gt;Depois que o sistema desligou, o controle foi repassado a um backup que era completamente redudante por ser uma cópia exata, levando ao mesmo erro meros milissegundos depois. Com isso, o foguete fez uma correção de curso que não era precisa, compensando por um movimento errado que não tinha ocorrido. A partir desse ponto, a Ariane 5 nada mais era do que um míssel com um alvo surpresa. As forças envolvidas começaram a despedaçar o foguete, que então corretamente acionou a rotina de autodestruição devido aos estresses aerodinâmicos que estavam arrancando os propulsores.&lt;/p&gt;
&lt;p&gt;E foi assim que a quatro quilômetros de altitude, sobre os pântanos da Guiana Francesa, o que deve ter sido a queima de fogos de artifício mais cara da história aconteceu.&lt;/p&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/ff51dc60b7335fc20715.png&quot; alt=&quot;&quot; width=&quot;367&quot; height=&quot;241&quot; loading=&quot;lazy&quot; /&gt;&lt;figcaption&gt;“Queima de Fogos” da Ariane 5&lt;/figcaption&gt;&lt;/figure&gt;
&lt;p&gt;Hoje, a Ariane 5 é um dos foguetes mais confiáveis, tendo 97 de seus 102 lançamentos efetivos. Explorar o espaço dá trabalho e é difícil, mas a longo prazo definitivamente vale a pena.&lt;/p&gt;
&lt;p&gt;O maior desafio é fugir do efeito borboleta, que como foi aqui fez com que um pequeno erro, fosse sendo ampliado ao ponto de causar perdas bilionárias.&lt;/p&gt;
&lt;p&gt;Obrigado por ler meu texto!&lt;br /&gt;
Se você chegou aqui, significa que eu te entreti!&lt;br /&gt;
Não fique com medo de me mandar um email!&lt;br /&gt;
diego.luidiblu@gmail.com&lt;/p&gt;
</content:encoded><category>engenharia</category><category>ariane-5</category></item><item><title>Identificando dispositivos na rede.</title><link>https://luidiblu.com/posts/identificando-dispositivos-na-rede/</link><guid isPermaLink="true">https://luidiblu.com/posts/identificando-dispositivos-na-rede/</guid><description>Endereços IP, gateway e a descoberta de dispositivos conectados à sua própria rede.</description><pubDate>Thu, 15 Aug 2019 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Você já teve a curiosidade de listar dispositivos que estão conectados na sua rede?&lt;/p&gt;
&lt;h2&gt;Requisitos&lt;/h2&gt;
&lt;p&gt;Para listarmos, precisamos utilizar o &lt;a href=&quot;https://github.com/nmap/nmap&quot;&gt;&lt;strong&gt;&lt;em&gt;nmap&lt;/em&gt;&lt;/strong&gt;&lt;/a&gt;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;sudo apt-get install nmap
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;Gateway Padrão&lt;/h2&gt;
&lt;p&gt;Precisamos ter o endereço do &lt;a href=&quot;https://pt.wikipedia.org/wiki/Gateway&quot;&gt;&lt;strong&gt;&lt;em&gt;gateway&lt;/em&gt;&lt;/strong&gt;&lt;/a&gt; padrão. Caso você não saiba seu gateway padrão, basta digitamos:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;route -n
&lt;/code&gt;&lt;/pre&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/c6af49366424f698b774.png&quot; alt=&quot;&quot; width=&quot;347&quot; height=&quot;154&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;p&gt;Na primeira linha, ele lista o gateway padrão.&lt;br /&gt;
No caso do exemplo: 192.168.0.1&lt;/p&gt;
&lt;h2&gt;Utilizando nmap&lt;/h2&gt;
&lt;p&gt;Com o gateway padrão em mãos, podemos utilizar o nmap!&lt;br /&gt;
Utilizando o comando:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;nmap -sP (seuGatewayPadrao)/24
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;E então seu terminal vai te retornar uma lista com todos os ips conectados na sua rede :)&lt;/p&gt;
</content:encoded><category>redes</category><category>enderecos-ip</category></item><item><title>Criando gemas em Ruby</title><link>https://luidiblu.com/posts/criando-gemas-em-ruby/</link><guid isPermaLink="true">https://luidiblu.com/posts/criando-gemas-em-ruby/</guid><description>Um tutorial sobre a estrutura, o gemspec, a construção e a publicação de uma gem Ruby.</description><pubDate>Wed, 31 Jul 2019 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Já teve problemas ao pensar em como criar gemas e colocá-las open-source? Então este é artigo é pra você! :D&lt;/p&gt;
&lt;p&gt;Estudando bastante sobre algumas gemas que executam funções mais específicas, entendi que qualquer pessoa da comunidade pode criar uma gem. Segue um tutorial:&lt;/p&gt;
&lt;h2&gt;Requisitos&lt;/h2&gt;
&lt;p&gt;Para criar sua Gem, precisamos de algumas ferramentas:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Sublime Text — &lt;a href=&quot;https://www.sublimetext.com/&quot;&gt;https://www.sublimetext.com/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;Ruby — &lt;a href=&quot;https://www.ruby-lang.org/pt/&quot;&gt;https://www.ruby-lang.org/pt/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;Git — &lt;a href=&quot;https://git-scm.com/downloads&quot;&gt;https://git-scm.com/downloads&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;RubyGems — &lt;a href=&quot;https://rubygems.org/&quot;&gt;https://rubygems.org/&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;Estrutura Inicial do projeto&lt;/h2&gt;
&lt;p&gt;Crie uma pasta com o nome da sua &lt;strong&gt;sua_gem&lt;/strong&gt;, em seguida dê um touch em um arquivo &lt;strong&gt;.gemspec&lt;/strong&gt;. Depois, dentro da sua &lt;strong&gt;lib&lt;/strong&gt;, crie uma o arquivo &lt;strong&gt;.rb&lt;/strong&gt; da &lt;strong&gt;sua_gem&lt;/strong&gt;. Seu arquivo precisa ficar desse jeito:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;sua_gem
├── sua_gem.gemspec
└── lib
     └── sua_gem.rb
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;Criação da gema&lt;/h2&gt;
&lt;p&gt;Dentro da &lt;strong&gt;sua_gem.rb&lt;/strong&gt; vamos codar as respectivas funções da gema, no meu caso, minha gema vai me devolver uma string “Minha primeira gem!”:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# lib/sua_gem.rb
class sua_gem
  def self.hello
   puts &quot;Minha primeira gem!&quot;
  end
end
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;Configurando o gemspec&lt;/h2&gt;
&lt;p&gt;Depois de codar a &lt;strong&gt;sua_gem.rb&lt;/strong&gt;, vamos configurar o &lt;strong&gt;.gemspec&lt;/strong&gt; da &lt;strong&gt;sua_gem&lt;/strong&gt;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# sua_gem.gemspec
Gem::Specification.new do |s|
 s.name        = &apos;sua_gem&apos;
 s.version     = &apos;0.0.0&apos;
 s.date        = &apos;2019-07-01&apos;
 s.summary     = &quot;Primeira versão da sua gem!&quot;
 s.description = &quot;Minha primeira gem que eu codei&quot;
 s.authors     = [&quot;Alan Turing&quot;]
 s.email       = &apos;alan@turing.com&apos;
 s.files       = [&quot;lib/sua_gem.rb&quot;]
 s.homepage    = &apos;https://github.com/username/gem&apos;
 s.license     = &apos;MIT&apos;
end
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Tendo em mente que:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;name = Nome da sua gem&lt;/li&gt;
&lt;li&gt;version = Versão da sua gem&lt;/li&gt;
&lt;li&gt;date = Data de modificação da sua gem&lt;/li&gt;
&lt;li&gt;summary = Sumário da sua gem&lt;/li&gt;
&lt;li&gt;description= Descrição da sua gem&lt;/li&gt;
&lt;li&gt;authors = Autores da gem&lt;/li&gt;
&lt;li&gt;email = email do(a) proprietário(a) da gem&lt;/li&gt;
&lt;li&gt;files = Path da sua gem (onde você alocou seu arquivo.rb)&lt;/li&gt;
&lt;li&gt;homepage = Onde sua gem foi upada (GitBucket também)&lt;/li&gt;
&lt;li&gt;license = Licensa da sua gema (você pode achar licensas de gemas na internet, no caso, eu usei ‘MIT’)&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;Pronto para publicar&lt;/h2&gt;
&lt;p&gt;No ponto atual, podemos utilizar nosso código, porém nossos amiguinhos ainda não podem instalar a nossa gem.&lt;br /&gt;
Para outros programadores poderem usar a gema, você precisa executar alguns comandos:&lt;/p&gt;
&lt;p&gt;Primeiro precisamos upar nosso código open-source:&lt;br /&gt;
&lt;em&gt;Github:&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;git init
hub create
git add . 
git commit -m &quot;My first gem&quot; 
git push origin master
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Em seguida, precisamos criar uma conta no site &lt;a href=&quot;https://rubygems.org/&quot;&gt;&lt;em&gt;RubyGems&lt;/em&gt;&lt;/a&gt;.&lt;/p&gt;
&lt;figure&gt;&lt;img src=&quot;/images/articles/031aa1b35a4de3669de9.webp&quot; alt=&quot;&quot; width=&quot;887&quot; height=&quot;415&quot; loading=&quot;lazy&quot; /&gt;&lt;figcaption&gt;Print do site RubyGems&lt;/figcaption&gt;&lt;/figure&gt;
&lt;p&gt;Para fazer o setup do RubyGems com o seu computador, precisamos executar o seguinte comando (o comando vai te pedir sua senha do RubyGems):&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;curl -u (seu-rubygems-nick) https://rubygems.org/api/v1/api_key.yaml
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;E no final, construir nossa gema utilizamos um pequeno código no terminal:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;gem build sua_gema.gemspec
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Agora para verificar sua gem funcionando, você pode achar a gem no RubyGems! c:&lt;/p&gt;
&lt;h2&gt;Conclusão&lt;/h2&gt;
&lt;p&gt;Agora, aprendemos de forma simples e segura de como criar uma gem! Não perca a oportunidade de tirar suas dúvidas ou deixar uma sugestão aí nos comentarios :)&lt;/p&gt;
&lt;p&gt;Thanks!&lt;/p&gt;
</content:encoded><category>ruby</category><category>gemspec</category></item></channel></rss>