Solución de problemas

​

Claves y copia de seguridad segura de claves

​

El desbloqueo falla (código de acceso inválido)

• Confirma que el código de acceso coincide con el usado en setup
• Espera entre intentos; los realms limitan por tasa los intentos incorrectos y pueden bloquear la recuperación tras demasiados fallos

try:
    chat.unlock(passcode)
except ValueError as e:
    print(e)  # may mention InvalidPin or guesses remaining

try {
  await chat.unlock(passcode);
} catch (e) {
  console.error((e as Error).message);
}

chat.unlock(passcode_bytes).await?;

if err := chat.Unlock(passcode, juiceboxConfigJSON); err != nil {
    log.Println(err)
}

try { chat.Unlock(passcode, juiceboxConfigJson); }
catch (Exception e) { Console.WriteLine(e.Message); }

try { chat.unlock(passcode, juiceboxConfigJson); }
catch (Exception e) { System.out.println(e.getMessage()); }

​

El cifrado o descifrado falla porque las claves o la identidad no están configuradas

chat.unlock(passcode)  # or: chat.import_keys(blob)
chat.set_identity(my_user_id, signing_key_version)

await chat.unlock(passcode);
chat.setIdentity(myUserId, signingKeyVersion);

chat.import_keys(&blob)?;
chat.set_identity(&my_user_id, &signing_key_version);

blob, _ := chatxdk.Base64ToBytes(privateKeysB64)
_ = chat.ImportKeys(blob)
_ = chat.SetIdentity(myUserID, signingKeyVersion)

chat.ImportKeys(blobBytes);
chat.SetIdentity(myUserId, signingKeyVersion);

chat.importKeys(blobBytes);
chat.setIdentity(myUserId, signingKeyVersion);

​

Tu clave pública local nunca coincide con las claves registradas de la cuenta

• La API almacena y devuelve la clave exactamente como la subió el registro: la codificación DER (SPKI) — la clave en bruto detrás de un prefijo fijo de identificador de algoritmo
• La get_public_keys del Chat XDK devuelve la clave en bruto sola, sin ese prefijo

import base64

def same_key(local_b64: str, server_b64: str) -> bool:
    local = base64.b64decode(local_b64)    # chat.get_public_keys()["identity"]
    server = base64.b64decode(server_b64)  # API row's "public_key"
    return local == server or (len(server) > len(local) and server.endswith(local))

const sameKey = (localB64: string, serverB64: string): boolean => {
  const local = Buffer.from(localB64, 'base64');   // chat.getPublicKeys().identity
  const server = Buffer.from(serverB64, 'base64'); // API row's public_key
  return local.equals(server) ||
    (server.length > local.length && server.subarray(server.length - local.length).equals(local));
};

fn same_key(local: &[u8], server: &[u8]) -> bool {
    local == server || (server.len() > local.len() && server.ends_with(local))
}

func sameKey(local, server []byte) bool {
    return bytes.Equal(local, server) ||
        (len(server) > len(local) && bytes.HasSuffix(server, local))
}

static bool SameKey(byte[] local, byte[] server) =>
    local.SequenceEqual(server) ||
    (server.Length > local.Length &&
     server.AsSpan(server.Length - local.Length).SequenceEqual(local));

static boolean sameKey(byte[] local, byte[] server) {
    if (Arrays.equals(local, server)) return true;
    if (server.length <= local.length) return false;
    byte[] tail = Arrays.copyOfRange(server, server.length - local.length, server.length);
    return Arrays.equals(tail, local);
}

​

Falta la clave de conversación para un mensaje

1. Descifra el material de clave desde conversation_key_change_event (eventos en vivo) o meta.conversation_key_events (historial) con extract_conversation_keys, o incluye esos blobs en decrypt_events—con set_cache_keys(true) habilitado, decrypt_events también retiene la clave verificada más reciente de cada conversación para que las llamadas posteriores a decrypt_event y encrypt_* puedan omitirla
2. Confirma que se agregaron claves de conversación para esa versión y que sigues siendo participante (consulta Primeros pasos)

​

El par no tiene claves públicas

​

Descifrado y firmas

​

El descifrado falla

• Clave de conversación en bruto desactualizada o incorrecta, o versión de clave incorrecta
• Cadena encoded_event incompleta
• El tipo de evento no es un mensaje cifrado que puedas tratar como contenido descifrable

​

La firma no verifica

• Entrada de clave de firma faltante o incompleta para el remitente (todos los campos que requiere el Chat XDK—consulta la referencia del Chat XDK)
• No se pasaron claves de firma en la llamada y ninguna está almacenada mediante set_signing_keys
• El remitente rotó versiones—vuelve a obtener sus claves públicas
• Una versión de clave por debajo del piso aceptado nunca verifica
• En un evento de cambio de clave de grupo, quien lo firmó ya abandonó el grupo, así que sus claves ya no se sirven — consulta Cambios de clave de miembros que se fueron

chat.set_reject_unverified(True)

chat.setRejectUnverified(true);

chat.set_reject_unverified(true);

chat.SetRejectUnverified(true)

chat.SetRejectUnverified(true);

chat.setRejectUnverified(true);

​

Una respuesta lleva reply_preview_validation: "Invalid"

​

Los eventos antiguos fallan la verificación de forma permanente

​

Construcción del payload de envío

​

La API devuelve 400 en una llamada que cambia estado

​

Cifrar y descifrar multimedia

• Usa la misma clave de conversación (y versión) que el mensaje que referencia el adjunto
• Trata las respuestas de descarga como texto cifrado hasta que ejecutes decrypt_stream
• Infiere el tipo MIME después de descifrar; el Content-Type de la descarga a menudo no es el tipo real de imagen

​

Depuración segura

• Registra solo los ids de conversación, ids de evento y versiones de clave
• No registres texto plano, códigos de acceso, claves privadas ni blobs de clave completos
• Confirma que la versión de clave de firma pasada a set_identity coincide con el public_key_version de tu registro de clave pública
• Para historial incompleto, pagina todas las páginas de eventos para no saltarte metadatos de cambio de clave antes de descifrar