MR. ROBOT HACKS: BUILDING A DEADMAN’S SWITCH COM PYTHON

Resumo

Este artigo demonstra como criar um Deadman’s Switch em Python, mecanismo de segurança que executa uma ação caso o usuário não realize uma confirmação periódica. Inspirado no uso feito por Elliot em Mr. Robot, o tutorial aborda os conceitos, o fluxo de funcionamento, o código necessário com threading e requests, e as boas práticas de segurança.

O que é um Deadman’s Switch?

Um Deadman’s Switch é um dispositivo de segurança que aciona uma determinada ação quando o operador deixa de realizar uma ação de confirmação dentro de um intervalo de tempo pré‑definido. Ele parte do princípio de que a ausência de atividade indica incapacidade ou morte do operador, disparando assim uma resposta de emergência. Exemplos clássicos incluem máquinas industriais, locomotivas e até coletes explosivos, onde o interruptor só permanece desarmado enquanto o usuário o mantém ativo.

O contexto em Mr. Robot

Na primeira temporada de Mr. Robot, Elliot Alderson utiliza um Deadman’s Switch digital para se proteger do traficante Vera, que mantém sua amiga Shayla refém. Elliot explica que, caso algo lhe aconteça, um programa enviará as provas coletadas contra Vera às autoridades. Essa narrativa serve como pano de fundo para explorar a implementação técnica do conceito em Python.

Como o Deadman’s Switch funciona

O fluxo básico é:

1. O usuário define um timeout (tempo máximo de inatividade).
2. Um temporizador é iniciado.
3. Enquanto o usuário confirma presença (por exemplo, pressionando Enter) antes do timeout expirar, o temporizador é cancelado e reiniciado.
4. Se o timeout for atingido sem confirmação, a ação configurada é executada (no exemplo, o envio de uma mensagem SMS).
5. O loop continua, permitindo que o Deadman’s Switch permaneça ativo até que o usuário decida encerrar o programa.

Preparando o projeto em Python

Para construir o Deadman’s Switch utilizaremos duas bibliotecas padrão do ecossistema Python:

• threading: permite a execução concorrente de threads, essencial para criar um temporizador que não bloqueie a entrada do usuário.
• requests: biblioteca simples e poderosa para fazer requisições HTTP, utilizada aqui para enviar a mensagem SMS via serviço Textbelt.

Ambas estão disponíveis via pip e já vêm instaladas em muitas distribuições; caso contrário, basta instalar com pip install requests (threading vem com a biblioteca padrão).

Criando a função de ação

A função action() é responsável por executar a tarefa quando o timeout ocorre. No exemplo original, ela envia uma mensagem SMS através do endpoint público do Textbelt. Veja o código:

import requests\n\ndef action():\n    payload = {\n        'phone': '',  # placeholder\n        'message': 'Alerta: Deadman’s Switch acionado. Verificar situação.',\n        'key': ''   # placeholder\n    }\n    response = requests.post('https://textbelt.com/text', data=payload)\n    print(response.json())

Objetivo: disparar a notificação quando o usuário não confirmar presença.

Parâmetros explicados:

• phone: número de telefone destinatário no formato internacional.
• message: texto da mensagem a ser enviada.
• key: chave de acesso fornecida pelo Textbelt (use a chave gratuita textbelt para testes ou uma chave própria).
• requests.post: envia os dados como application/x-www-form-urlencoded.

A resposta é um JSON contendo success, textId e possivelmente error.

Criando o temporizador

O temporizador é implementado com threading.Timer. Essa classe permite agendar a execução de uma função após um determinado intervalo, running em uma thread separada. Seu funcionamento:

• Instanciado com threading.Timer(interval, function).
• O método start() inicia a contagem.
• Se confirmarmos presença antes do término, chamamos cancel() para impedir a execução da função.

Exemplo de uso dentro de wait_for_input():

import threading\n\ndef wait_for_input(timeout):\n    timer = threading.Timer(timeout, action)\n    timer.start()\n    try:\n        input(f"Press Enter within {timeout} seconds to reset the deadman’s switch: ")\n        timer.cancel()\n        return True\n    except Exception:\n        timer.cancel()\n        return False

O que cada parte faz:

• threading.Timer(timeout, action) cria o temporizador que chamará action() após timeout segundos.
• timer.start() inicia a contagem.
• input() bloqueia aguardando a tecla Enter.
• timer.cancel() interrompe o temporizador se o usuário responder a tempo.
• A função retorna True se recebeu input, False se o timeout ocorreu.

Criando “wait_for_input()”

A função wait_for_input() engloba a lógica de aguardar a confirmação do usuário com timeout. Ela retorna um booleano indicando se o input foi recebido (True) ou se o tempo esgotou (False). Essa retornada é utilizada no laço principal para decidir se continuamos ou acionamos o Deadman’s Switch. O tratamento de exceção garante que, mesmo caso ocorra algum erro inesperado durante a entrada, o temporizador seja cancelado e a função retorne False, evitando deixar threads órfãs.

Criando a função principal

A função main() orquestra o programa:

1. Solicita ao usuário o timeout em segundos.
2. Exibe uma mensagem informando que o Deadman’s Switch está ativo.
3. Entra em um laço infinito que chama wait_for_input(timeout).
4. Se a função retornar False (timeout), o laço é interrompido via break; caso contrário, o ciclo se repete.

\ndef main():\n    timeout = int(input("Enter the length of timeout in seconds: "))\n    print("Deadman’s switch activated. Press Enter regularly to keep it alive.")\n    while True:\n        if not wait_for_input(timeout):\n            break

Esse design permite que o usuário mantenha o switch ativo indefinidamente, desde que continue confirmando presença dentro do intervalo definido.

“if __name__ == \”__main__\””

O bloco

if __name__ == "__main__":\n    main()

garante que a função main() seja executada apenas quando o script for rodado diretamente, e não quando importado como módulo por outro script. Esse padrão é considerado boa prática em Python, pois permite reutilizar o código em outros projetos sem acionar acidentalmente o laço principal.

Permissão e execução

Antes de rodar o script, é necessário torná‑lo executável. No terminal, use:

chmod 755 deadmans_switch.py

O chmod 755 concede permissão de leitura, escrita e execução ao dono, e leitura e execução ao grupo e aos demais usuários. Depois disso, execute com:

./deadmans_switch.py

ou

python3 deadmans_switch.py

Lembre‑se de substituir os placeholders e por valores reais em um ambiente controlado e autorizado.

Como o fluxo completo funciona

O ciclo completo pode ser resumido assim:

INÍCIO\n↓\ndefine timeout\n↓\nativa temporizador\n↓\navalida confirmação\n↓\nconfirmação recebida?\n   SIM → cancela/reinicia temporizador → volta ao início\n   NÃO → timeout expirou → executa ação configurada → fim

Enquanto o usuário continuar interagindo, o temporizador é constantemente reiniciado. Só quando houver falha na confirmação dentro do prazo é que a ação é disparada. Essa lógica torna o Deadman’s Switch um mecanismo confiável para situações em que se deseja garantir uma resposta automática à inatividade prolongada.

Considerações de segurança

Embora o exemplo utilize um serviço público de SMS (Textbelt), em aplicações reais você deve:

• Utilizar credenciais próprias e protegidas (variáveis de ambiente ou cofres de secrets).
• Restringir o uso a números de telefone controlados e em ambientes autorizados.
• Preferir serviços empresariais ou APIs internas para notificações críticas.
• Nunca hard‑codar chaves de API ou números de telefone no fonte; carregue‑as de variáveis de ambiente.
• Testar em ambiente isolado antes de implantar em produção.
• Auditorar o acesso ao script e garantir que apenas usuários confiáveis possam modificá‑lo.

Seguindo essas práticas, o Deadman’s Switch pode ser empregado como recurso de segurança legítimo, por exemplo para acionar alertas de falta de resposta em sistemas de monitoramento.

Conclusão

Este artigo mostrou como construir um Deadman’s Switch em Python usando apenas threading e requests. Ao entender o conceito, o fluxo de funcionamento e as boas práticas de implementação, você pode adaptar o mecanismo para diversos cenários de segurança e automação, sempre ressaltando a importância de usar credenciais seguras e ambientes controlados. O exemplo inspirado em Mr. Robot serve como ponto de partida para explorar técnicas de deteção de inatividade e resposta automática em Python.