Alphasub

Alphasub é uma cifra monoalfabética personalizada criada por *nacr0*. A cifra gera um alfabeto de substituição único a partir de uma chave (Key 1) usando multiplicações sequenciais da posição alfabética de cada letra, regras de colisão e um loop cíclico sobre a chave.

Sumário

Visão geral
Geração do alfabeto
Regras
Codificação / Decodificação
Exemplo
Implementação (Python)
Referências e notas

Visão geral

Alphasub cria uma permutação determinística do alfabeto (a–z). A segurança e singularidade da cifra vêm do método não convencional de geração do alfabeto, que não corresponde a cifras clássicas conhecidas (César, Vigenère, Playfair, etc.).

Geração do alfabeto

Receba **Key 1** (a chave do alfabeto). Normalize removendo acentos e caracteres não-alfabéticos e converta para minúsculas.
Remova duplicatas enquanto preserva a ordem. Esse conjunto inicial forma o *prefixo* do alfabeto substitutivo.
Percorra a chave em loop infinito; para cada letra da chave:
- Converta a letra para sua posição no alfabeto: a=1, b=2, …, z=26.
- Calcule a posição candidata começando em ×2 (isto é, posição × 2).
- Aplique wrap: se a posição > 26, subtraia 26 até caber (≈ modulo 26).
- Converta a posição em letra. Se a letra NÃO estiver no alfabeto atual, adicione-a.
- Se a letra já existir, aumente o multiplicador (×3, ×4, ×5, …), sempre multiplicando pela **posição original** (não encadeando), aplicando wrap cada vez, até encontrar uma letra livre.
- Avance sempre para a próxima letra da chave (mesmo se nenhuma multiplicação gerou nova letra nesta tentativa). Se for impossível gerar letra nova com todas as multiplicações (após tentativas suficientes), pule essa letra da chave.
Continue até completar 26 letras ou até não ser possível progredir; em último caso, preencha com letras que faltam em ordem alfabética.

Regras (resumidas)

Inicie sempre com multiplicador ×2; só aumente (×3, ×4, ...) se houver colisão.
Ao aumentar multiplicadores, sempre multiplique a **posição original** da letra.
Use wrap para manter valores dentro de 1–26.
A chave (Key 1) é percorrida em loop e você **avança na chave** mesmo quando não adiciona letra.
Pule uma letra da chave somente se TODAS as multiplicações possíveis não gerarem letra inédita.

Codificação / Decodificação

**Codificar (plain → keyed):** gere o alfabeto com Key 1 e substitua cada letra do texto pela correspondente no alfabeto gerado. Preserve espaços, pontuação e (opcionalmente) a capitalização.
**Decodificar (keyed → plain):** gere o alfabeto com Key 1 e inverta o mapeamento (keyed→plain).

Exemplo (ilustrativo)

Key 1: cobra; Prefixo inicial — c o b r a; (continua o processo até gerar as 26 letras; resultado dependente das regras exatas)

Implementação (Python)

# Lê a primeira chave (Key 1) e converte para minúsculas
key = input('digite a 1° chave: ').lower()

# Alfabeto base
a = ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 
     'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z')

# tkey = chave temporária que guardará a versão sem duplicatas
tkey = ''

# Remove letras repetidas da chave original
for l in key:
    if l.isalpha and l not in tkey:   # só adiciona se for letra e não repetida
        tkey += l

# A chave final sem duplicatas substitui a original
key = tkey
del(tkey)  # apaga variável temporária

# 'na' será o dicionário final: mapeia plain → keyed
na = {}

# 'alk' é o índice que percorre a chave em loop infinito
alk = 0

# Percorre cada letra do alfabeto base
for l in a:

    # Primeira fase: colocar o prefixo inicial (letras da chave)
    if a.index(l) < len(key):
        i = a.index(l)
        na[a[i]] = key[alk]  # mapeia plain para a letra da chave
        i += 1
        alk += 1             # avança na chave
        continue

    # Segunda fase: multiplicações (×2, ×3, ... ×26)
    for m in range(2, 27):   # multiplicador começa em 2 até 26

        # Reinicia o índice da chave se passar do tamanho → loop infinito
        if alk >= len(key):
            alk = 0

        # Posição da letra da chave (1–26), convertida para índice (0–25)
        al = ((a.index(key[alk]) + 1) * m) - 1

        # Wrap: garante que fique dentro de 0–25
        while al > 25:
            al %= 26

        # Letra candidata após multiplicação
        nl = a[al]

        # Se ainda não está sendo usada no alfabeto resultante:
        if nl not in na.values():
            na[l] = nl    # adiciona mapeamento
            alk += 1      # avança na chave, mesmo quando aceita
            break          # para as multiplicações (próxima letra)
        # Se já existe, o loop continua com próximo multiplicador (×3, ×4...)

# Exibe os valores do dicionário final (o alfabeto gerado)
print(na.values())

input

digite a 1° chave: cobra

output

['c', 'o', 'b', 'r', 'a', 'f', 'd', 'h', 'j', 'e', 'i', 's', 'l', 't', 'g', 'u', 'w', 'n', 'v', 'k', 'x', 'p', 'z']

Referências e notas

Criador: nacr0
Nome: Alphasub (anteriormente ChainSub)
Observação: projeto original de cifra criada pelo autor; ver também implementações públicas.

Diagrama / código ilustrativo