CÉLULA 0 — Cabeçalho e Sumário Executivo¶

CIP — Demonstração de Interoperabilidade Espectral entre SDKs (IDX 18 / IDX 20)¶

Este notebook demonstra, de forma pública e reprodutível, a reprodutibilidade e a interoperabilidade do protocolo CIP
entre ambientes distintos (Linux ↔ Windows). Os experimentos apresentados confirmam que a CIP preserva coerência espectral e
compatibilidade operacional mesmo quando um arquivo é cifrado em um ambiente e decifrado em outro, utilizando apenas as
informações registradas na própria chave CIP-T.

A demonstração evidencia que o protocolo opera de modo determinístico, independente do sistema operacional, compilador ou
biblioteca local — desde que a régua aritmética pública (IDX) seja respeitada.

Este notebook utiliza dois SDKs oficiais:

  • SDK Linux — IDX 18
  • SDK Windows — IDX 20

Ambos assinaram o mesmo arquivo em modo TOTAL (-t). O objetivo é demonstrar que:

  1. Um único arquivo, assinado por dois SDKs distintos, gera chaves diferentes;
  2. O mesmo binário CIP (da máquina que executa o notebook) é capaz de:
    • validar com a chave do SDK Linux (IDX 18);
    • validar com a chave do SDK Windows (IDX 20);
  3. A decisão de integridade não depende:
    • do sistema operacional de origem,
    • do SDK que realizou a assinatura,
    • nem do compilador utilizado;
  4. Uma alteração mínima (1 bit) no arquivo faz com que ambas as chaves falhem;
  5. A interoperabilidade decorre diretamente da régua espectral única, e não de ajustes específicos de implementação.

Este notebook não recompila SDKs nem gera novas assinaturas. Ele replica um cenário realista: SDKs já distribuídos e chaves já emitidas,
verificando a coerência pública do protocolo CIP.

CÉLULA 1 — Imports, detecção de SO e configuração básica¶

Aqui vamos seguir a mesma linha do notebook anterior: detectar SO, definir diretórios e preparar utilitários.

In [1]:
# ============================================================
# CÉLULA 1 — Configuração básica de ambiente
# ============================================================

import os
import stat
import shutil
import zipfile
import subprocess
import time
import random

from pathlib import Path

import pandas as pd
import matplotlib.pyplot as plt
from tqdm import tqdm

# Diretório base (local do notebook)
BASE_DIR = Path.cwd()
print(f"[INFO] Diretório base do notebook: {BASE_DIR}")

# Sistema operacional
WINDOWS = os.name == "nt"
print(f"[INFO] Sistema detectado: {'Windows' if WINDOWS else 'Linux'}")

# ------------------------------------------------------------
# Estrutura de diretórios do experimento
# ------------------------------------------------------------
SDK_DIR        = BASE_DIR / "sdk_local"          # onde o SDK nativo será extraído
CHAVES_DIR     = BASE_DIR / "chaves_interop"     # onde colocaremos as duas chaves (Linux/Windows)
ARQUIVOS_DIR   = BASE_DIR / "arquivos"           # onde ficará o arquivo de teste
RESULTADOS_DIR = BASE_DIR / "resultados"         # para tabelas e artefatos

for d in [SDK_DIR, CHAVES_DIR, ARQUIVOS_DIR, RESULTADOS_DIR]:
    d.mkdir(exist_ok=True)
    print(f"[OK] Diretório garantido: {d}")

# Limite de segurança para tamanho de arquivo (1 GB)
LIMITE_BYTES = 1_000_000_000
print(f"[INFO] Limite de tamanho de arquivo: {LIMITE_BYTES/1e6:.1f} MB")

[INFO] Diretório base do notebook: /home/alvaro/cip_demo
[INFO] Sistema detectado: Linux
[OK] Diretório garantido: /home/alvaro/cip_demo/sdk_local
[OK] Diretório garantido: /home/alvaro/cip_demo/chaves_interop
[OK] Diretório garantido: /home/alvaro/cip_demo/arquivos
[OK] Diretório garantido: /home/alvaro/cip_demo/resultados
[INFO] Limite de tamanho de arquivo: 1000.0 MB

CÉLULA 2 — Download (ou uso local) do SDK nativo¶

Aqui vamos assumir que, para o notebook de interoperabilidade, você vai disponibilizar um SDK nativo único:

Se o usuário estiver em Linux → cip-sdk-linux-idx18.zip

Se estiver em Windows → cip-sdk-windows-idx20.zip

A interoperabilidade conceptual não depende de qual é o “nativo”; o foco é: um binário local verificando chaves de SDKs distintos.

In [2]:
# ============================================================
# CÉLULA 2 — Download e extração do SDK nativo
# ============================================================

# Aqui definimos o ZIP esperado de acordo com o sistema
if WINDOWS:
    ZIP_NAME = "cip-sdk-windows-idx20.zip"
    SDK_FOLDER_NAME = "cip-sdk-windows-idx20"
    DOWNLOAD_URL = "https://delta-cip.com.br/downloads/cip-sdk-windows-idx20.zip"
else:
    ZIP_NAME = "cip-sdk-linux-idx18.zip"
    SDK_FOLDER_NAME = "cip-sdk-linux-idx18"
    DOWNLOAD_URL = "https://delta-cip.com.br/downloads/cip-sdk-linux-idx18.zip"

ZIP_PATH = BASE_DIR / ZIP_NAME
SDK_FOLDER_PATH = SDK_DIR / SDK_FOLDER_NAME

print(f"[INFO] ZIP esperado: {ZIP_NAME}")
print(f"[INFO] Pasta local do SDK: {SDK_FOLDER_PATH}")

# ------------------------------------------------------------
# 1. Se a pasta do SDK já existir, usamos diretamente
# ------------------------------------------------------------
if SDK_FOLDER_PATH.exists():
    print(f"[OK] SDK já disponível em: {SDK_FOLDER_PATH}")
else:
    # --------------------------------------------------------
    # 2. Se o ZIP não existir localmente, baixamos
    # --------------------------------------------------------
    if not ZIP_PATH.exists():
        import requests

        print(f"[INFO] Baixando SDK a partir de:\n{DOWNLOAD_URL}\n")
        with requests.get(DOWNLOAD_URL, stream=True) as r:
            r.raise_for_status()
            with open(ZIP_PATH, "wb") as f:
                for chunk in r.iter_content(chunk_size=8192):
                    if chunk:
                        f.write(chunk)
        print(f"[OK] Download concluído: {ZIP_PATH}")
    else:
        print(f"[OK] ZIP encontrado localmente: {ZIP_PATH}")

    # --------------------------------------------------------
    # 3. Extração do SDK
    # --------------------------------------------------------
    print(f"[INFO] Extraindo SDK para: {SDK_FOLDER_PATH}")
    SDK_FOLDER_PATH.mkdir(parents=True, exist_ok=True)
    with zipfile.ZipFile(ZIP_PATH, "r") as z:
        z.extractall(SDK_FOLDER_PATH)

    print("[OK] SDK extraído com sucesso.")

# ------------------------------------------------------------
# 4. Localizar o binário nativo da CIP
# ------------------------------------------------------------
if WINDOWS:
    CIP_BIN = SDK_FOLDER_PATH / "bin" / "cip.exe"
else:
    CIP_BIN = SDK_FOLDER_PATH / "bin" / "cip"

if not CIP_BIN.exists():
    raise FileNotFoundError(f"[ERRO] Binário CIP não encontrado em: {CIP_BIN}")

# Garantir permissão de execução no Linux
if not WINDOWS:
    st = os.stat(CIP_BIN)
    os.chmod(CIP_BIN, st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)

print(f"[OK] Binário CIP localizado em: {CIP_BIN}")

[INFO] ZIP esperado: cip-sdk-linux-idx18.zip
[INFO] Pasta local do SDK: /home/alvaro/cip_demo/sdk_local/cip-sdk-linux-idx18
[OK] SDK já disponível em: /home/alvaro/cip_demo/sdk_local/cip-sdk-linux-idx18
[OK] Binário CIP localizado em: /home/alvaro/cip_demo/sdk_local/cip-sdk-linux-idx18/bin/cip

CÉLULA 3 — Função utilitária run_cip e explicação da lógica de interoperabilidade¶

Aqui copiamos a função run_cip (como no notebook 1) e já deixamos explicado que vamos usar um único binário para verificar duas chaves geradas por SDKs com IDX distintos.

In [3]:
# ============================================================
# CÉLULA 3 — Utilitário para executar o binário CIP
# ============================================================

def run_cip(args):
    """
    Executa o binário CIP com os argumentos dados,
    medindo tempo de execução e capturando stdout/stderr.
    """
    inicio = time.time()
    proc = subprocess.run(
        [str(CIP_BIN)] + args,
        cwd=SDK_FOLDER_PATH,
        capture_output=True,
        text=True,
        encoding="utf-8",
        errors="replace",
    )
    duracao = time.time() - inicio
    return proc, duracao

print("[OK] Função run_cip configurada.")

print(
    "\nNeste notebook, usaremos **um único binário CIP nativo** "
    "para verificar chaves geradas por SDKs distintos (IDX 18 e IDX 20)."
)
print(
    "A lógica de interoperabilidade é simples: se o arquivo permanece idêntico, "
    "qualquer SDK compatível com a régua espectral única deve validar a integridade."
)

[OK] Função run_cip configurada.

Neste notebook, usaremos **um único binário CIP nativo** para verificar chaves geradas por SDKs distintos (IDX 18 e IDX 20).
A lógica de interoperabilidade é simples: se o arquivo permanece idêntico, qualquer SDK compatível com a régua espectral única deve validar a integridade.

CÉLULA 4 — Download do arquivo de teste + cópia local das duas chaves com tqdm¶

In [4]:
# ============================================================
# CÉLULA 4 — Download NOAA + Chaves (IDX 18 / IDX 20) com tqdm
# ============================================================

import requests
from tqdm import tqdm

# URLs públicas do site
BASE_URL = "https://delta-cip.com.br/downloads"

ARQ_REMOTE            = f"{BASE_URL}/noaa_gsod_2023.tar.gz"
CHAVE_LINUX_REMOTE   = f"{BASE_URL}/chave_cipt_assinado_idx18_N1024_20251124_115945.json"
CHAVE_WINDOWS_REMOTE = f"{BASE_URL}/chave_cipt_assinado_idx20_N1024_20251124_120307.json"

ARQ_LOCAL            = ARQUIVOS_DIR / "noaa_gsod_2023.tar.gz"
CHAVE_LINUX_LOCAL    = CHAVES_DIR   / "chave_idx18_linux.json"
CHAVE_WINDOWS_LOCAL  = CHAVES_DIR   / "chave_idx20_windows.json"

# ------------------------------------------------------------
# Função com tqdm
# ------------------------------------------------------------
def baixar_com_progresso(url: str, destino: Path):
    """
    Faz download com barra de progresso.
    Não baixa novamente se o arquivo já existir.
    """
    if destino.exists() and destino.stat().st_size > 0:
        print(f"[OK] Já existe localmente: {destino} ({destino.stat().st_size/1e6:.2f} MB)")
        return

    print(f"[INFO] Baixando: {url}")

    with requests.get(url, stream=True) as r:
        r.raise_for_status()

        total = int(r.headers.get("content-length", 0))
        blocos = 8192

        # barra de progresso
        barra = tqdm(total=total, unit="B", unit_scale=True, desc=destino.name)

        with open(destino, "wb") as f:
            for chunk in r.iter_content(chunk_size=blocos):
                if chunk:
                    f.write(chunk)
                    barra.update(len(chunk))

        barra.close()

    print(f"[OK] Download concluído: {destino} ({destino.stat().st_size/1e6:.2f} MB)")


# ------------------------------------------------------------
# Baixar arquivo NOAA + chaves
# ------------------------------------------------------------
baixar_com_progresso(ARQ_REMOTE, ARQ_LOCAL)
baixar_com_progresso(CHAVE_LINUX_REMOTE, CHAVE_LINUX_LOCAL)
baixar_com_progresso(CHAVE_WINDOWS_REMOTE, CHAVE_WINDOWS_LOCAL)

print("\n[OK] Arquivo e chaves importados para o notebook:")
print(f"  - Arquivo NOAA............: {ARQ_LOCAL}")
print(f"  - Chave Linux (IDX 18)....: {CHAVE_LINUX_LOCAL}")
print(f"  - Chave Windows (IDX 20)..: {CHAVE_WINDOWS_LOCAL}")

# Segurança básica: tamanho
tamanho_bytes = ARQ_LOCAL.stat().st_size
print(f"\nTamanho do arquivo NOAA: {tamanho_bytes/1e6:.2f} MB")

if tamanho_bytes == 0 or tamanho_bytes > LIMITE_BYTES:
    raise RuntimeError("Arquivo ausente, corrompido ou fora do limite permitido.")

[OK] Já existe localmente: /home/alvaro/cip_demo/arquivos/noaa_gsod_2023.tar.gz (108.78 MB)
[OK] Já existe localmente: /home/alvaro/cip_demo/chaves_interop/chave_idx18_linux.json (0.09 MB)
[OK] Já existe localmente: /home/alvaro/cip_demo/chaves_interop/chave_idx20_windows.json (0.09 MB)

[OK] Arquivo e chaves importados para o notebook:
  - Arquivo NOAA............: /home/alvaro/cip_demo/arquivos/noaa_gsod_2023.tar.gz
  - Chave Linux (IDX 18)....: /home/alvaro/cip_demo/chaves_interop/chave_idx18_linux.json
  - Chave Windows (IDX 20)..: /home/alvaro/cip_demo/chaves_interop/chave_idx20_windows.json

Tamanho do arquivo NOAA: 108.78 MB

CÉLULA 5 — Carregar / exibir metadados essenciais das chaves¶

Esta célula mostra para o usuário que:

as chaves correspondem ao mesmo arquivo,

porém foram emitidas por SDKs diferentes,

com IDX distintos,

e que isso não é problema para a interoperabilidade.

In [5]:
# ============================================================
# CÉLULA — Inspeção das chaves IDX 18 (Linux) e IDX 20 (Windows)
# ============================================================

import json

def carregar_json(p):
    with open(p, "r", encoding="utf-8") as f:
        return json.load(f)

def extrair_hash_v3(chave):
    """
    Versão robusta: extrai o hash de integridade das chaves v3 híbridas.
    """
    campos = [
        "assinatura_integridade_final",
        "assinatura_integridade_chave_cipt",
    ]
    for c in campos:
        if c in chave and chave[c]:
            return chave[c]
    return None

def resumo_v3(chave, nome):
    print(f"[{nome}]")
    print(f"  - idx.............: {chave.get('sdk_idx_usado')}")
    print(f"  - N (dimensões)...: {chave.get('matrix_size_N_usado')}")
    print(f"  - arquivo..........: {chave.get('arquivo_original_nome')}")
    print(f"  - operação.........: {chave.get('operacao')}")
    print(f"  - data/hora........: {chave.get('timestamp_operacao_str')}")

    h = extrair_hash_v3(chave)
    if h:
        print(f"  - hash_integridade.: {h[:32]}...")
    else:
        print("  - hash_integridade.: [não encontrado]")

    # segurança: exibe presença da matriz P (não imprime)
    print(f"  - matriz_p........: {'OK' if chave.get('matriz_p_base64') else 'ausente'}")
    print()


# Carregar chaves locais baixadas
ch18 = carregar_json(CHAVE_LINUX_LOCAL)
ch20 = carregar_json(CHAVE_WINDOWS_LOCAL)

print("=== INSPEÇÃO DAS CHAVES — CIP-T v3 HÍBRIDO ===\n")

resumo_v3(ch18, "Chave Linux IDX 18")
resumo_v3(ch20, "Chave Windows IDX 20")

print(
    "Ambas as chaves foram produzidas sobre o MESMO arquivo NOAA.\n"
    "Elas diferem apenas pelo IDX e pela plataforma usada na assinatura.\n"
    "O binário CIP deste notebook deverá validar AMBAS — essa é a essência\n"
    "da interoperabilidade espectral da CIP.\n"
)

=== INSPEÇÃO DAS CHAVES — CIP-T v3 HÍBRIDO ===

[Chave Linux IDX 18]
  - idx.............: 18
  - N (dimensões)...: 1024
  - arquivo..........: noaa_gsod_2023.tar.gz
  - operação.........: assinatura_total_cipt_v3_hibrido
  - data/hora........: 20251124_115945
  - hash_integridade.: 77f210ad293d2957a514f2a1e44fe2be...
  - matriz_p........: OK

[Chave Windows IDX 20]
  - idx.............: 20
  - N (dimensões)...: 1024
  - arquivo..........: noaa_gsod_2023.tar.gz
  - operação.........: assinatura_total_cipt_v3_hibrido
  - data/hora........: 20251124_120307
  - hash_integridade.: b660f961b8dee7fabc0cad8d3456a8f9...
  - matriz_p........: OK

Ambas as chaves foram produzidas sobre o MESMO arquivo NOAA.
Elas diferem apenas pelo IDX e pela plataforma usada na assinatura.
O binário CIP deste notebook deverá validar AMBAS — essa é a essência
da interoperabilidade espectral da CIP.

CÉLULA 6 — Verificação Cruzada de Interoperabilidade¶

Ou seja:

Usar o binário local do notebook (Linux ou Windows, tanto faz — o ponto é: “um binário único”)

Para verificar:

  • o arquivo NOAA com a chave Linux IDX 18

  • o arquivo NOAA com a chave Windows IDX 20

A interoperabilidade só é provada se:

  • Ambas as verificações retornarem sucesso (returncode == 0),

  • Mesmo cada chave tendo sido produzida em outro sistema operacional

  • E com Outro IDX

Isso demonstra que:

A CIP não depende do SO, nem do compilador, nem da máquina.
O que importa é a coerência espectral do arquivo com o IDX.
Se isso for mantido, qualquer binário válido deve verificar qualquer chave válida.

In [6]:
# ============================================================
# CÉLULA — Verificação Cruzada de Interoperabilidade
# ============================================================

print("\n=== VERIFICAÇÃO CRUZADA — INTEROPERABILIDADE CIP ===\n")

def verificar_cipt(arquivo, chave_json, nome):
    """
    Executa o binário CIP local usando uma chave CIP-T proveniente
    de outro ambiente (Linux ↔ Windows).
    """
    print(f"\n--- Verificando com {nome} ---")
    proc, t = run_cip(["-t", "verificar", str(arquivo), str(chave_json)])

    print("\n[STDOUT]\n", proc.stdout)

    if proc.returncode == 0:
        print(f"[OK] Verificação BEM-SUCEDIDA ({t:.3f} s) — interoperabilidade confirmada.")
    else:
        print("\n[STDERR]\n", proc.stderr)
        raise RuntimeError(
            f"FALHA: A verificação cruzada falhou usando {nome}. "
            "Isso não deveria ocorrer — investigar imediatamente."
        )

# Executar verificações cruzadas
verificar_cipt(ARQ_LOCAL, CHAVE_LINUX_LOCAL, "Chave Linux IDX 18 (assinada em outro SO)")
verificar_cipt(ARQ_LOCAL, CHAVE_WINDOWS_LOCAL, "Chave Windows IDX 20 (assinada em outro SO)")

print("\n=== RESULTADO ===")
print("Ambas as verificações foram realizadas com o MESMO binário CIP local.\n"
      "Isso demonstra, de forma pública e reprodutível, que o protocolo CIP opera\n"
      "com TOTAL independência de plataforma, compilador e sistema operacional.")

=== VERIFICAÇÃO CRUZADA — INTEROPERABILIDADE CIP ===


--- Verificando com Chave Linux IDX 18 (assinada em outro SO) ---

[STDOUT]
 [INFO] OpenMP: 18 threads.
[INFO] Eigen: 18 threads.
[INFO] CIP SDK em modo ilimitado: contador de créditos desativado.

════════════════[ CIP - Configuração SDK ]════════════════
[INFO] Idx do SDK determinado automaticamente: 18
[SUCESSO] Configuração do SDK (idx 18) carregada com sucesso.
[INFO] Idx da matriz de Assinatura (pré-calculada): 18 | Idx da matriz de Cifragem (pré-calculada): 19

════════════[ CIP - Verificação (MODO TOTAL) ]════════════
[INFO] Arquivo a ser verificado: noaa_gsod_2023.tar.gz
[INFO] Chave CIPT usada: chave_idx18_linux.json
[INFO] Verificando integridade da própria chave CIP-T...
[INFO] Hash esperado (assinatura_integridade_chave_cipt): 46a81b7ee6fafd983d764ab43e7d46f07f8a2806019adbd9a2a347e1566bd85b
[INFO] Hash calculado: 46a81b7ee6fafd983d764ab43e7d46f07f8a2806019adbd9a2a347e1566bd85b
[SUCESSO] Integridade da propria chave assinatura_integridade_chave_cipt: OK.
[INFO] Verificando integridade do conteudo do arquivo (Modo Total)...
[INFO] Idx SDK da chave: 18 (LOCAL)
[INFO] Verificação com matriz LOCAL (idx=18)

═════[ Status Final da Verificação (CIP-T - TOTAL) ]══════
[SUCESSO] Conteúdo Íntegro
[INFO] Hash original (na chave): 77f210ad293d2957a514f2a1e44fe2be49b7db73c4f6e3dcb140c1dd9cd9b42c
[INFO] Hash re-calculado:        77f210ad293d2957a514f2a1e44fe2be49b7db73c4f6e3dcb140c1dd9cd9b42c
[SUCESSO] Chave de verificação salva em: /home/alvaro/cip_demo/arquivos/.cip/chaves_cipt/chave_cipt_verificado18_N1024_20251128_115000.json
[SUCESSO] Auditoria de verificação salva em: /home/alvaro/cip_demo/arquivos/.cip/auditorias_cipt/auditoria_cipt_verificado18_N1024_20251128_115000.json
────── Tempos de Execucao (CIP-T - Verificacao TOTAL) ──────
  • Tempo total da verificacao ..............    632 ms

[OK] Verificação BEM-SUCEDIDA (0.681 s) — interoperabilidade confirmada.

--- Verificando com Chave Windows IDX 20 (assinada em outro SO) ---

[STDOUT]
 [INFO] OpenMP: 18 threads.
[INFO] Eigen: 18 threads.
[INFO] CIP SDK em modo ilimitado: contador de créditos desativado.

════════════════[ CIP - Configuração SDK ]════════════════
[INFO] Idx do SDK determinado automaticamente: 18
[SUCESSO] Configuração do SDK (idx 18) carregada com sucesso.
[INFO] Idx da matriz de Assinatura (pré-calculada): 18 | Idx da matriz de Cifragem (pré-calculada): 19

════════════[ CIP - Verificação (MODO TOTAL) ]════════════
[INFO] Arquivo a ser verificado: noaa_gsod_2023.tar.gz
[INFO] Chave CIPT usada: chave_idx20_windows.json
[INFO] Verificando integridade da própria chave CIP-T...
[INFO] Hash esperado (assinatura_integridade_chave_cipt): 550812b6bdd698b289ec7f403509883433d2bcadcfe671cfe800ceebbae7aa26
[INFO] Hash calculado: 550812b6bdd698b289ec7f403509883433d2bcadcfe671cfe800ceebbae7aa26
[SUCESSO] Integridade da propria chave assinatura_integridade_chave_cipt: OK.
[INFO] Verificando integridade do conteudo do arquivo (Modo Total)...
[INFO] Idx SDK da chave: 20 (EXTERNO)
[INFO] Verificação com matriz EMBUTIDA da chave (idx=20)

═════[ Status Final da Verificação (CIP-T - TOTAL) ]══════
[SUCESSO] Conteúdo Íntegro
[INFO] Hash original (na chave): b660f961b8dee7fabc0cad8d3456a8f97c406dbe0b9ebefad12052c8d38d14e3
[INFO] Hash re-calculado:        b660f961b8dee7fabc0cad8d3456a8f97c406dbe0b9ebefad12052c8d38d14e3
[SUCESSO] Chave de verificação salva em: /home/alvaro/cip_demo/arquivos/.cip/chaves_cipt/chave_cipt_verificado20_N1024_20251128_115000.json
[SUCESSO] Auditoria de verificação salva em: /home/alvaro/cip_demo/arquivos/.cip/auditorias_cipt/auditoria_cipt_verificado20_N1024_20251128_115000.json
────── Tempos de Execucao (CIP-T - Verificacao TOTAL) ──────
  • Tempo total da verificacao ..............    632 ms

[OK] Verificação BEM-SUCEDIDA (0.678 s) — interoperabilidade confirmada.

=== RESULTADO ===
Ambas as verificações foram realizadas com o MESMO binário CIP local.
Isso demonstra, de forma pública e reprodutível, que o protocolo CIP opera
com TOTAL independência de plataforma, compilador e sistema operacional.

CÉLULA 7 — Tabela comparativa das chaves (Linux IDX 18 vs Windows IDX 20)¶

In [7]:
# ============================================================
# CÉLULA 7 — Tabela comparativa das chaves (IDX 18 vs IDX 20)
# ============================================================

import pandas as pd

def linha_resumo(chave, origem):
    return {
        "origem": origem,
        "arquivo": chave.get("arquivo_original_nome"),
        "sdk_idx_usado": chave.get("sdk_idx_usado"),
        "N": chave.get("matrix_size_N_usado"),
        "operacao": chave.get("operacao"),
        "tamanho_bytes": chave.get("tamanho_original_bytes"),
        "timestamp": chave.get("timestamp_operacao_str"),
        "hash_chave": chave.get("assinatura_integridade_chave_cipt")[:16] + "...",
        "hash_arquivo": chave.get("assinatura_integridade_final")[:16] + "...",
    }

df_chaves = pd.DataFrame([
    linha_resumo(ch18, "Linux (SDK IDX 18)"),
    linha_resumo(ch20, "Windows (SDK IDX 20)")
])

display(df_chaves)

print(
    "\nAmbas as linhas se referem ao MESMO arquivo, com o MESMO tamanho e a MESMA dimensão N.\n"
    "Os hashes finais são distintos porque cada SDK utiliza uma base harmônica própria (idx\n"
    "diferente), mas ambos são revalidados com sucesso pelo mesmo binário CIP deste notebook."
)
origem arquivo sdk_idx_usado N operacao tamanho_bytes timestamp hash_chave hash_arquivo
0 Linux (SDK IDX 18) noaa_gsod_2023.tar.gz 18 1024 assinatura_total_cipt_v3_hibrido 108776234 20251124_115945 46a81b7ee6fafd98... 77f210ad293d2957...
1 Windows (SDK IDX 20) noaa_gsod_2023.tar.gz 20 1024 assinatura_total_cipt_v3_hibrido 108776234 20251124_120307 550812b6bdd698b2... b660f961b8dee7fa... 
Ambas as linhas se referem ao MESMO arquivo, com o MESMO tamanho e a MESMA dimensão N.
Os hashes finais são distintos porque cada SDK utiliza uma base harmônica própria (idx
diferente), mas ambos são revalidados com sucesso pelo mesmo binário CIP deste notebook.

CÉLULA 8 — Corrupção de 1 bit + Verificação Cruzada (Linux idx18 e Windows idx20)¶

In [8]:
# ============================================================
# CÉLULA — Corrupção de 1 bit + Verificação Cruzada
# ============================================================

import os
import random
import shutil
from pathlib import Path

print("\n=== TESTE CRUZADO — DETECÇÃO DE CORRUPÇÃO (1 BIT) ===")

# ------------------------------------------------------------
# 1. Criar uma cópia do arquivo e corromper 1 bit
# ------------------------------------------------------------
arquivo_corrompido = ARQ_LOCAL.parent / f"{ARQ_LOCAL.stem}_1bit{ARQ_LOCAL.suffix}"
shutil.copy2(ARQ_LOCAL, arquivo_corrompido)

def flip_bit(path: Path):
    with open(path, "r+b") as f:
        f.seek(0, os.SEEK_END)
        tamanho = f.tell()
        pos = random.randint(0, tamanho - 1)
        bit = random.randint(0, 7)

        f.seek(pos)
        original = f.read(1)[0]

        novo = original ^ (1 << bit)
        f.seek(pos)
        f.write(bytes([novo]))

    return pos, bit, original, novo

pos, bit, antigo, novo = flip_bit(arquivo_corrompido)

print(
    f"[INFO] 1 bit corrompido em posição byte {pos}, bit {bit} "
    f"({antigo:02x} → {novo:02x})"
)

# ------------------------------------------------------------
# 2. Verificar com chave Linux (idx 18)
# ------------------------------------------------------------
print("\n--- Verificando com chave Linux IDX 18 ---")

proc_lin, t_lin = run_cip([
    "-t", "verificar", str(arquivo_corrompido), str(CHAVE_LINUX_LOCAL)
])

print("\n[STDOUT]\n", proc_lin.stdout)

falha_linux = proc_lin.returncode != 0

if falha_linux:
    print(f"[OK] Chave Linux detectou a corrupção — tempo {t_lin:.3f} s")
else:
    print("[ERRO CRÍTICO] A chave Linux NÃO detectou a corrupção!")
    raise RuntimeError("Falha inesperada na verificação com chave Linux.")

# ------------------------------------------------------------
# 3. Verificar com chave Windows (idx 20)
# ------------------------------------------------------------
print("\n--- Verificando com chave Windows IDX 20 ---")

proc_win, t_win = run_cip([
    "-t", "verificar", str(arquivo_corrompido), str(CHAVE_WINDOWS_LOCAL)
])

print("\n[STDOUT]\n", proc_win.stdout)

falha_windows = proc_win.returncode != 0

if falha_windows:
    print(f"[OK] Chave Windows detectou a corrupção — tempo {t_win:.3f} s")
else:
    print("[ERRO CRÍTICO] A chave Windows NÃO detectou a corrupção!")
    raise RuntimeError("Falha inesperada na verificação com chave Windows.")

# ------------------------------------------------------------
# 4. Resultado Final
# ------------------------------------------------------------
print("\n=== RESULTADO FINAL ===")
if falha_linux and falha_windows:
    print(
        "As DUAS chaves (Linux idx18 e Windows idx20) rejeitaram o\n"
        "MESMO arquivo corrompido — interoperabilidade COMPLETA.\n"
        "A estrutura espectral não admite falsos positivos."
    )
else:
    print("Há inconsistência inesperada — investigar.")

=== TESTE CRUZADO — DETECÇÃO DE CORRUPÇÃO (1 BIT) ===
[INFO] 1 bit corrompido em posição byte 102499971, bit 1 (93 → 91)

--- Verificando com chave Linux IDX 18 ---

[STDOUT]
 [INFO] OpenMP: 18 threads.
[INFO] Eigen: 18 threads.
[INFO] CIP SDK em modo ilimitado: contador de créditos desativado.

════════════════[ CIP - Configuração SDK ]════════════════
[INFO] Idx do SDK determinado automaticamente: 18
[SUCESSO] Configuração do SDK (idx 18) carregada com sucesso.
[INFO] Idx da matriz de Assinatura (pré-calculada): 18 | Idx da matriz de Cifragem (pré-calculada): 19

════════════[ CIP - Verificação (MODO TOTAL) ]════════════
[INFO] Arquivo a ser verificado: noaa_gsod_2023.tar_1bit.gz
[INFO] Chave CIPT usada: chave_idx18_linux.json
[INFO] Verificando integridade da própria chave CIP-T...
[INFO] Hash esperado (assinatura_integridade_chave_cipt): 46a81b7ee6fafd983d764ab43e7d46f07f8a2806019adbd9a2a347e1566bd85b
[INFO] Hash calculado: 46a81b7ee6fafd983d764ab43e7d46f07f8a2806019adbd9a2a347e1566bd85b
[SUCESSO] Integridade da propria chave assinatura_integridade_chave_cipt: OK.
[AVISO] Nome do arquivo diferente, mas isso não compromete a integridade.
[AVISO] Nome do arquivo real: "noaa_gsod_2023.tar_1bit.gz"
[AVISO] Nome registrado na chave: "noaa_gsod_2023.tar.gz"
[INFO] Verificando integridade do conteudo do arquivo (Modo Total)...
[INFO] Idx SDK da chave: 18 (LOCAL)
[INFO] Verificação com matriz LOCAL (idx=18)

═════[ Status Final da Verificação (CIP-T - TOTAL) ]══════
[INFO] Hash original (na chave): 77f210ad293d2957a514f2a1e44fe2be49b7db73c4f6e3dcb140c1dd9cd9b42c
[INFO] Hash re-calculado:        428994567ed86fc64068ed52d1c6469e90b78df285302ffb06d758979cf78a42
[SUCESSO] Chave de verificação salva em: /home/alvaro/cip_demo/arquivos/.cip/chaves_cipt/chave_cipt_verificado18_N1024_20251128_115001.json
[SUCESSO] Auditoria de verificação salva em: /home/alvaro/cip_demo/arquivos/.cip/auditorias_cipt/auditoria_cipt_verificado18_N1024_20251128_115001.json
────── Tempos de Execucao (CIP-T - Verificacao TOTAL) ──────
  • Tempo total da verificacao ..............    650 ms

[OK] Chave Linux detectou a corrupção — tempo 0.700 s

--- Verificando com chave Windows IDX 20 ---

[STDOUT]
 [INFO] OpenMP: 18 threads.
[INFO] Eigen: 18 threads.
[INFO] CIP SDK em modo ilimitado: contador de créditos desativado.

════════════════[ CIP - Configuração SDK ]════════════════
[INFO] Idx do SDK determinado automaticamente: 18
[SUCESSO] Configuração do SDK (idx 18) carregada com sucesso.
[INFO] Idx da matriz de Assinatura (pré-calculada): 18 | Idx da matriz de Cifragem (pré-calculada): 19

════════════[ CIP - Verificação (MODO TOTAL) ]════════════
[INFO] Arquivo a ser verificado: noaa_gsod_2023.tar_1bit.gz
[INFO] Chave CIPT usada: chave_idx20_windows.json
[INFO] Verificando integridade da própria chave CIP-T...
[INFO] Hash esperado (assinatura_integridade_chave_cipt): 550812b6bdd698b289ec7f403509883433d2bcadcfe671cfe800ceebbae7aa26
[INFO] Hash calculado: 550812b6bdd698b289ec7f403509883433d2bcadcfe671cfe800ceebbae7aa26
[SUCESSO] Integridade da propria chave assinatura_integridade_chave_cipt: OK.
[AVISO] Nome do arquivo diferente, mas isso não compromete a integridade.
[AVISO] Nome do arquivo real: "noaa_gsod_2023.tar_1bit.gz"
[AVISO] Nome registrado na chave: "noaa_gsod_2023.tar.gz"
[INFO] Verificando integridade do conteudo do arquivo (Modo Total)...
[INFO] Idx SDK da chave: 20 (EXTERNO)
[INFO] Verificação com matriz EMBUTIDA da chave (idx=20)

═════[ Status Final da Verificação (CIP-T - TOTAL) ]══════
[INFO] Hash original (na chave): b660f961b8dee7fabc0cad8d3456a8f97c406dbe0b9ebefad12052c8d38d14e3
[INFO] Hash re-calculado:        595116d476970988ca7b352f91d3f4ac7e5f56623da06eacacb7cbcecd64d491
[SUCESSO] Chave de verificação salva em: /home/alvaro/cip_demo/arquivos/.cip/chaves_cipt/chave_cipt_verificado20_N1024_20251128_115002.json
[SUCESSO] Auditoria de verificação salva em: /home/alvaro/cip_demo/arquivos/.cip/auditorias_cipt/auditoria_cipt_verificado20_N1024_20251128_115002.json
────── Tempos de Execucao (CIP-T - Verificacao TOTAL) ──────
  • Tempo total da verificacao ..............    638 ms

[OK] Chave Windows detectou a corrupção — tempo 0.689 s

=== RESULTADO FINAL ===
As DUAS chaves (Linux idx18 e Windows idx20) rejeitaram o
MESMO arquivo corrompido — interoperabilidade COMPLETA.
A estrutura espectral não admite falsos positivos.

CÉLULA 9 — Decifragem cruzada (Linux idx19 e Windows idx21)¶

Na célula anterior mostramos que duas chaves de verificação geradas em ambientes distintos (Linux idx18 e Windows idx20) são aceitas pelo mesmo binário CIP local.

Aqui avançamos um passo: usamos artefatos cifrados do mesmo arquivo NOAA, produzidos por dois SDKs diferentes:

  • SDK Linux com matriz de cifragem idx 19
  • SDK Windows com matriz de cifragem idx 21

A lógica do experimento é:

  1. Partimos do mesmo arquivo noaa_gsod_2023.tar.gz já utilizado nas demais células.
  2. Esse arquivo foi cifrado em cada ambiente, gerando:
    • um arquivo .cip + chave de cifragem no Linux (idx19);
    • um arquivo .cip + chave de cifragem no Windows (idx21).
  3. Copiamos esses quatro artefatos para as pastas arquivos/ e chaves_interop/ deste notebook.
  4. Usamos um único binário CIP nativo (o mesmo das células anteriores) para:
    • decifrar o .cip produzido no Linux, se o binário CIP local é nativo do Windows;
    • decifrar o .cip produzido no Windows, se o binário CIP local é nativo do Linux;
    • comparar, em ambos os casos, o resultado com o arquivo NOAA original via CIP.

Se os hashes forem idênticos nos dois cenários, temos uma evidência prática de que:

A etapa de cifragem/decifragem da CIP é interoperável entre SDKs com IDX distintos, desde que compartilhem a mesma régua espectral global.

In [9]:
# ======================================================================================
# CÉLULA 9 — Download NOAA CIFRADO + Chave Cruzada (Linux ↔ Windows) com tqdm
# ======================================================================================

import platform

SO = platform.system().lower()
print(f"[INFO] Sistema operacional detectado: {SO}")

# ------------------------------------------------------------
# Seleção dinâmica dos artefatos (arquivo + chave)
# ------------------------------------------------------------
if SO == "linux":
    print("[INFO] Rodando em Linux → baixar artefatos CIFRADOS do Windows (SDK idx21).")

    ARQ_CIFRADO_REMOTE = f"{BASE_URL}/noaa_gsod_2023.tar_idx21_N128_xor.cipt"
    CHAVE_REMOTE       = f"{BASE_URL}/chave_cipt_cifrado_idx21_N128_20251125_082436.json"

    ARQ_LOCAL_CIFRADO  = ARQUIVOS_DIR / "noaa_cifrado_idx21_windows.cipt"
    CHAVE_LOCAL        = CHAVES_DIR   / "chave_cipt_cifrado_idx21_windows.json"

elif SO == "windows":
    print("[INFO] Rodando em Windows → baixar artefatos CIFRADOS do Linux (SDK idx19).")

    ARQ_CIFRADO_REMOTE = f"{BASE_URL}/noaa_gsod_2023.tar_idx19_N128_xor.cipt"
    CHAVE_REMOTE       = f"{BASE_URL}/chave_cipt_cifrado_idx19_N128_20251125_082128.json"

    ARQ_LOCAL_CIFRADO  = ARQUIVOS_DIR / "noaa_cifrado_idx19_linux.cipt"
    CHAVE_LOCAL        = CHAVES_DIR   / "chave_cipt_cifrado_idx19_linux.json"

else:
    raise RuntimeError("Sistema operacional não suportado neste experimento.")


# ------------------------------------------------------------
# Função de download com barra de progresso (tqdm)
# ------------------------------------------------------------
def baixar_com_progresso(url: str, destino: Path):
    """
    Faz download com barra de progresso.
    Não baixa novamente se o arquivo já existir com tamanho > 0.
    """
    if destino.exists() and destino.stat().st_size > 0:
        print(f"[OK] Já existe localmente: {destino} ({destino.stat().st_size/1e6:.2f} MB)")
        return

    print(f"[INFO] Baixando: {url}")

    with requests.get(url, stream=True) as r:
        r.raise_for_status()

        total = int(r.headers.get("content-length", 0))
        blocos = 8192

        barra = tqdm(total=total, unit="B", unit_scale=True, desc=destino.name)

        with open(destino, "wb") as f:
            for chunk in r.iter_content(chunk_size=blocos):
                if chunk:
                    f.write(chunk)
                    barra.update(len(chunk))

        barra.close()

    print(f"[OK] Download concluído: {destino} ({destino.stat().st_size/1e6:.2f} MB)")


# ------------------------------------------------------------
# 1) Baixar artefato NOAA CIFRADO cruzado
# 2) Baixar chave correspondente
# ------------------------------------------------------------
baixar_com_progresso(ARQ_CIFRADO_REMOTE, ARQ_LOCAL_CIFRADO)
baixar_com_progresso(CHAVE_REMOTE, CHAVE_LOCAL)

print("\n[OK] Artefatos importados para o notebook:")
print(f"  - Arquivo NOAA cifrado (cruzado)....: {ARQ_LOCAL_CIFRADO}")
print(f"  - Chave correspondente..............: {CHAVE_LOCAL}")

# ------------------------------------------------------------
# Segurança básica: tamanho (evitar arquivos ausentes ou truncados)
# ------------------------------------------------------------
tamanho_bytes = ARQ_LOCAL_CIFRADO.stat().st_size
print(f"\nTamanho do arquivo cifrado: {tamanho_bytes/1e6:.2f} MB")

if tamanho_bytes == 0:
    raise RuntimeError("Arquivo cifrado está vazio. Download falhou ou URL incorreta.")

print("\n[INFO] Pronto para a decifragem cruzada com:")
print("       cip -t decifrar <arquivo.cipt> <chave.json>")

[INFO] Sistema operacional detectado: linux
[INFO] Rodando em Linux → baixar artefatos CIFRADOS do Windows (SDK idx21).
[OK] Já existe localmente: /home/alvaro/cip_demo/arquivos/noaa_cifrado_idx21_windows.cipt (108.78 MB)
[OK] Já existe localmente: /home/alvaro/cip_demo/chaves_interop/chave_cipt_cifrado_idx21_windows.json (0.11 MB)

[OK] Artefatos importados para o notebook:
  - Arquivo NOAA cifrado (cruzado)....: /home/alvaro/cip_demo/arquivos/noaa_cifrado_idx21_windows.cipt
  - Chave correspondente..............: /home/alvaro/cip_demo/chaves_interop/chave_cipt_cifrado_idx21_windows.json

Tamanho do arquivo cifrado: 108.78 MB

[INFO] Pronto para a decifragem cruzada com:
       cip -t decifrar <arquivo.cipt> <chave.json>
In [10]:
# ============================================================
# CÉLULA — Decifração Cruzada de Interoperabilidade
# ============================================================

print("\n=== DECIFRAÇÃO CRUZADA — INTEROPERABILIDADE CIP ===\n")

SO = platform.system().lower()
print(f"[INFO] Sistema operacional detectado: {SO}")

def decifrar_cipt(arquivo, chave_json, nome):
    """
    Executa o binário CIP local usando artefatos produzidos em outro ambiente.
    """
    print(f"\n--- Decifrando com {nome} ---")
    proc, t = run_cip(["-t", "decifrar", str(arquivo), str(chave_json)])

    print("\n[STDOUT]\n", proc.stdout)

    if proc.returncode == 0:
        print(f"[OK] Decifração bem-sucedida ({t:.3f} s) — interoperabilidade confirmada.")
    else:
        print("\n[STDERR]\n", proc.stderr)
        raise RuntimeError(
            f"FALHA: A decifração cruzada falhou usando {nome}. "
            "Isso não deveria ocorrer — investigar imediatamente."
        )

# ------------------------------------------------------------
# Regras do experimento de interoperabilidade:
#   - Se estiver em Linux, decifra APENAS o arquivo cifrado no Windows (idx21).
#   - Se estiver em Windows, decifra APENAS o arquivo cifrado no Linux (idx19).
# ------------------------------------------------------------

if SO == "linux":
    print("[INFO] Executando decifragem cruzada: artefato Windows → binário Linux.")
    decifrar_cipt(
        ARQ_LOCAL_CIFRADO,
        CHAVE_LOCAL,
        "Chave Windows IDX 21 (arquivo cifrado no Windows)"
    )

elif SO == "windows":
    print("[INFO] Executando decifragem cruzada: artefato Linux → binário Windows.")
    decifrar_cipt(
        ARQ_LOCAL_CIFRADO,
        CHAVE_LOCAL,
        "Chave Linux IDX 19 (arquivo cifrado no Linux)"
    )

else:
    raise RuntimeError("Sistema operacional não suportado para este experimento.")


print("\n=== RESULTADO ===")
print("A decifragem cruzada foi executada com sucesso usando o MESMO binário local.\n"
      "O experimento demonstra, de forma pública e reproduzível, que a CIP mantém\n"
      "interoperabilidade total entre ambientes distintos (Linux ↔ Windows), prova\n"
      "de que o protocolo não depende de plataforma, compilador ou SO.")

=== DECIFRAÇÃO CRUZADA — INTEROPERABILIDADE CIP ===

[INFO] Sistema operacional detectado: linux
[INFO] Executando decifragem cruzada: artefato Windows → binário Linux.

--- Decifrando com Chave Windows IDX 21 (arquivo cifrado no Windows) ---

[STDOUT]
 [INFO] OpenMP: 18 threads.
[INFO] Eigen: 18 threads.
[INFO] CIP SDK em modo ilimitado: contador de créditos desativado.

════════════════[ CIP - Configuração SDK ]════════════════
[INFO] Idx do SDK determinado automaticamente: 18
[SUCESSO] Configuração do SDK (idx 18) carregada com sucesso.
[INFO] Idx da matriz de Assinatura (pré-calculada): 18 | Idx da matriz de Cifragem (pré-calculada): 19

═════════════[ CIP - Decifragem (MODO TOTAL) ]══════════════
[INFO] Arquivo cifrado: noaa_cifrado_idx21_windows.cipt
[INFO] Chave CIPT usada: chave_cipt_cifrado_idx21_windows.json
[INFO] Verificando integridade da propria chave CIPT de cifragem...
[INFO] Hash esperado (assinatura_integridade_chave_cipt): 884c5911a0ee2cfc66c8499423083034ae774dff91e8a9358a38ba904329a189
[INFO] Hash calculado: 884c5911a0ee2cfc66c8499423083034ae774dff91e8a9358a38ba904329a189
[SUCESSO] Integridade da propria chave assinatura_integridade_chave_cipt: OK.
[INFO] Reconstruindo padrao XOR para decifragem...
[SUCESSO] Padrao XOR reconstruido com sucesso.
[SUCESSO] Arquivo decifrado salvo em: /home/alvaro/cip_demo/arquivos/.cip/decifrados_cipt/noaa_gsod_2023.tar.gz
[INFO] Verificando integridade do arquivo decifrado (Modo Total)...
[INFO] Verificação com matriz de ASSINATURA EMBUTIDA da chave (idx=20)
[SUCESSO] Integridade do arquivo decifrado: OK.
[INFO] Hash original esperado: b660f961b8dee7fabc0cad8d3456a8f97c406dbe0b9ebefad12052c8d38d14e3
[INFO] Hash do decifrado:     b660f961b8dee7fabc0cad8d3456a8f97c406dbe0b9ebefad12052c8d38d14e3
[SUCESSO] Chave de log da decifragem salva em: /home/alvaro/cip_demo/arquivos/.cip/chaves_cipt/chave_cipt_decifrado_20251128_115003.json
[SUCESSO] Auditoria salva em: /home/alvaro/cip_demo/arquivos/.cip/auditorias_cipt/auditoria_cipt_decifrado_20251128_115003.json
─────── Tempos de Execucao (CIP - Decifragem TOTAL) ────────
  • Tempo total da operacao .................   1158 ms

[OK] Decifração bem-sucedida (1.215 s) — interoperabilidade confirmada.

=== RESULTADO ===
A decifragem cruzada foi executada com sucesso usando o MESMO binário local.
O experimento demonstra, de forma pública e reproduzível, que a CIP mantém
interoperabilidade total entre ambientes distintos (Linux ↔ Windows), prova
de que o protocolo não depende de plataforma, compilador ou SO.

Observação Técnica — Interoperabilidade e Reconstrução Espectral¶

A decifragem cruzada apresentada acima demonstra uma propriedade central da CIP:
a operação de decifragem é totalmente independente do ambiente em que a cifragem foi realizada.

A chave CIP-T incorpora todos os elementos necessários para reproduzir o processo original, incluindo:

  • o índice espectral utilizado;
  • a matriz hermitiana correspondente;
  • os parâmetros de derivação do fluxo XOR;
  • e o hash de integridade da própria chave.

Durante a decifragem, o SDK local não utiliza suas próprias matrizes quando o IDX informado é externo.
Nessa condição, ele identifica, pela chave, qual índice deve ser aplicado e opera exclusivamente com os parâmetros nela
registrados. Essa lógica torna possível que um arquivo cifrado em Windows seja decifrado por um binário compilado em
Linux (e vice-versa), com reconstrução integral do IKM, do padrão XOR e dos mecanismos de integridade.

Por outro lado, quando o IDX é local, o SDK utiliza suas matrizes pré-calculadas. Essa distinção garante que o
protocolo seja universalizável sem perda de eficiência: operações internas utilizam recursos locais, enquanto operações
externas obedecem integralmente às informações registradas na chave.

O hash final do arquivo decifrado coincide exatamente com o hash esperado. Esse resultado confirma a reprodutibilidade
determinística do protocolo e evidencia que a CIP não depende de biblioteca, compilador ou arquitetura específicos.

Observação Técnica — Integridade Espectral baseada em Índices¶

A CIP utiliza uma reta pública de índices $n \ge 10^5$, na qual cada valor de $n$ produz uma matriz hermitiana distinta,
derivada da função $\Delta_\pi(x)$. Variações no índice produzem espectros diferentes, com autovalores e autovetores
incompatíveis entre si.

Consequentemente:

  • arquivos assinados no índice $n = 7\,000\,000$ só podem ser verificados nesse mesmo ponto;
  • arquivos cifrados no índice $n = 9\,500\,000$ só podem ser decifrados com a matriz correspondente.

Como esses parâmetros são registrados na chave CIP-T (modo TOTAL), a verificação e a decifragem tornam-se operações
independentes do ambiente local. Essa arquitetura garante determinismo criptográfico, reprodutibilidade e compatibilidade
entre plataformas.

O conjunto dos experimentos documenta, de forma pública e verificável, que a CIP constitui um protocolo espectral
determinístico, com interoperabilidade integral Linux ↔ Windows — característica essencial para auditoria, validação
independente e aplicações institucionais.

CÉLULA 10 — Encerramento específico da interoperabilidade (Markdown)¶

Encerramento — Interoperabilidade Espectral da CIP¶

Este notebook documenta, de maneira pública e reprodutível, que a Cifra de Integridade Primal (CIP):

  1. Assina o mesmo arquivo público em ambientes distintos

    • Uma chave foi gerada em Linux (SDK IDX 18).
    • Outra foi gerada em Windows (SDK IDX 20).
    • Ambas em modo TOTAL sobre o mesmo arquivo NOAA (noaa_gsod_2023.tar.gz), com N = 1024.

  2. Verifica ambas as chaves com um único binário nativo
    O binário CIP executado neste ambiente validou:

    • a chave Linux (IDX 18) usando sua matriz local;
    • a chave Windows (IDX 20) usando a matriz registrada na própria chave.

  3. Especifica claramente o papel do IDX
    O campo sdk_idx_usado define a base harmônica associada à assinatura:

    • se o IDX da chave coincide com o IDX local, utiliza-se a matriz pré-calculada;
    • se o IDX for externo, utiliza-se exclusivamente a matriz registrada na chave CIP-T.

    Em ambos os casos, o critério é idêntico:
    o hash de integridade deve coincidir bit a bit com o registrado na chave.

  4. Indica que o processo é independente de plataforma, compilador ou ambiente
    A decisão de integridade não depende do sistema operacional, compilador ou hardware.
    O que determina o resultado é a coerência espectral entre:

    • o conteúdo do arquivo,
    • o IDX utilizado,
    • e a matriz hermitiana correspondente.

  5. Evidencia o caráter universal da estrutura
    O fato de um único binário validar chaves produzidas em ambientes diferentes, com IDX distintos, reforça que a CIP opera
    sobre uma estrutura aritmética estável e universal.
    Não há ajustes empíricos ou calibração: ou o espectro coincide, ou a verificação falha.

De um ponto de vista institucional, este experimento demonstra que:

  • é possível definir um protocolo único de integridade, baseado em uma régua espectral comum;
  • diferentes SDKs e plataformas podem coexistir sem perda de verificabilidade;
  • qualquer instituição pode validar, de forma independente, uma assinatura produzida em outro ambiente, desde que respeite a mesma
    régua estrutural.

A interoperabilidade não é um detalhe técnico.
Ela demonstra que a CIP se comporta como um protocolo público de integridade, e não como uma biblioteca local dependente de ambiente.

Observação Técnica — Origem Aritmética, Unicidade da Régua e Interoperabilidade¶

A estrutura da CIP é derivada da aritmética. Tanto a função de contagem de primos $ \pi(x) $ quanto o funcional $ \Delta_\pi(x) $ possuem uma origem fixa, ancorada na unidade.
Qualquer deslocamento ou redefinição da origem violaria essa estrutura.

Esse princípio tem consequências diretas para o protocolo:

  • a manifestação da GOE aritmética se estabiliza a partir de $ n \ge 10^5 $;
  • por isso, os índices (IDX) da CIP começam em $ 10^5 $;
  • o tamanho $ N $ das matrizes pode ser escolhido, desde que contenha informação suficiente para representar o arquivo;
  • mas, uma vez definido, não pode ser alterado sem quebrar a interoperabilidade.

Alterar $ N $ modifica todo o espectro (autovalores, autovetores e projeções), impossibilitando verificações ou decifragem cruzada.
A aritmética permite escolhas iniciais; o protocolo exige estabilidade para garantir interoperabilidade.

Assim, o protocolo admite liberdade inicial, mas exige uniformidade para assegurar que:

qualquer instância da CIP possa verificar o que outra produziu.

Experimentos com decifragem cruzada Linux ↔ Windows e reprodutibilidade bit a bit confirmam que, respeitada a régua comum,
o protocolo opera de forma determinística e independente de ambiente.

Nota Institucional — Sobre a Necessidade de Uma Régua Única¶

Um protocolo público de integridade exige que todos os participantes utilizem a mesma definição estrutural. A CIP adota:

  • uma origem única para os índices (a partir de $10^5$);
  • regras fixas para determinação de $N$;
  • matrizes hermitianas derivadas exclusivamente de $ \Delta_\pi(x) $.

Modificações como iniciar a régua em $10^7$ ou redefinir $N$ podem funcionar localmente, mas quebram a compatibilidade global.
A interoperabilidade depende da existência de uma única régua espectral.

Em termos institucionais, isso implica que:

  • implementações independentes só permanecem verificáveis se seguirem a mesma régua;
  • auditorias externas podem reproduzir e verificar qualquer assinatura;
  • o protocolo mantém caráter público, auditável e replicável;
  • e pode ser adotado por diferentes órgãos e plataformas sem perda de coerência.

A necessidade de institucionalização decorre da própria estrutura aritmética que fundamenta o protocolo — não de preferências
de implementação.
Se o objetivo é garantir verificabilidade universal, a régua deve ser única, estável e pública.