cred.c 4.63 KB
Newer Older
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
3 4 5 6 7 8 9
 *
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
 */

#include "git2.h"
#include "smart.h"
10
#include "git2/cred_helpers.h"
11

12 13 14 15 16 17 18 19 20 21
int git_cred_has_username(git_cred *cred)
{
	int ret = 0;

	switch (cred->credtype) {
	case GIT_CREDTYPE_USERPASS_PLAINTEXT: {
		git_cred_userpass_plaintext *c = (git_cred_userpass_plaintext *)cred;
		ret = !!c->username;
		break;
	}
22 23
	case GIT_CREDTYPE_SSH_KEY: {
		git_cred_ssh_key *c = (git_cred_ssh_key *)cred;
24 25 26
		ret = !!c->username;
		break;
	}
27 28
	case GIT_CREDTYPE_SSH_CUSTOM: {
		git_cred_ssh_custom *c = (git_cred_ssh_custom *)cred;
29 30 31
		ret = !!c->username;
		break;
	}
32 33 34 35
	case GIT_CREDTYPE_DEFAULT: {
		ret = 0;
		break;
	}
36 37 38 39 40
	}

	return ret;
}

41 42 43 44 45 46 47
static void plaintext_free(struct git_cred *cred)
{
	git_cred_userpass_plaintext *c = (git_cred_userpass_plaintext *)cred;

	git__free(c->username);

	/* Zero the memory which previously held the password */
48 49 50 51 52
	if (c->password) {
		size_t pass_len = strlen(c->password);
		git__memzero(c->password, pass_len);
		git__free(c->password);
	}
53

54
	git__memzero(c, sizeof(*c));
55 56 57 58 59 60 61 62 63 64
	git__free(c);
}

int git_cred_userpass_plaintext_new(
	git_cred **cred,
	const char *username,
	const char *password)
{
	git_cred_userpass_plaintext *c;

65
	assert(cred && username && password);
66

67
	c = git__malloc(sizeof(git_cred_userpass_plaintext));
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
	GITERR_CHECK_ALLOC(c);

	c->parent.credtype = GIT_CREDTYPE_USERPASS_PLAINTEXT;
	c->parent.free = plaintext_free;
	c->username = git__strdup(username);

	if (!c->username) {
		git__free(c);
		return -1;
	}

	c->password = git__strdup(password);

	if (!c->password) {
		git__free(c->username);
		git__free(c);
		return -1;
	}

	*cred = &c->parent;
	return 0;
89
}
Brad Morgan committed
90

91
static void ssh_key_free(struct git_cred *cred)
Brad Morgan committed
92
{
93 94
	git_cred_ssh_key *c =
		(git_cred_ssh_key *)cred;
95

96
	git__free(c->username);
97
	git__free(c->publickey);
Brad Morgan committed
98 99
	git__free(c->privatekey);

Russell Belfer committed
100 101
	if (c->passphrase) {
		/* Zero the memory which previously held the passphrase */
102
		size_t pass_len = strlen(c->passphrase);
Russell Belfer committed
103 104 105
		git__memzero(c->passphrase, pass_len);
		git__free(c->passphrase);
	}
Brad Morgan committed
106

107
	git__memzero(c, sizeof(*c));
Brad Morgan committed
108 109 110
	git__free(c);
}

111
static void ssh_custom_free(struct git_cred *cred)
112
{
113
	git_cred_ssh_custom *c = (git_cred_ssh_custom *)cred;
114

115
	git__free(c->username);
Russell Belfer committed
116
	git__free(c->publickey);
117

118
	git__memzero(c, sizeof(*c));
119 120 121
	git__free(c);
}

122 123 124 125 126 127 128
static void default_free(struct git_cred *cred)
{
	git_cred_default *c = (git_cred_default *)cred;

	git__free(c);
}

129
int git_cred_ssh_key_new(
Brad Morgan committed
130
	git_cred **cred,
131
	const char *username,
Brad Morgan committed
132 133 134 135
	const char *publickey,
	const char *privatekey,
	const char *passphrase)
{
136
	git_cred_ssh_key *c;
Brad Morgan committed
137

138
	assert(cred && privatekey);
Brad Morgan committed
139

140
	c = git__calloc(1, sizeof(git_cred_ssh_key));
Brad Morgan committed
141 142
	GITERR_CHECK_ALLOC(c);

143 144
	c->parent.credtype = GIT_CREDTYPE_SSH_KEY;
	c->parent.free = ssh_key_free;
145

146 147 148 149 150
	if (username) {
		c->username = git__strdup(username);
		GITERR_CHECK_ALLOC(c->username);
	}

Russell Belfer committed
151
	c->privatekey = git__strdup(privatekey);
152
	GITERR_CHECK_ALLOC(c->privatekey);
153

Russell Belfer committed
154
	if (publickey) {
155 156 157
		c->publickey = git__strdup(publickey);
		GITERR_CHECK_ALLOC(c->publickey);
	}
158

159 160 161 162
	if (passphrase) {
		c->passphrase = git__strdup(passphrase);
		GITERR_CHECK_ALLOC(c->passphrase);
	}
Brad Morgan committed
163 164

	*cred = &c->parent;
165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
	return 0;
}

int git_cred_ssh_key_from_agent(git_cred **cred, const char *username) {
	git_cred_ssh_key *c;

	assert(cred);

	c = git__calloc(1, sizeof(git_cred_ssh_key));
	GITERR_CHECK_ALLOC(c);

	c->parent.credtype = GIT_CREDTYPE_SSH_KEY;
	c->parent.free = ssh_key_free;

	if (username) {
		c->username = git__strdup(username);
		GITERR_CHECK_ALLOC(c->username);
	}

	c->privatekey = NULL;

	*cred = &c->parent;
Brad Morgan committed
187
	return 0;
188 189
}

190
int git_cred_ssh_custom_new(
191
	git_cred **cred,
192
	const char *username,
193
	const char *publickey,
Russell Belfer committed
194
	size_t publickey_len,
195
	git_cred_sign_callback sign_callback,
Russell Belfer committed
196
	void *sign_data)
197
{
198
	git_cred_ssh_custom *c;
199

200
	assert(cred);
201

202
	c = git__calloc(1, sizeof(git_cred_ssh_custom));
203 204
	GITERR_CHECK_ALLOC(c);

205 206
	c->parent.credtype = GIT_CREDTYPE_SSH_CUSTOM;
	c->parent.free = ssh_custom_free;
207

208 209 210 211 212
	if (username) {
		c->username = git__strdup(username);
		GITERR_CHECK_ALLOC(c->username);
	}

213 214 215
	if (publickey_len > 0) {
		c->publickey = git__malloc(publickey_len);
		GITERR_CHECK_ALLOC(c->publickey);
216

217 218
		memcpy(c->publickey, publickey, publickey_len);
	}
219

Russell Belfer committed
220 221 222
	c->publickey_len = publickey_len;
	c->sign_callback = sign_callback;
	c->sign_data = sign_data;
223 224 225

	*cred = &c->parent;
	return 0;
226
}
227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242

int git_cred_default_new(git_cred **cred)
{
	git_cred_default *c;

	assert(cred);

	c = git__calloc(1, sizeof(git_cred_default));
	GITERR_CHECK_ALLOC(c);

	c->credtype = GIT_CREDTYPE_DEFAULT;
	c->free = default_free;

	*cred = c;
	return 0;
}