display.h File Reference

Go to the source code of this file.

Macros
#define	KEY_IDENTITY_BUFFER_SIZE   2048

Functions
asciichat_error_t	key_identity_format (const public_key_t *key, bool art, bool unicode, int cols, char *out, size_t size)
asciichat_error_t	key_identity_format_terminal (const public_key_t *key, char *out, size_t size)
const char *	key_identity_art_end (const char *text)
void	key_identity_announce (const char *label, const public_key_t *key)

Macro Definition Documentation

KEY_IDENTITY_BUFFER_SIZE

#define KEY_IDENTITY_BUFFER_SIZE   2048

Definition at line 6 of file include/ascii-chat/crypto/key_identity/display.h.

Referenced by display_mitm_warning(), key_identity_announce(), and prompt_unknown_host().

Function Documentation

key_identity_announce()

void key_identity_announce	(	const char *	label,
		const public_key_t *	key )

Announce a public identity using the existing notice/logging policy.

Definition at line 83 of file lib/crypto/key_identity/display.c.

                                                                       {
  char identity[KEY_IDENTITY_BUFFER_SIZE];
  if (key_identity_format_terminal(key, identity, sizeof(identity)) == ASCIICHAT_OK)
    NOTICE_ANNOUNCE(label, "%s", identity);
}

References ASCIICHAT_OK, KEY_IDENTITY_BUFFER_SIZE, key_identity_format_terminal(), and NOTICE_ANNOUNCE.

Referenced by crypto_handshake_client_key_exchange().

key_identity_art_end()

const char * key_identity_art_end

(

const char *

text

)

Return the end of a complete Keymask heading/art block, or NULL. Allows notice renderers to use the terminal's default foreground for art.

Definition at line 64 of file lib/crypto/key_identity/display.c.

                                                   {
  static const char heading[] = "Keymask v2 / SHA-256\n";
  static const char border[] = "+--------------------------------+\n";
  if (!text || strncmp(text, heading, sizeof(heading) - 1) != 0)
    return NULL;
  const char *row = text + sizeof(heading) - 1;
  if (strncmp(row, border, sizeof(border) - 1) != 0)
    return NULL;
  row += sizeof(border) - 1;
  for (unsigned i = 0; i < KEYMASK_ROWS - 2; ++i) {
    const char *end = strchr(row, '\n');
    if (!end || end - row < 2 || row[0] != '|' || end[-1] != '|' ||
        utf8_display_width_n(row, (size_t)(end - row)) != KEYMASK_WIDTH)
      return NULL;
    row = end + 1;
  }
  return strncmp(row, border, sizeof(border) - 1) == 0 ? row + sizeof(border) - 1 : NULL;
}

References KEYMASK_ROWS, KEYMASK_WIDTH, and utf8_display_width_n().

Referenced by ui_notice_render().

key_identity_format()

asciichat_error_t key_identity_format	(	const public_key_t *	key,
		bool	art,
		bool	unicode,
		int	cols,
		char *	out,
		size_t	size )

Format public identity with full fingerprint and optional Keymask v2. cols is the available content width; insufficient width suppresses the art.

Definition at line 11 of file lib/crypto/key_identity/display.c.

                                                   {
  if (!out || !size)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing identity output buffer");
  out[0] = '\0';
  if (!key)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing public identity");
  const char *type;
  switch (key->type) {
  case KEY_TYPE_ED25519:
    type = "Ed25519";
    break;
  case KEY_TYPE_GPG:
    type = "Ed25519 (GPG)";
    break;
  case KEY_TYPE_X25519:
    type = "X25519";
    break;
  default:
    return SET_ERRNO(ERROR_INVALID_PARAM, "Unsupported public identity type");
  }
  uint8_t digest[KEYMASK_DIGEST_SIZE];
  asciichat_error_t result = key_fingerprint_digest(key->key, digest);
  if (result != ASCIICHAT_OK)
    return result;
  char hex[HEX_STRING_SIZE_32];
  for (size_t i = 0; i < sizeof(digest); ++i) {
    hex[i * 2] = "0123456789abcdef"[digest[i] >> 4];
    hex[i * 2 + 1] = "0123456789abcdef"[digest[i] & 15];
  }
  hex[64] = '\0';
  char mask[KEYMASK_BUFFER_SIZE] = "";
  bool show = art && cols >= KEYMASK_WIDTH;
  if (show && (result = keymask_render(digest, unicode, mask, sizeof(mask))) != ASCIICHAT_OK)
    return result;
  const char *heading = show ? "Keymask v2 / SHA-256\n" : "";
  size_t needed = strlen(type) + strlen(" public key\n") + strlen(heading) + strlen(mask) + strlen("SHA256:") + 64 + 2;
  if (size < needed)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Identity output needs %zu bytes", needed);
  safe_snprintf(out, size, "%s public key\n%s%sSHA256:%s\n", type, heading, mask, hex);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, HEX_STRING_SIZE_32, public_key_t::key, key_fingerprint_digest(), KEY_TYPE_ED25519, KEY_TYPE_GPG, KEY_TYPE_X25519, KEYMASK_BUFFER_SIZE, KEYMASK_DIGEST_SIZE, keymask_render(), KEYMASK_WIDTH, out, safe_snprintf(), SET_ERRNO, and public_key_t::type.

Referenced by key_identity_format_terminal(), and prompt_unknown_host().

key_identity_format_terminal()

asciichat_error_t key_identity_format_terminal	(	const public_key_t *	key,
		char *	out,
		size_t	size )

Format using the current terminal capabilities and snapshot policy.

Definition at line 54 of file lib/crypto/key_identity/display.c.

                                                                                                {
  bool tty = platform_isatty(STDERR_FILENO);
  bool art = tty && !GET_OPTION(snapshot_mode);
  int cols = tty ? ui_controller_size().cols : 80;
  // Notices reserve borders, padding, and the terminal's final column.
  cols = (cols > 81 ? 80 : cols - 1) - 4;
  bool unicode = terminal_should_use_utf8(GET_OPTION(force_utf8));
  return key_identity_format(key, art, unicode, cols, out, size);
}

References GET_OPTION, key_identity_format(), out, and ui_controller_size().

Referenced by display_mitm_warning(), key_identity_announce(), and prompt_unknown_host().