static void torture_pki_duplicate_key_ecdsa(void **state) { int rc; char *b64_key; char *b64_key_gen; ssh_key pubkey; ssh_key privkey; ssh_key privkey_dup; (void) state; rc = ssh_pki_import_pubkey_file(LIBSSH_ECDSA_TESTKEY ".pub", &pubkey); assert_true(rc == 0); rc = ssh_pki_export_pubkey_base64(pubkey, &b64_key); assert_true(rc == 0); ssh_key_free(pubkey); rc = ssh_pki_import_privkey_file(LIBSSH_ECDSA_TESTKEY, NULL, NULL, NULL, &privkey); assert_true(rc == 0); privkey_dup = ssh_key_dup(privkey); assert_true(privkey_dup != NULL); rc = ssh_pki_export_privkey_to_pubkey(privkey, &pubkey); assert_true(rc == SSH_OK); rc = ssh_pki_export_pubkey_base64(pubkey, &b64_key_gen); assert_true(rc == 0); assert_string_equal(b64_key, b64_key_gen); rc = ssh_key_cmp(privkey, privkey_dup, SSH_KEY_CMP_PRIVATE); assert_true(rc == 0); ssh_key_free(pubkey); ssh_key_free(privkey); ssh_key_free(privkey_dup); ssh_string_free_char(b64_key); ssh_string_free_char(b64_key_gen); }
int ssh_pki_export_pubkey_file(const ssh_key key, const char *filename) { char key_buf[4096]; char host[256]; char *b64_key; char *user; FILE *fp; int rc; if (key == NULL || filename == NULL || *filename == '\0') { return SSH_ERROR; } user = ssh_get_local_username(); if (user == NULL) { return SSH_ERROR; } rc = gethostname(host, sizeof(host)); if (rc < 0) { free(user); return SSH_ERROR; } rc = ssh_pki_export_pubkey_base64(key, &b64_key); if (rc < 0) { free(user); return SSH_ERROR; } rc = snprintf(key_buf, sizeof(key_buf), "%s %s %s@%s\n", key->type_c, b64_key, user, host); free(user); free(b64_key); if (rc < 0) { return SSH_ERROR; } fp = fopen(filename, "w+"); if (fp == NULL) { return SSH_ERROR; } rc = fwrite(key_buf, strlen(key_buf), 1, fp); if (rc != 1 || ferror(fp)) { fclose(fp); unlink(filename); return SSH_ERROR; } fclose(fp); return SSH_OK; }
static int auth_pubkey_cb(__unused ssh_session session, const char *user, struct ssh_key_struct *pubkey, char signature_state, void *userdata) { struct tmate_ssh_client *client = userdata; switch (signature_state) { case SSH_PUBLICKEY_STATE_VALID: client->username = xstrdup(user); if (ssh_pki_export_pubkey_base64(pubkey, &client->pubkey) != SSH_OK) tmate_fatal("error getting public key"); return check_authorized_keys(pubkey); case SSH_PUBLICKEY_STATE_NONE: return SSH_AUTH_SUCCESS; default: return SSH_AUTH_DENIED; } }
static void torture_pki_publickey_rsa_base64(void **state) { enum ssh_keytypes_e type; char *b64_key, *key_buf, *p; const char *q; ssh_key key; int rc; (void) state; /* unused */ key_buf = read_file(LIBSSH_RSA_TESTKEY ".pub"); assert_true(key_buf != NULL); q = p = key_buf; while (*p != ' ') p++; *p = '\0'; type = ssh_key_type_from_name(q); assert_true(((type == SSH_KEYTYPE_RSA) || (type == SSH_KEYTYPE_RSA1))); q = ++p; while (*p != ' ') p++; *p = '\0'; rc = ssh_pki_import_pubkey_base64(q, type, &key); assert_true(rc == 0); rc = ssh_pki_export_pubkey_base64(key, &b64_key); assert_true(rc == 0); assert_string_equal(q, b64_key); free(b64_key); free(key_buf); ssh_key_free(key); }
#include "common.h" /* Convert SSH public key KEY to a scheme string. */ SCM_DEFINE (guile_ssh_public_key_to_string, "public-key->string", 1, 0, 0, (SCM key), "\ Convert SSH public key to a scheme string.\ ") #define FUNC_NAME s_guile_ssh_public_key_to_string { struct key_data *key_data = _scm_to_key_data (key); char *key_str; SCM_ASSERT (_public_key_p (key_data), key, SCM_ARG1, FUNC_NAME); int res = ssh_pki_export_pubkey_base64 (key_data->ssh_key, &key_str); if (res != SSH_OK) guile_ssh_error1 (FUNC_NAME, "Unable to convert the key to a string", key); return scm_take_locale_string (key_str); } #undef FUNC_NAME SCM_DEFINE (guile_ssh_string_to_public_key, "string->public-key", 2, 0, 0, (SCM base64_str, SCM type), "\ Convert Base64 string to a public key. Return new public key.\n\ Throw `guile-ssh-error' on error.\ ") #define FUNC_NAME s_guile_ssh_string_to_public_key {