自学教程：C++ sshbuf_put_string函数代码示例

/* Confirmation hash calculation */voidjpake_confirm_hash(const BIGNUM *k,    const u_char *endpoint_id, u_int endpoint_id_len,    const u_char *sess_id, u_int sess_id_len,    u_char **confirm_hash, u_int *confirm_hash_len){	struct sshbuf *b;	int r;	/*	 * Calculate confirmation proof:	 *     client: H(k || client_id || session_id)	 *     server: H(k || server_id || session_id)	 */	if ((b = sshbuf_new()) == NULL)		fatal("%s: sshbuf_new failed", __func__);	if ((r = sshbuf_put_bignum2(b, k)) != 0 ||	    (r = sshbuf_put_string(b, endpoint_id, endpoint_id_len)) != 0 ||	    (r = sshbuf_put_string(b, sess_id, sess_id_len)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	if (hash_buffer(sshbuf_ptr(b), sshbuf_len(b), EVP_sha256(),	    confirm_hash, confirm_hash_len) != 0)		fatal("%s: hash_buffer", __func__);	sshbuf_free(b);}

static voidbuild_cert(struct sshbuf *b, const struct sshkey *k, const char *type,    const struct sshkey *sign_key, const struct sshkey *ca_key,    const char *sig_alg){	struct sshbuf *ca_buf, *pk, *principals, *critopts, *exts;	u_char *sigblob;	size_t siglen;	ca_buf = sshbuf_new();	ASSERT_PTR_NE(ca_buf, NULL);	ASSERT_INT_EQ(sshkey_putb(ca_key, ca_buf), 0);	/*	 * Get the public key serialisation by rendering the key and skipping	 * the type string. This is a bit of a hack :/	 */	pk = sshbuf_new();	ASSERT_PTR_NE(pk, NULL);	ASSERT_INT_EQ(sshkey_putb_plain(k, pk), 0);	ASSERT_INT_EQ(sshbuf_skip_string(pk), 0);	principals = sshbuf_new();	ASSERT_PTR_NE(principals, NULL);	ASSERT_INT_EQ(sshbuf_put_cstring(principals, "gsamsa"), 0);	ASSERT_INT_EQ(sshbuf_put_cstring(principals, "gregor"), 0);	critopts = sshbuf_new();	ASSERT_PTR_NE(critopts, NULL);	put_opt(critopts, "force-command", "/usr/local/bin/nethack");	put_opt(critopts, "source-address", "192.168.0.0/24,127.0.0.1,::1");	exts = sshbuf_new();	ASSERT_PTR_NE(exts, NULL);	put_opt(critopts, "permit-X11-forwarding", NULL);	ASSERT_INT_EQ(sshbuf_put_cstring(b, type), 0);	ASSERT_INT_EQ(sshbuf_put_cstring(b, "noncenoncenonce!"), 0); /* nonce */	ASSERT_INT_EQ(sshbuf_putb(b, pk), 0); /* public key serialisation */	ASSERT_INT_EQ(sshbuf_put_u64(b, 1234), 0); /* serial */	ASSERT_INT_EQ(sshbuf_put_u32(b, SSH2_CERT_TYPE_USER), 0); /* type */	ASSERT_INT_EQ(sshbuf_put_cstring(b, "gregor"), 0); /* key ID */	ASSERT_INT_EQ(sshbuf_put_stringb(b, principals), 0); /* principals */	ASSERT_INT_EQ(sshbuf_put_u64(b, 0), 0); /* start */	ASSERT_INT_EQ(sshbuf_put_u64(b, 0xffffffffffffffffULL), 0); /* end */	ASSERT_INT_EQ(sshbuf_put_stringb(b, critopts), 0); /* options */	ASSERT_INT_EQ(sshbuf_put_stringb(b, exts), 0); /* extensions */	ASSERT_INT_EQ(sshbuf_put_string(b, NULL, 0), 0); /* reserved */	ASSERT_INT_EQ(sshbuf_put_stringb(b, ca_buf), 0); /* signature key */	ASSERT_INT_EQ(sshkey_sign(sign_key, &sigblob, &siglen,	    sshbuf_ptr(b), sshbuf_len(b), sig_alg, 0), 0);	ASSERT_INT_EQ(sshbuf_put_string(b, sigblob, siglen), 0); /* signature */	free(sigblob);	sshbuf_free(ca_buf);	sshbuf_free(exts);	sshbuf_free(critopts);	sshbuf_free(principals);	sshbuf_free(pk);}

static voidbuild_cert(struct sshbuf *b, const struct sshkey *k, const char *type,    const struct sshkey *sign_key, const struct sshkey *ca_key){	struct sshbuf *ca_buf, *pk, *principals, *critopts, *exts;	u_char *sigblob;	size_t siglen;	ca_buf = sshbuf_new();	ASSERT_INT_EQ(sshkey_to_blob_buf(ca_key, ca_buf), 0);	/*	 * Get the public key serialisation by rendering the key and skipping	 * the type string. This is a bit of a hack :/	 */	pk = sshbuf_new();	ASSERT_INT_EQ(sshkey_plain_to_blob_buf(k, pk), 0);	ASSERT_INT_EQ(sshbuf_skip_string(pk), 0);	principals = sshbuf_new();	ASSERT_INT_EQ(sshbuf_put_cstring(principals, "gsamsa"), 0);	ASSERT_INT_EQ(sshbuf_put_cstring(principals, "gregor"), 0);	critopts = sshbuf_new();	/* XXX fill this in */	exts = sshbuf_new();	/* XXX fill this in */	ASSERT_INT_EQ(sshbuf_put_cstring(b, type), 0);	ASSERT_INT_EQ(sshbuf_put_cstring(b, "noncenoncenonce!"), 0); /* nonce */	ASSERT_INT_EQ(sshbuf_putb(b, pk), 0); /* public key serialisation */	ASSERT_INT_EQ(sshbuf_put_u64(b, 1234), 0); /* serial */	ASSERT_INT_EQ(sshbuf_put_u32(b, SSH2_CERT_TYPE_USER), 0); /* type */	ASSERT_INT_EQ(sshbuf_put_cstring(b, "gregor"), 0); /* key ID */	ASSERT_INT_EQ(sshbuf_put_stringb(b, principals), 0); /* principals */	ASSERT_INT_EQ(sshbuf_put_u64(b, 0), 0); /* start */	ASSERT_INT_EQ(sshbuf_put_u64(b, 0xffffffffffffffffULL), 0); /* end */	ASSERT_INT_EQ(sshbuf_put_stringb(b, critopts), 0); /* options */	ASSERT_INT_EQ(sshbuf_put_stringb(b, exts), 0); /* extensions */	ASSERT_INT_EQ(sshbuf_put_string(b, NULL, 0), 0); /* reserved */	ASSERT_INT_EQ(sshbuf_put_stringb(b, ca_buf), 0); /* signature key */	ASSERT_INT_EQ(sshkey_sign(sign_key, &sigblob, &siglen,	    sshbuf_ptr(b), sshbuf_len(b), 0), 0);	ASSERT_INT_EQ(sshbuf_put_string(b, sigblob, siglen), 0); /* signature */	free(sigblob);	sshbuf_free(ca_buf);	sshbuf_free(exts);	sshbuf_free(critopts);	sshbuf_free(principals);	sshbuf_free(pk);}

/* ask agent to sign data, returns err.h code on error, 0 on success */intssh_agent_sign(int sock, struct sshkey *key,    u_char **sigp, size_t *lenp,    const u_char *data, size_t datalen, u_int compat){	struct sshbuf *msg;	u_char *blob = NULL, type;	size_t blen = 0, len = 0;	u_int flags = 0;	int r = SSH_ERR_INTERNAL_ERROR;	if (sigp != NULL)		*sigp = NULL;	if (lenp != NULL)		*lenp = 0;	if (datalen > SSH_KEY_MAX_SIGN_DATA_SIZE)		return SSH_ERR_INVALID_ARGUMENT;	if (compat & SSH_BUG_SIGBLOB)		flags |= SSH_AGENT_OLD_SIGNATURE;	if ((msg = sshbuf_new()) == NULL)		return SSH_ERR_ALLOC_FAIL;	if ((r = sshkey_to_blob(key, &blob, &blen)) != 0)		goto out;	if ((r = sshbuf_put_u8(msg, SSH2_AGENTC_SIGN_REQUEST)) != 0 ||	    (r = sshbuf_put_string(msg, blob, blen)) != 0 ||	    (r = sshbuf_put_string(msg, data, datalen)) != 0 ||	    (r = sshbuf_put_u32(msg, flags)) != 0)		goto out;	if ((r = ssh_request_reply(sock, msg, msg) != 0))		goto out;	if ((r = sshbuf_get_u8(msg, &type)) != 0)		goto out;	if (agent_failed(type)) {		r = SSH_ERR_AGENT_FAILURE;		goto out;	} else if (type != SSH2_AGENT_SIGN_RESPONSE) {		r = SSH_ERR_INVALID_FORMAT;		goto out;	}	if ((r = sshbuf_get_string(msg, sigp, &len)) != 0)		goto out;	*lenp = len;	r = 0; out:	if (blob != NULL) {		explicit_bzero(blob, blen);		free(blob);	}	sshbuf_free(msg);	return r;}

intkex_c25519_hash(    int hash_alg,    const char *client_version_string,    const char *server_version_string,    const char *ckexinit, size_t ckexinitlen,    const char *skexinit, size_t skexinitlen,    const u_char *serverhostkeyblob, size_t sbloblen,    const u_char client_dh_pub[CURVE25519_SIZE],    const u_char server_dh_pub[CURVE25519_SIZE],    const u_char *shared_secret, size_t secretlen,    u_char *hash, size_t *hashlen){	struct sshbuf *b;	int r;	if (*hashlen < ssh_digest_bytes(hash_alg))		return SSH_ERR_INVALID_ARGUMENT;	if ((b = sshbuf_new()) == NULL)		return SSH_ERR_ALLOC_FAIL;	if ((r = sshbuf_put_cstring(b, client_version_string)) < 0 ||	    (r = sshbuf_put_cstring(b, server_version_string)) < 0 ||	    /* kexinit messages: fake header: len+SSH2_MSG_KEXINIT */	    (r = sshbuf_put_u32(b, ckexinitlen+1)) < 0 ||	    (r = sshbuf_put_u8(b, SSH2_MSG_KEXINIT)) < 0 ||	    (r = sshbuf_put(b, ckexinit, ckexinitlen)) < 0 ||	    (r = sshbuf_put_u32(b, skexinitlen+1)) < 0 ||	    (r = sshbuf_put_u8(b, SSH2_MSG_KEXINIT)) < 0 ||	    (r = sshbuf_put(b, skexinit, skexinitlen)) < 0 ||	    (r = sshbuf_put_string(b, serverhostkeyblob, sbloblen)) < 0 ||	    (r = sshbuf_put_string(b, client_dh_pub, CURVE25519_SIZE)) < 0 ||	    (r = sshbuf_put_string(b, server_dh_pub, CURVE25519_SIZE)) < 0 ||	    (r = sshbuf_put(b, shared_secret, secretlen)) < 0) {		sshbuf_free(b);		return r;	}#ifdef DEBUG_KEX	sshbuf_dump(b, stderr);#endif	if (ssh_digest_buffer(hash_alg, b, hash, *hashlen) != 0) {		sshbuf_free(b);		return SSH_ERR_LIBCRYPTO_ERROR;	}	sshbuf_free(b);	*hashlen = ssh_digest_bytes(hash_alg);#ifdef DEBUG_KEX	dump_digest("hash", hash, *hashlen);#endif	return 0;}

intsshbuf_put_ec(struct sshbuf *buf, const EC_POINT *v, const EC_GROUP *g){	u_char d[SSHBUF_MAX_ECPOINT];	BN_CTX *bn_ctx;	size_t len;	int ret;	if ((bn_ctx = BN_CTX_new()) == NULL)		return SSH_ERR_ALLOC_FAIL;	if ((len = EC_POINT_point2oct(g, v, POINT_CONVERSION_UNCOMPRESSED,	    NULL, 0, bn_ctx)) > SSHBUF_MAX_ECPOINT) {		BN_CTX_free(bn_ctx);		return SSH_ERR_INVALID_ARGUMENT;	}	if (EC_POINT_point2oct(g, v, POINT_CONVERSION_UNCOMPRESSED,	    d, len, bn_ctx) != len) {		BN_CTX_free(bn_ctx);		return SSH_ERR_INTERNAL_ERROR; /* Shouldn't happen */	}	BN_CTX_free(bn_ctx);	ret = sshbuf_put_string(buf, d, len);	bzero(d, len);	return ret;}

intmm_answer_gss_accept_ctx(int sock, struct sshbuf *m){	gss_buffer_desc in;	gss_buffer_desc out = GSS_C_EMPTY_BUFFER;	OM_uint32 major, minor;	OM_uint32 flags = 0; /* GSI needs this */	size_t len;	u_char *p;	int r;	if ((r = sshbuf_get_string(m, &p, &len)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	in.value = p;	in.length = len;	major = ssh_gssapi_accept_ctx(gsscontext, &in, &out, &flags);	free(in.value);	sshbuf_reset(m);	if ((r = sshbuf_put_u32(m, major)) != 0 ||	    (r = sshbuf_put_string(m, out.value, out.length)) != 0 ||	    (r = sshbuf_put_u32(m, flags)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	mm_request_send(sock, MONITOR_ANS_GSSSTEP, m);	gss_release_buffer(&minor, &out);	if (major == GSS_S_COMPLETE) {		monitor_permit(mon_dispatch, MONITOR_REQ_GSSSTEP, 0);		monitor_permit(mon_dispatch, MONITOR_REQ_GSSUSEROK, 1);		monitor_permit(mon_dispatch, MONITOR_REQ_GSSCHECKMIC, 1);	}	return 0;}

intkexgex_hash(    int hash_alg,    const char *client_version_string,    const char *server_version_string,    const u_char *ckexinit, size_t ckexinitlen,    const u_char *skexinit, size_t skexinitlen,    const u_char *serverhostkeyblob, size_t sbloblen,    int min, int wantbits, int max,    const BIGNUM *prime,    const BIGNUM *gen,    const BIGNUM *client_dh_pub,    const BIGNUM *server_dh_pub,    const BIGNUM *shared_secret,    u_char **hash, size_t *hashlen){	struct sshbuf *b;	static u_char digest[SSH_DIGEST_MAX_LENGTH];	int r;	if ((b = sshbuf_new()) == NULL)		return SSH_ERR_ALLOC_FAIL;	if ((r = sshbuf_put_cstring(b, client_version_string)) != 0 ||	    (r = sshbuf_put_cstring(b, server_version_string)) != 0 ||	    /* kexinit messages: fake header: len+SSH2_MSG_KEXINIT */	    (r = sshbuf_put_u32(b, ckexinitlen+1)) != 0 ||	    (r = sshbuf_put_u8(b, SSH2_MSG_KEXINIT)) != 0 ||	    (r = sshbuf_put(b, ckexinit, ckexinitlen)) != 0 ||	    (r = sshbuf_put_u32(b, skexinitlen+1)) != 0 ||	    (r = sshbuf_put_u8(b, SSH2_MSG_KEXINIT)) != 0 ||	    (r = sshbuf_put(b, skexinit, skexinitlen)) != 0 ||	    (r = sshbuf_put_string(b, serverhostkeyblob, sbloblen)) != 0 ||	    (min != -1 && (r = sshbuf_put_u32(b, min)) != 0) ||	    (r = sshbuf_put_u32(b, wantbits)) != 0 ||	    (max != -1 && (r = sshbuf_put_u32(b, max)) != 0) ||	    (r = sshbuf_put_bignum2(b, prime)) != 0 ||	    (r = sshbuf_put_bignum2(b, gen)) != 0 ||	    (r = sshbuf_put_bignum2(b, client_dh_pub)) != 0 ||	    (r = sshbuf_put_bignum2(b, server_dh_pub)) != 0 ||	    (r = sshbuf_put_bignum2(b, shared_secret)) != 0) {		sshbuf_free(b);		return r;	}#ifdef DEBUG_KEXDH	sshbuf_dump(b, stderr);#endif	if (ssh_digest_buffer(hash_alg, b, digest, sizeof(digest)) != 0) {		sshbuf_free(b);		return SSH_ERR_LIBCRYPTO_ERROR;	}	sshbuf_free(b);	*hash = digest;	*hashlen = ssh_digest_bytes(hash_alg);#ifdef DEBUG_KEXDH	dump_digest("hash", digest, *hashlen);#endif	return 0;}

voidbuffer_put_string(Buffer *buffer, const void *buf, u_int len){	int ret;	if ((ret = sshbuf_put_string(buffer, buf, len)) != 0)		fatal("%s: %s", __func__, ssh_err(ret));}

intssh_ed25519_sign(const struct sshkey *key, u_char **sigp, size_t *lenp,    const u_char *data, size_t datalen, u_int compat){	u_char *sig = NULL;	size_t slen = 0, len;	unsigned long long smlen;	int r, ret;	struct sshbuf *b = NULL;	if (lenp != NULL)		*lenp = 0;	if (sigp != NULL)		*sigp = NULL;	if (key == NULL ||	    sshkey_type_plain(key->type) != KEY_ED25519 ||	    key->ed25519_sk == NULL ||	    datalen >= INT_MAX - crypto_sign_ed25519_BYTES)		return SSH_ERR_INVALID_ARGUMENT;	smlen = slen = datalen + crypto_sign_ed25519_BYTES;	if ((sig = malloc(slen)) == NULL)		return SSH_ERR_ALLOC_FAIL;	if ((ret = crypto_sign_ed25519(sig, &smlen, data, datalen,	    key->ed25519_sk)) != 0 || smlen <= datalen) {		r = SSH_ERR_INVALID_ARGUMENT; /* XXX better error? */		goto out;	}	/* encode signature */	if ((b = sshbuf_new()) == NULL) {		r = SSH_ERR_ALLOC_FAIL;		goto out;	}	if ((r = sshbuf_put_cstring(b, "ssh-ed25519")) != 0 ||	    (r = sshbuf_put_string(b, sig, smlen - datalen)) != 0)		goto out;	len = sshbuf_len(b);	if (sigp != NULL) {		if ((*sigp = malloc(len)) == NULL) {			r = SSH_ERR_ALLOC_FAIL;			goto out;		}		memcpy(*sigp, sshbuf_ptr(b), len);	}	if (lenp != NULL)		*lenp = len;	/* success */	r = 0; out:	sshbuf_free(b);	if (sig != NULL) {		explicit_bzero(sig, slen);		free(sig);	}	return r;}

intkex_ecdh_hash(    const EVP_MD *evp_md,    const EC_GROUP *ec_group,    const char *client_version_string,    const char *server_version_string,    const u_char *ckexinit, size_t ckexinitlen,    const u_char *skexinit, size_t skexinitlen,    const u_char *serverhostkeyblob, size_t sbloblen,    const EC_POINT *client_dh_pub,    const EC_POINT *server_dh_pub,    const BIGNUM *shared_secret,    u_char **hash, size_t *hashlen){	struct sshbuf *b;	EVP_MD_CTX md;	static u_char digest[EVP_MAX_MD_SIZE];	int r;	if ((b = sshbuf_new()) == NULL)		return SSH_ERR_ALLOC_FAIL;	if ((r = sshbuf_put_cstring(b, client_version_string)) != 0 ||	    (r = sshbuf_put_cstring(b, server_version_string)) != 0 ||	    /* kexinit messages: fake header: len+SSH2_MSG_KEXINIT */	    (r = sshbuf_put_u32(b, ckexinitlen+1)) != 0 ||	    (r = sshbuf_put_u8(b, SSH2_MSG_KEXINIT)) != 0 ||	    (r = sshbuf_put(b, ckexinit, ckexinitlen)) != 0 ||	    (r = sshbuf_put_u32(b, skexinitlen+1)) != 0 ||	    (r = sshbuf_put_u8(b, SSH2_MSG_KEXINIT)) != 0 ||	    (r = sshbuf_put(b, skexinit, skexinitlen)) != 0 ||	    (r = sshbuf_put_string(b, serverhostkeyblob, sbloblen)) != 0 ||	    (r = sshbuf_put_ec(b, client_dh_pub, ec_group)) != 0 ||	    (r = sshbuf_put_ec(b, server_dh_pub, ec_group)) != 0 ||	    (r = sshbuf_put_bignum2(b, shared_secret)) != 0) {		sshbuf_free(b);		return r;	}#ifdef DEBUG_KEX	sshbuf_dump(b, stderr);#endif	if (EVP_DigestInit(&md, evp_md) != 1 ||	    EVP_DigestUpdate(&md, sshbuf_ptr(b), sshbuf_len(b)) != 1 ||	    EVP_DigestFinal(&md, digest, NULL) != 1) {		sshbuf_free(b);		return SSH_ERR_LIBCRYPTO_ERROR;	}	sshbuf_free(b);#ifdef DEBUG_KEX	dump_digest("hash", digest, EVP_MD_size(evp_md));#endif	*hash = digest;	*hashlen = EVP_MD_size(evp_md);	return 0;}

static intpkcs11_rsa_private_encrypt(int flen, const u_char *from, u_char *to, RSA *rsa,    int padding){	struct sshkey key;	u_char *blob, *signature = NULL;	size_t blen, slen = 0;	int r, ret = -1;	struct sshbuf *msg;	if (padding != RSA_PKCS1_PADDING)		return (-1);	key.type = KEY_RSA;	key.rsa = rsa;	if ((r = sshkey_to_blob(&key, &blob, &blen)) != 0) {		error("%s: sshkey_to_blob: %s", __func__, ssh_err(r));		return -1;	}	if ((msg = sshbuf_new()) == NULL)		fatal("%s: sshbuf_new failed", __func__);	if ((r = sshbuf_put_u8(msg, SSH2_AGENTC_SIGN_REQUEST)) != 0 ||	    (r = sshbuf_put_string(msg, blob, blen)) != 0 ||	    (r = sshbuf_put_string(msg, from, flen)) != 0 ||	    (r = sshbuf_put_u32(msg, 0)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	xfree(blob);	send_msg(msg);	sshbuf_reset(msg);	if (recv_msg(msg) == SSH2_AGENT_SIGN_RESPONSE) {		if ((r = sshbuf_get_string(msg, &signature, &slen)) != 0)			fatal("%s: buffer error: %s", __func__, ssh_err(r));		if (slen <= (size_t)RSA_size(rsa)) {			memcpy(to, signature, slen);			ret = slen;		}		xfree(signature);	}	sshbuf_free(msg);	return (ret);}

voidssh_gssapi_buildmic(struct sshbuf *b, const char *user, const char *service,    const char *context){	int r;	sshbuf_reset(b);	if ((r = sshbuf_put_string(b, session_id2, session_id2_len)) != 0 ||	    (r = sshbuf_put_u8(b, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||	    (r = sshbuf_put_cstring(b, user)) != 0 ||	    (r = sshbuf_put_cstring(b, service)) != 0 ||	    (r = sshbuf_put_cstring(b, context)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));}

intmm_answer_rsa_keyallowed(int sock, struct sshbuf *m){	BIGNUM *client_n;	struct sshkey *key = NULL;	u_char *blob = NULL;	size_t blen = 0;	int r, allowed = 0;	debug3("%s entering", __func__);	auth_method = "rsa";	if (options.rsa_authentication && authctxt->valid) {		if ((client_n = BN_new()) == NULL)			fatal("%s: BN_new", __func__);		if ((r = sshbuf_get_bignum2(m, client_n)) != 0)			fatal("%s: buffer error: %s", __func__, ssh_err(r));		allowed = auth_rsa_key_allowed(authctxt->pw, client_n, &key);		BN_clear_free(client_n);	}	sshbuf_reset(m);	if ((r = sshbuf_put_u32(m, allowed)) != 0 ||	    (r = sshbuf_put_u32(m, forced_command != NULL)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	/* clear temporarily storage (used by generate challenge) */	monitor_reset_key_state();	if (allowed && key != NULL) {		key->type = KEY_RSA;	/* cheat for key_to_blob */		if ((r = sshkey_to_blob(key, &blob, &blen)) != 0)			fatal("%s: key_to_blob failed: %s",			    __func__, ssh_err(r));		if ((r = sshbuf_put_string(m, blob, blen)) != 0)			fatal("%s: buffer error: %s", __func__, ssh_err(r));		/* Save temporarily for comparison in verify */		key_blob = blob;		key_bloblen = blen;		key_blobtype = MM_RSAUSERKEY;	}	if (key != NULL)		sshkey_free(key);	mm_request_send(sock, MONITOR_ANS_RSAKEYALLOWED, m);	monitor_permit(mon_dispatch, MONITOR_REQ_RSACHALLENGE, allowed);	monitor_permit(mon_dispatch, MONITOR_REQ_RSARESPONSE, 0);	return (0);}

intsshkey_xmss_serialize_enc_key(const struct sshkey *k, struct sshbuf *b){	struct ssh_xmss_state *state = k->xmss_state;	int r;	if (state == NULL || state->enc_keyiv == NULL ||	    state->enc_ciphername == NULL)		return SSH_ERR_INVALID_ARGUMENT;	if ((r = sshbuf_put_cstring(b, state->enc_ciphername)) != 0 ||	    (r = sshbuf_put_string(b, state->enc_keyiv,	    state->enc_keyiv_len)) != 0)		return r;	return 0;}

static voidsend_data_or_handle(char type, u_int32_t id, const u_char *data, int dlen){	struct sshbuf *msg;	int r;	if ((msg = sshbuf_new()) == NULL)		fatal("%s: sshbuf_new failed", __func__);	if ((r = sshbuf_put_u8(msg, type)) != 0 ||	    (r = sshbuf_put_u32(msg, id)) != 0 ||	    (r = sshbuf_put_string(msg, data, dlen)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	send_msg(msg);	sshbuf_free(msg);}

/* * Removes an identity from the authentication server. * This call is intended only for use by ssh-add(1) and like applications. */intssh_remove_identity(int sock, struct sshkey *key){	struct sshbuf *msg;	int r;	u_char type, *blob = NULL;	size_t blen;	if ((msg = sshbuf_new()) == NULL)		return SSH_ERR_ALLOC_FAIL;#ifdef WITH_SSH1	if (key->type == KEY_RSA1) {		if ((r = sshbuf_put_u8(msg,		    SSH_AGENTC_REMOVE_RSA_IDENTITY)) != 0 ||		    (r = sshbuf_put_u32(msg, BN_num_bits(key->rsa->n))) != 0 ||		    (r = sshbuf_put_bignum1(msg, key->rsa->e)) != 0 ||		    (r = sshbuf_put_bignum1(msg, key->rsa->n)) != 0)			goto out;	} else#endif	if (key->type != KEY_UNSPEC) {		if ((r = sshkey_to_blob(key, &blob, &blen)) != 0)			goto out;		if ((r = sshbuf_put_u8(msg,		    SSH2_AGENTC_REMOVE_IDENTITY)) != 0 ||		    (r = sshbuf_put_string(msg, blob, blen)) != 0)			goto out;	} else {		r = SSH_ERR_INVALID_ARGUMENT;		goto out;	}	if ((r = ssh_request_reply(sock, msg, msg)) != 0)		goto out;	if ((r = sshbuf_get_u8(msg, &type)) != 0)		goto out;	r = decode_reply(type); out:	if (blob != NULL) {		explicit_bzero(blob, blen);		free(blob);	}	sshbuf_free(msg);	return r;}

intsshbuf_put_bignum2(struct sshbuf *buf, const BIGNUM *v){	u_char d[SSHBUF_MAX_BIGNUM + 1];	int len = BN_num_bytes(v), prepend = 0, r;	if (len < 0 || len > SSHBUF_MAX_BIGNUM)		return SSH_ERR_INVALID_ARGUMENT;	*d = '/0';	if (BN_bn2bin(v, d + 1) != len)		return SSH_ERR_INTERNAL_ERROR; /* Shouldn't happen */	/* If MSB is set, prepend a /0 */	if (len > 0 && (d[1] & 0x80) != 0)		prepend = 1;	if ((r = sshbuf_put_string(buf, d + 1 - prepend, len + prepend)) < 0) {		bzero(d, sizeof(d));		return r;	}	bzero(d, sizeof(d));	return 0;}

intsshkey_xmss_serialize_state(const struct sshkey *k, struct sshbuf *b){	struct ssh_xmss_state *state = k->xmss_state;	treehash_inst *th;	u_int32_t i, node;	int r;	if (state == NULL)		return SSH_ERR_INVALID_ARGUMENT;	if (state->stack == NULL)		return SSH_ERR_INVALID_ARGUMENT;	state->stackoffset = state->bds.stackoffset;	/* copy back */	if ((r = sshbuf_put_cstring(b, SSH_XMSS_K2_MAGIC)) != 0 ||	    (r = sshbuf_put_u32(b, state->idx)) != 0 ||	    (r = sshbuf_put_string(b, state->stack, num_stack(state))) != 0 ||	    (r = sshbuf_put_u32(b, state->stackoffset)) != 0 ||	    (r = sshbuf_put_string(b, state->stacklevels, num_stacklevels(state))) != 0 ||	    (r = sshbuf_put_string(b, state->auth, num_auth(state))) != 0 ||	    (r = sshbuf_put_string(b, state->keep, num_keep(state))) != 0 ||	    (r = sshbuf_put_string(b, state->th_nodes, num_th_nodes(state))) != 0 ||	    (r = sshbuf_put_string(b, state->retain, num_retain(state))) != 0 ||	    (r = sshbuf_put_u32(b, num_treehash(state))) != 0)		return r;	for (i = 0; i < num_treehash(state); i++) {		th = &state->treehash[i];		node = th->node - state->th_nodes;		if ((r = sshbuf_put_u32(b, th->h)) != 0 ||		    (r = sshbuf_put_u32(b, th->next_idx)) != 0 ||		    (r = sshbuf_put_u32(b, th->stackusage)) != 0 ||		    (r = sshbuf_put_u8(b, th->completed)) != 0 ||		    (r = sshbuf_put_u32(b, node)) != 0)			return r;	}	return 0;}

static intserver_input_hostkeys_prove(struct sshbuf **respp){	struct ssh *ssh = active_state; /* XXX */	struct sshbuf *resp = NULL;	struct sshbuf *sigbuf = NULL;	struct sshkey *key = NULL, *key_pub = NULL, *key_prv = NULL;	int r, ndx, success = 0;	const u_char *blob;	u_char *sig = 0;	size_t blen, slen;	if ((resp = sshbuf_new()) == NULL || (sigbuf = sshbuf_new()) == NULL)		fatal("%s: sshbuf_new", __func__);	while (ssh_packet_remaining(ssh) > 0) {		sshkey_free(key);		key = NULL;		if ((r = sshpkt_get_string_direct(ssh, &blob, &blen)) != 0 ||		    (r = sshkey_from_blob(blob, blen, &key)) != 0) {			error("%s: couldn't parse key: %s",			    __func__, ssh_err(r));			goto out;		}		/*		 * Better check that this is actually one of our hostkeys		 * before attempting to sign anything with it.		 */		if ((ndx = ssh->kex->host_key_index(key, 1, ssh)) == -1) {			error("%s: unknown host %s key",			    __func__, sshkey_type(key));			goto out;		}		/*		 * XXX refactor: make kex->sign just use an index rather		 * than passing in public and private keys		 */		if ((key_prv = get_hostkey_by_index(ndx)) == NULL &&		    (key_pub = get_hostkey_public_by_index(ndx, ssh)) == NULL) {			error("%s: can't retrieve hostkey %d", __func__, ndx);			goto out;		}		sshbuf_reset(sigbuf);		free(sig);		sig = NULL;		if ((r = sshbuf_put_cstring(sigbuf,		    "[email
C++ sshbuf_put_u32函数代码示例
C++ sshbuf_put_cstring函数代码示例