Solución de problemas

​

Claves y copia de seguridad segura de claves

​

Falla el unlock (código de acceso inválido)

• Confirma que el código de acceso coincide con el usado con setup
• Espera entre intentos; los realms limitan por tasa los intentos erróneos 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()); }

​

Cifrar o descifrar 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 el registro la subió: la codificación DER (SPKI) — la clave en bruto detrás de un prefijo fijo de identificador de algoritmo
• El get_public_keys del Chat XDK devuelve solo la clave en bruto, 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 última clave verificada de cada conversación para que las llamadas posteriores decrypt_event y encrypt_* puedan omitirla
2. Confirma que se añadieron 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

​

Falla el descifrado

• Clave de conversación en bruto obsoleta 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 se verifica

• Entrada de clave de firma faltante o incompleta para el remitente (todos los campos requeridos por el Chat XDK—consulta la referencia del Chat XDK)
• No se pasaron claves de firma en la llamada y no hay ninguna almacenada mediante set_signing_keys
• El remitente rotó versiones—vuelve a obtener sus claves públicas
• Una versión de clave por debajo del mínimo aceptado nunca se verifica
• En un evento de cambio de clave de grupo, el firmante ha abandonado el grupo desde entonces, por lo que sus claves ya no se sirven—consulta Cambios de clave por parte de miembros que han abandonado el grupo

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 permanentemente la verificación

​

Construyendo el payload de envío

​

La API devuelve 400 para una llamada que cambia el estado

​

Cifrado y descifrado de multimedia

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

​

Depuración segura

• Registra en logs los IDs de conversación, los IDs de evento y las versiones de claves únicamente
• No registres en logs texto plano, códigos de acceso, claves privadas ni blobs de clave completos
• Confirma que la versión de la clave de firma pasada a set_identity coincide con el public_key_version de tu registro de public-key
• Para historial incompleto, pagina todas las páginas de eventos para no saltar los metadatos de key-change antes de descifrar