lib/libssh2
1
0
Fork 0
mirror of https://github.com/libssh2/libssh2.git synced 2025-08-08 19:02:07 +03:00
Code Activity

src: fix checksrc warnings

Browse Source 
Use checksrc.pl from the curl project, with (for now)
suppressed long line warnings and indentation set to
4 spaces. Fixes are whitespace for the most part.

Warning count went down from 2704 to 12.

Also fix codespell typos, two non-ANSI C89 comments
and a stray tab in include/libssh2.h.

Ref: https://github.com/libssh2/libssh2/pull/235
This commit is contained in:
Viktor Szakats
2018-03-12 11:08:21 +00:00
parent fad6e5bb02
commit e54ef175d4
30 changed files with 2788 additions and 2612 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/libssh2.h
View File

@@ -968,7 +968,7 @@ libssh2_knownhost_init(LIBSSH2_SESSION *session);
#define LIBSSH2_KNOWNHOST_KEY_RSA1 (1<<18) #define LIBSSH2_KNOWNHOST_KEY_RSA1 (1<<18)
#define LIBSSH2_KNOWNHOST_KEY_SSHRSA (2<<18) #define LIBSSH2_KNOWNHOST_KEY_SSHRSA (2<<18)
#define LIBSSH2_KNOWNHOST_KEY_SSHDSS (3<<18) #define LIBSSH2_KNOWNHOST_KEY_SSHDSS (3<<18)
#define LIBSSH2_KNOWNHOST_KEY_ECDSA (4<<18) #define LIBSSH2_KNOWNHOST_KEY_ECDSA (4<<18)
#define LIBSSH2_KNOWNHOST_KEY_UNKNOWN (7<<18) #define LIBSSH2_KNOWNHOST_KEY_UNKNOWN (7<<18)
LIBSSH2_API int LIBSSH2_API int

138
src/agent.c
View File

@@ -148,21 +148,21 @@ agent_connect_unix(LIBSSH2_AGENT *agent)
struct sockaddr_un s_un; struct sockaddr_un s_un;
path = getenv("SSH_AUTH_SOCK"); path = getenv("SSH_AUTH_SOCK");
if (!path) if(!path)
return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_USE, return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_USE,
"no auth sock variable"); "no auth sock variable");
agent->fd = socket(PF_UNIX, SOCK_STREAM, 0); agent->fd = socket(PF_UNIX, SOCK_STREAM, 0);
if (agent->fd < 0) if(agent->fd < 0)
return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_SOCKET, return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_SOCKET,
"failed creating socket"); "failed creating socket");
s_un.sun_family = AF_UNIX; s_un.sun_family = AF_UNIX;
strncpy (s_un.sun_path, path, sizeof s_un.sun_path); strncpy(s_un.sun_path, path, sizeof s_un.sun_path);
s_un.sun_path[sizeof(s_un.sun_path)-1]=0; /* make sure there's a trailing s_un.sun_path[sizeof(s_un.sun_path)-1] = 0; /* make sure there's a trailing
zero */ zero */
if (connect(agent->fd, (struct sockaddr*)(&s_un), sizeof s_un) != 0) { if(connect(agent->fd, (struct sockaddr*)(&s_un), sizeof s_un) != 0) {
close (agent->fd); close(agent->fd);
return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL, return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
"failed connecting with agent"); "failed connecting with agent");
} }
@@ -177,34 +177,34 @@ agent_transact_unix(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
int rc; int rc;
/* Send the length of the request */ /* Send the length of the request */
if (transctx->state == agent_NB_state_request_created) { if(transctx->state == agent_NB_state_request_created) {
_libssh2_htonu32(buf, transctx->request_len); _libssh2_htonu32(buf, transctx->request_len);
rc = LIBSSH2_SEND_FD(agent->session, agent->fd, buf, sizeof buf, 0); rc = LIBSSH2_SEND_FD(agent->session, agent->fd, buf, sizeof buf, 0);
if (rc == -EAGAIN) if(rc == -EAGAIN)
return LIBSSH2_ERROR_EAGAIN; return LIBSSH2_ERROR_EAGAIN;
else if (rc < 0) else if(rc < 0)
return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_SEND, return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_SEND,
"agent send failed"); "agent send failed");
transctx->state = agent_NB_state_request_length_sent; transctx->state = agent_NB_state_request_length_sent;
} }
/* Send the request body */ /* Send the request body */
if (transctx->state == agent_NB_state_request_length_sent) { if(transctx->state == agent_NB_state_request_length_sent) {
rc = LIBSSH2_SEND_FD(agent->session, agent->fd, transctx->request, rc = LIBSSH2_SEND_FD(agent->session, agent->fd, transctx->request,
transctx->request_len, 0); transctx->request_len, 0);
if (rc == -EAGAIN) if(rc == -EAGAIN)
return LIBSSH2_ERROR_EAGAIN; return LIBSSH2_ERROR_EAGAIN;
else if (rc < 0) else if(rc < 0)
return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_SEND, return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_SEND,
"agent send failed"); "agent send failed");
transctx->state = agent_NB_state_request_sent; transctx->state = agent_NB_state_request_sent;
} }
/* Receive the length of a response */ /* Receive the length of a response */
if (transctx->state == agent_NB_state_request_sent) { if(transctx->state == agent_NB_state_request_sent) {
rc = LIBSSH2_RECV_FD(agent->session, agent->fd, buf, sizeof buf, 0); rc = LIBSSH2_RECV_FD(agent->session, agent->fd, buf, sizeof buf, 0);
if (rc < 0) { if(rc < 0) {
if (rc == -EAGAIN) if(rc == -EAGAIN)
return LIBSSH2_ERROR_EAGAIN; return LIBSSH2_ERROR_EAGAIN;
return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_RECV, return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_RECV,
"agent recv failed"); "agent recv failed");
@@ -212,18 +212,18 @@ agent_transact_unix(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
transctx->response_len = _libssh2_ntohu32(buf); transctx->response_len = _libssh2_ntohu32(buf);
transctx->response = LIBSSH2_ALLOC(agent->session, transctx->response = LIBSSH2_ALLOC(agent->session,
transctx->response_len); transctx->response_len);
if (!transctx->response) if(!transctx->response)
return LIBSSH2_ERROR_ALLOC; return LIBSSH2_ERROR_ALLOC;
transctx->state = agent_NB_state_response_length_received; transctx->state = agent_NB_state_response_length_received;
} }
/* Receive the response body */ /* Receive the response body */
if (transctx->state == agent_NB_state_response_length_received) { if(transctx->state == agent_NB_state_response_length_received) {
rc = LIBSSH2_RECV_FD(agent->session, agent->fd, transctx->response, rc = LIBSSH2_RECV_FD(agent->session, agent->fd, transctx->response,
transctx->response_len, 0); transctx->response_len, 0);
if (rc < 0) { if(rc < 0) {
if (rc == -EAGAIN) if(rc == -EAGAIN)
return LIBSSH2_ERROR_EAGAIN; return LIBSSH2_ERROR_EAGAIN;
return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_SEND, return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_SEND,
"agent recv failed"); "agent recv failed");
@@ -270,7 +270,7 @@ agent_connect_pageant(LIBSSH2_AGENT *agent)
{ {
HWND hwnd; HWND hwnd;
hwnd = FindWindow("Pageant", "Pageant"); hwnd = FindWindow("Pageant", "Pageant");
if (!hwnd) if(!hwnd)
return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL, return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
"failed connecting agent"); "failed connecting agent");
agent->fd = 0; /* Mark as the connection has been established */ agent->fd = 0; /* Mark as the connection has been established */
@@ -288,12 +288,12 @@ agent_transact_pageant(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
int id; int id;
COPYDATASTRUCT cds; COPYDATASTRUCT cds;
if (!transctx || 4 + transctx->request_len > PAGEANT_MAX_MSGLEN) if(!transctx || 4 + transctx->request_len > PAGEANT_MAX_MSGLEN)
return _libssh2_error(agent->session, LIBSSH2_ERROR_INVAL, return _libssh2_error(agent->session, LIBSSH2_ERROR_INVAL,
"illegal input"); "illegal input");
hwnd = FindWindow("Pageant", "Pageant"); hwnd = FindWindow("Pageant", "Pageant");
if (!hwnd) if(!hwnd)
return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL, return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
"found no pageant"); "found no pageant");
@@ -301,12 +301,12 @@ agent_transact_pageant(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
filemap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, filemap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
0, PAGEANT_MAX_MSGLEN, mapname); 0, PAGEANT_MAX_MSGLEN, mapname);
if (filemap == NULL || filemap == INVALID_HANDLE_VALUE) if(filemap == NULL || filemap == INVALID_HANDLE_VALUE)
return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL, return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
"failed setting up pageant filemap"); "failed setting up pageant filemap");
p2 = p = MapViewOfFile(filemap, FILE_MAP_WRITE, 0, 0, 0); p2 = p = MapViewOfFile(filemap, FILE_MAP_WRITE, 0, 0, 0);
if (p == NULL || p2 == NULL) { if(p == NULL || p2 == NULL) {
CloseHandle(filemap); CloseHandle(filemap);
return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL, return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
"failed to open pageant filemap for writing"); "failed to open pageant filemap for writing");
@@ -320,9 +320,9 @@ agent_transact_pageant(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
cds.lpData = mapname; cds.lpData = mapname;
id = SendMessage(hwnd, WM_COPYDATA, (WPARAM) NULL, (LPARAM) &cds); id = SendMessage(hwnd, WM_COPYDATA, (WPARAM) NULL, (LPARAM) &cds);
if (id > 0) { if(id > 0) {
transctx->response_len = _libssh2_ntohu32(p); transctx->response_len = _libssh2_ntohu32(p);
if (transctx->response_len > PAGEANT_MAX_MSGLEN) { if(transctx->response_len > PAGEANT_MAX_MSGLEN) {
UnmapViewOfFile(p); UnmapViewOfFile(p);
CloseHandle(filemap); CloseHandle(filemap);
return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL, return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
@@ -330,7 +330,7 @@ agent_transact_pageant(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
} }
transctx->response = LIBSSH2_ALLOC(agent->session, transctx->response = LIBSSH2_ALLOC(agent->session,
transctx->response_len); transctx->response_len);
if (!transctx->response) { if(!transctx->response) {
UnmapViewOfFile(p); UnmapViewOfFile(p);
CloseHandle(filemap); CloseHandle(filemap);
return _libssh2_error(agent->session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(agent->session, LIBSSH2_ERROR_ALLOC,
@@ -384,9 +384,9 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
int rc; int rc;
/* Create a request to sign the data */ /* Create a request to sign the data */
if (transctx->state == agent_NB_state_init) { if(transctx->state == agent_NB_state_init) {
s = transctx->request = LIBSSH2_ALLOC(session, len); s = transctx->request = LIBSSH2_ALLOC(session, len);
if (!transctx->request) if(!transctx->request)
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"out of memory"); "out of memory");
@@ -405,17 +405,17 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
} }
/* Make sure to be re-called as a result of EAGAIN. */ /* Make sure to be re-called as a result of EAGAIN. */
if (*transctx->request != SSH2_AGENTC_SIGN_REQUEST) if(*transctx->request != SSH2_AGENTC_SIGN_REQUEST)
return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE, return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE,
"illegal request"); "illegal request");
if (!agent->ops) if(!agent->ops)
/* if no agent has been connected, bail out */ /* if no agent has been connected, bail out */
return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE, return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE,
"agent not connected"); "agent not connected");
rc = agent->ops->transact(agent, transctx); rc = agent->ops->transact(agent, transctx);
if (rc) { if(rc) {
goto error; goto error;
} }
LIBSSH2_FREE(session, transctx->request); LIBSSH2_FREE(session, transctx->request);
@@ -424,11 +424,11 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
len = transctx->response_len; len = transctx->response_len;
s = transctx->response; s = transctx->response;
len--; len--;
if (len < 0) { if(len < 0) {
rc = LIBSSH2_ERROR_AGENT_PROTOCOL; rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
goto error; goto error;
} }
if (*s != SSH2_AGENT_SIGN_RESPONSE) { if(*s != SSH2_AGENT_SIGN_RESPONSE) {
rc = LIBSSH2_ERROR_AGENT_PROTOCOL; rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
goto error; goto error;
} }
@@ -436,7 +436,7 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
/* Skip the entire length of the signature */ /* Skip the entire length of the signature */
len -= 4; len -= 4;
if (len < 0) { if(len < 0) {
rc = LIBSSH2_ERROR_AGENT_PROTOCOL; rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
goto error; goto error;
} }
@@ -444,14 +444,14 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
/* Skip signing method */ /* Skip signing method */
len -= 4; len -= 4;
if (len < 0) { if(len < 0) {
rc = LIBSSH2_ERROR_AGENT_PROTOCOL; rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
goto error; goto error;
} }
method_len = _libssh2_ntohu32(s); method_len = _libssh2_ntohu32(s);
s += 4; s += 4;
len -= method_len; len -= method_len;
if (len < 0) { if(len < 0) {
rc = LIBSSH2_ERROR_AGENT_PROTOCOL; rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
goto error; goto error;
} }
@@ -459,20 +459,20 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
/* Read the signature */ /* Read the signature */
len -= 4; len -= 4;
if (len < 0) { if(len < 0) {
rc = LIBSSH2_ERROR_AGENT_PROTOCOL; rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
goto error; goto error;
} }
*sig_len = _libssh2_ntohu32(s); *sig_len = _libssh2_ntohu32(s);
s += 4; s += 4;
len -= *sig_len; len -= *sig_len;
if (len < 0) { if(len < 0) {
rc = LIBSSH2_ERROR_AGENT_PROTOCOL; rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
goto error; goto error;
} }
*sig = LIBSSH2_ALLOC(session, *sig_len); *sig = LIBSSH2_ALLOC(session, *sig_len);
if (!*sig) { if(!*sig) {
rc = LIBSSH2_ERROR_ALLOC; rc = LIBSSH2_ERROR_ALLOC;
goto error; goto error;
} }
@@ -498,24 +498,24 @@ agent_list_identities(LIBSSH2_AGENT *agent)
unsigned char c = SSH2_AGENTC_REQUEST_IDENTITIES; unsigned char c = SSH2_AGENTC_REQUEST_IDENTITIES;
/* Create a request to list identities */ /* Create a request to list identities */
if (transctx->state == agent_NB_state_init) { if(transctx->state == agent_NB_state_init) {
transctx->request = &c; transctx->request = &c;
transctx->request_len = 1; transctx->request_len = 1;
transctx->state = agent_NB_state_request_created; transctx->state = agent_NB_state_request_created;
} }
/* Make sure to be re-called as a result of EAGAIN. */ /* Make sure to be re-called as a result of EAGAIN. */
if (*transctx->request != SSH2_AGENTC_REQUEST_IDENTITIES) if(*transctx->request != SSH2_AGENTC_REQUEST_IDENTITIES)
return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_USE, return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_USE,
"illegal agent request"); "illegal agent request");
if (!agent->ops) if(!agent->ops)
/* if no agent has been connected, bail out */ /* if no agent has been connected, bail out */
return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_USE, return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_USE,
"agent not connected"); "agent not connected");
rc = agent->ops->transact(agent, transctx); rc = agent->ops->transact(agent, transctx);
if (rc) { if(rc) {
goto error; goto error;
} }
transctx->request = NULL; transctx->request = NULL;
@@ -523,11 +523,11 @@ agent_list_identities(LIBSSH2_AGENT *agent)
len = transctx->response_len; len = transctx->response_len;
s = transctx->response; s = transctx->response;
len--; len--;
if (len < 0) { if(len < 0) {
rc = LIBSSH2_ERROR_AGENT_PROTOCOL; rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
goto error; goto error;
} }
if (*s != SSH2_AGENT_IDENTITIES_ANSWER) { if(*s != SSH2_AGENT_IDENTITIES_ANSWER) {
rc = LIBSSH2_ERROR_AGENT_PROTOCOL; rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
goto error; goto error;
} }
@@ -535,25 +535,25 @@ agent_list_identities(LIBSSH2_AGENT *agent)
/* Read the length of identities */ /* Read the length of identities */
len -= 4; len -= 4;
if (len < 0) { if(len < 0) {
rc = LIBSSH2_ERROR_AGENT_PROTOCOL; rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
goto error; goto error;
} }
num_identities = _libssh2_ntohu32(s); num_identities = _libssh2_ntohu32(s);
s += 4; s += 4;
while (num_identities--) { while(num_identities--) {
struct agent_publickey *identity; struct agent_publickey *identity;
ssize_t comment_len; ssize_t comment_len;
/* Read the length of the blob */ /* Read the length of the blob */
len -= 4; len -= 4;
if (len < 0) { if(len < 0) {
rc = LIBSSH2_ERROR_AGENT_PROTOCOL; rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
goto error; goto error;
} }
identity = LIBSSH2_ALLOC(agent->session, sizeof *identity); identity = LIBSSH2_ALLOC(agent->session, sizeof *identity);
if (!identity) { if(!identity) {
rc = LIBSSH2_ERROR_ALLOC; rc = LIBSSH2_ERROR_ALLOC;
goto error; goto error;
} }
@@ -562,7 +562,7 @@ agent_list_identities(LIBSSH2_AGENT *agent)
/* Read the blob */ /* Read the blob */
len -= identity->external.blob_len; len -= identity->external.blob_len;
if (len < 0) { if(len < 0) {
rc = LIBSSH2_ERROR_AGENT_PROTOCOL; rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
LIBSSH2_FREE(agent->session, identity); LIBSSH2_FREE(agent->session, identity);
goto error; goto error;
@@ -570,7 +570,7 @@ agent_list_identities(LIBSSH2_AGENT *agent)
identity->external.blob = LIBSSH2_ALLOC(agent->session, identity->external.blob = LIBSSH2_ALLOC(agent->session,
identity->external.blob_len); identity->external.blob_len);
if (!identity->external.blob) { if(!identity->external.blob) {
rc = LIBSSH2_ERROR_ALLOC; rc = LIBSSH2_ERROR_ALLOC;
LIBSSH2_FREE(agent->session, identity); LIBSSH2_FREE(agent->session, identity);
goto error; goto error;
@@ -580,7 +580,7 @@ agent_list_identities(LIBSSH2_AGENT *agent)
/* Read the length of the comment */ /* Read the length of the comment */
len -= 4; len -= 4;
if (len < 0) { if(len < 0) {
rc = LIBSSH2_ERROR_AGENT_PROTOCOL; rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
LIBSSH2_FREE(agent->session, identity->external.blob); LIBSSH2_FREE(agent->session, identity->external.blob);
LIBSSH2_FREE(agent->session, identity); LIBSSH2_FREE(agent->session, identity);
@@ -591,7 +591,7 @@ agent_list_identities(LIBSSH2_AGENT *agent)
/* Read the comment */ /* Read the comment */
len -= comment_len; len -= comment_len;
if (len < 0) { if(len < 0) {
rc = LIBSSH2_ERROR_AGENT_PROTOCOL; rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
LIBSSH2_FREE(agent->session, identity->external.blob); LIBSSH2_FREE(agent->session, identity->external.blob);
LIBSSH2_FREE(agent->session, identity); LIBSSH2_FREE(agent->session, identity);
@@ -600,7 +600,7 @@ agent_list_identities(LIBSSH2_AGENT *agent)
identity->external.comment = LIBSSH2_ALLOC(agent->session, identity->external.comment = LIBSSH2_ALLOC(agent->session,
comment_len + 1); comment_len + 1);
if (!identity->external.comment) { if(!identity->external.comment) {
rc = LIBSSH2_ERROR_ALLOC; rc = LIBSSH2_ERROR_ALLOC;
LIBSSH2_FREE(agent->session, identity->external.blob); LIBSSH2_FREE(agent->session, identity->external.blob);
LIBSSH2_FREE(agent->session, identity); LIBSSH2_FREE(agent->session, identity);
@@ -621,11 +621,12 @@ agent_list_identities(LIBSSH2_AGENT *agent)
} }
static void static void
agent_free_identities(LIBSSH2_AGENT *agent) { agent_free_identities(LIBSSH2_AGENT *agent)
{
struct agent_publickey *node; struct agent_publickey *node;
struct agent_publickey *next; struct agent_publickey *next;
for (node = _libssh2_list_first(&agent->head); node; node = next) { for(node = _libssh2_list_first(&agent->head); node; node = next) {
next = _libssh2_list_next(&node->node); next = _libssh2_list_next(&node->node);
LIBSSH2_FREE(agent->session, node->external.blob); LIBSSH2_FREE(agent->session, node->external.blob);
LIBSSH2_FREE(agent->session, node->external.comment); LIBSSH2_FREE(agent->session, node->external.comment);
@@ -664,7 +665,7 @@ libssh2_agent_init(LIBSSH2_SESSION *session)
LIBSSH2_AGENT *agent; LIBSSH2_AGENT *agent;
agent = LIBSSH2_CALLOC(session, sizeof *agent); agent = LIBSSH2_CALLOC(session, sizeof *agent);
if (!agent) { if(!agent) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate space for agent connection"); "Unable to allocate space for agent connection");
return NULL; return NULL;
@@ -687,10 +688,10 @@ LIBSSH2_API int
libssh2_agent_connect(LIBSSH2_AGENT *agent) libssh2_agent_connect(LIBSSH2_AGENT *agent)
{ {
int i, rc = -1; int i, rc = -1;
for (i = 0; supported_backends[i].name; i++) { for(i = 0; supported_backends[i].name; i++) {
agent->ops = supported_backends[i].ops; agent->ops = supported_backends[i].ops;
rc = (agent->ops->connect)(agent); rc = (agent->ops->connect)(agent);
if (!rc) if(!rc)
return 0; return 0;
} }
return rc; return rc;
@@ -707,7 +708,7 @@ LIBSSH2_API int
libssh2_agent_list_identities(LIBSSH2_AGENT *agent) libssh2_agent_list_identities(LIBSSH2_AGENT *agent)
{ {
memset(&agent->transctx, 0, sizeof agent->transctx); memset(&agent->transctx, 0, sizeof agent->transctx);
/* Abondon the last fetched identities */ /* Abandon the last fetched identities */
agent_free_identities(agent); agent_free_identities(agent);
return agent_list_identities(agent); return agent_list_identities(agent);
} }
@@ -730,7 +731,7 @@ libssh2_agent_get_identity(LIBSSH2_AGENT *agent,
struct libssh2_agent_publickey *oprev) struct libssh2_agent_publickey *oprev)
{ {
struct agent_publickey *node; struct agent_publickey *node;
if (oprev && oprev->node) { if(oprev && oprev->node) {
/* we have a starting point */ /* we have a starting point */
struct agent_publickey *prev = oprev->node; struct agent_publickey *prev = oprev->node;
@@ -740,7 +741,7 @@ libssh2_agent_get_identity(LIBSSH2_AGENT *agent,
else else
node = _libssh2_list_first(&agent->head); node = _libssh2_list_first(&agent->head);
if (!node) if(!node)
/* no (more) node */ /* no (more) node */
return 1; return 1;
@@ -764,7 +765,7 @@ libssh2_agent_userauth(LIBSSH2_AGENT *agent,
void *abstract = agent; void *abstract = agent;
int rc; int rc;
if (agent->session->userauth_pblc_state == libssh2_NB_state_idle) { if(agent->session->userauth_pblc_state == libssh2_NB_state_idle) {
memset(&agent->transctx, 0, sizeof agent->transctx); memset(&agent->transctx, 0, sizeof agent->transctx);
agent->identity = identity->node; agent->identity = identity->node;
} }
@@ -789,7 +790,7 @@ libssh2_agent_userauth(LIBSSH2_AGENT *agent,
LIBSSH2_API int LIBSSH2_API int
libssh2_agent_disconnect(LIBSSH2_AGENT *agent) libssh2_agent_disconnect(LIBSSH2_AGENT *agent)
{ {
if (agent->ops && agent->fd != LIBSSH2_INVALID_SOCKET) if(agent->ops && agent->fd != LIBSSH2_INVALID_SOCKET)
return agent->ops->disconnect(agent); return agent->ops->disconnect(agent);
return 0; return 0;
} }
@@ -801,9 +802,10 @@ libssh2_agent_disconnect(LIBSSH2_AGENT *agent)
* collection of public keys. * collection of public keys.
*/ */
LIBSSH2_API void LIBSSH2_API void
libssh2_agent_free(LIBSSH2_AGENT *agent) { libssh2_agent_free(LIBSSH2_AGENT *agent)
{
/* Allow connection freeing when the socket has lost its connection */ /* Allow connection freeing when the socket has lost its connection */
if (agent->fd != LIBSSH2_INVALID_SOCKET) { if(agent->fd != LIBSSH2_INVALID_SOCKET) {
libssh2_agent_disconnect(agent); libssh2_agent_disconnect(agent);
} }
agent_free_identities(agent); agent_free_identities(agent);

397
src/channel.c
View File

File diff suppressed because it is too large Load Diff

39
src/comp.c
View File

@@ -142,7 +142,7 @@ comp_method_zlib_init(LIBSSH2_SESSION * session, int compr,
int status; int status;
strm = LIBSSH2_CALLOC(session, sizeof(z_stream)); strm = LIBSSH2_CALLOC(session, sizeof(z_stream));
if (!strm) { if(!strm) {
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for " "Unable to allocate memory for "
"zlib compression/decompression"); "zlib compression/decompression");
@@ -151,15 +151,16 @@ comp_method_zlib_init(LIBSSH2_SESSION * session, int compr,
strm->opaque = (voidpf) session; strm->opaque = (voidpf) session;
strm->zalloc = (alloc_func) comp_method_zlib_alloc; strm->zalloc = (alloc_func) comp_method_zlib_alloc;
strm->zfree = (free_func) comp_method_zlib_free; strm->zfree = (free_func) comp_method_zlib_free;
if (compr) { if(compr) {
/* deflate */ /* deflate */
status = deflateInit(strm, Z_DEFAULT_COMPRESSION); status = deflateInit(strm, Z_DEFAULT_COMPRESSION);
} else { }
else {
/* inflate */ /* inflate */
status = inflateInit(strm); status = inflateInit(strm);
} }
if (status != Z_OK) { if(status != Z_OK) {
LIBSSH2_FREE(session, strm); LIBSSH2_FREE(session, strm);
_libssh2_debug(session, LIBSSH2_TRACE_TRANS, _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
"unhandled zlib error %d", status); "unhandled zlib error %d", status);
@@ -197,7 +198,7 @@ comp_method_zlib_comp(LIBSSH2_SESSION *session,
status = deflate(strm, Z_PARTIAL_FLUSH); status = deflate(strm, Z_PARTIAL_FLUSH);
if ((status == Z_OK) && (strm->avail_out > 0)) { if((status == Z_OK) && (strm->avail_out > 0)) {
*dest_len = out_maxlen - strm->avail_out; *dest_len = out_maxlen - strm->avail_out;
return 0; return 0;
} }
@@ -227,15 +228,15 @@ comp_method_zlib_decomp(LIBSSH2_SESSION * session,
int out_maxlen = 4 * src_len; int out_maxlen = 4 * src_len;
/* If strm is null, then we have not yet been initialized. */ /* If strm is null, then we have not yet been initialized. */
if (strm == NULL) if(strm == NULL)
return _libssh2_error(session, LIBSSH2_ERROR_COMPRESS, return _libssh2_error(session, LIBSSH2_ERROR_COMPRESS,
"decompression uninitialized");; "decompression uninitialized");;
/* In practice they never come smaller than this */ /* In practice they never come smaller than this */
if (out_maxlen < 25) if(out_maxlen < 25)
out_maxlen = 25; out_maxlen = 25;
if (out_maxlen > (int) payload_limit) if(out_maxlen > (int) payload_limit)
out_maxlen = payload_limit; out_maxlen = payload_limit;
strm->next_in = (unsigned char *) src; strm->next_in = (unsigned char *) src;
@@ -243,26 +244,28 @@ comp_method_zlib_decomp(LIBSSH2_SESSION * session,
strm->next_out = (unsigned char *) LIBSSH2_ALLOC(session, out_maxlen); strm->next_out = (unsigned char *) LIBSSH2_ALLOC(session, out_maxlen);
out = (char *) strm->next_out; out = (char *) strm->next_out;
strm->avail_out = out_maxlen; strm->avail_out = out_maxlen;
if (!strm->next_out) if(!strm->next_out)
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate decompression buffer"); "Unable to allocate decompression buffer");
/* Loop until it's all inflated or hit error */ /* Loop until it's all inflated or hit error */
for (;;) { for(;;) {
int status; int status;
size_t out_ofs; size_t out_ofs;
char *newout; char *newout;
status = inflate(strm, Z_PARTIAL_FLUSH); status = inflate(strm, Z_PARTIAL_FLUSH);
if (status == Z_OK) { if(status == Z_OK) {
if (strm->avail_out > 0) if(strm->avail_out > 0)
/* status is OK and the output buffer has not been exhausted so we're done */ /* status is OK and the output buffer has not been exhausted so we're done */
break; break;
} else if (status == Z_BUF_ERROR) { }
else if(status == Z_BUF_ERROR) {
/* the input data has been exhausted so we are done */ /* the input data has been exhausted so we are done */
break; break;
} else { }
else {
/* error state */ /* error state */
LIBSSH2_FREE(session, out); LIBSSH2_FREE(session, out);
_libssh2_debug(session, LIBSSH2_TRACE_TRANS, _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
@@ -271,7 +274,7 @@ comp_method_zlib_decomp(LIBSSH2_SESSION * session,
"decompression failure"); "decompression failure");
} }
if (out_maxlen >= (int) payload_limit) { if(out_maxlen >= (int) payload_limit) {
LIBSSH2_FREE(session, out); LIBSSH2_FREE(session, out);
return _libssh2_error(session, LIBSSH2_ERROR_ZLIB, return _libssh2_error(session, LIBSSH2_ERROR_ZLIB,
"Excessive growth in decompression phase"); "Excessive growth in decompression phase");
@@ -281,7 +284,7 @@ comp_method_zlib_decomp(LIBSSH2_SESSION * session,
out_ofs = out_maxlen - strm->avail_out; out_ofs = out_maxlen - strm->avail_out;
out_maxlen *= 2; out_maxlen *= 2;
newout = LIBSSH2_REALLOC(session, out, out_maxlen); newout = LIBSSH2_REALLOC(session, out, out_maxlen);
if (!newout) { if(!newout) {
LIBSSH2_FREE(session, out); LIBSSH2_FREE(session, out);
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to expand decompression buffer"); "Unable to expand decompression buffer");
@@ -306,8 +309,8 @@ comp_method_zlib_dtor(LIBSSH2_SESSION *session, int compr, void **abstract)
{ {
z_stream *strm = *abstract; z_stream *strm = *abstract;
if (strm) { if(strm) {
if (compr) if(compr)
deflateEnd(strm); deflateEnd(strm);
else else
inflateEnd(strm); inflateEnd(strm);

14
src/crypt.c
View File

@@ -80,12 +80,12 @@ crypt_init(LIBSSH2_SESSION * session,
{ {
struct crypt_ctx *ctx = LIBSSH2_ALLOC(session, struct crypt_ctx *ctx = LIBSSH2_ALLOC(session,
sizeof(struct crypt_ctx)); sizeof(struct crypt_ctx));
if (!ctx) if(!ctx)
return LIBSSH2_ERROR_ALLOC; return LIBSSH2_ERROR_ALLOC;
ctx->encrypt = encrypt; ctx->encrypt = encrypt;
ctx->algo = method->algo; ctx->algo = method->algo;
if (_libssh2_cipher_init(&ctx->h, ctx->algo, iv, secret, encrypt)) { if(_libssh2_cipher_init(&ctx->h, ctx->algo, iv, secret, encrypt)) {
LIBSSH2_FREE(session, ctx); LIBSSH2_FREE(session, ctx);
return -1; return -1;
} }
@@ -109,7 +109,7 @@ static int
crypt_dtor(LIBSSH2_SESSION * session, void **abstract) crypt_dtor(LIBSSH2_SESSION * session, void **abstract)
{ {
struct crypt_ctx **cctx = (struct crypt_ctx **) abstract; struct crypt_ctx **cctx = (struct crypt_ctx **) abstract;
if (cctx && *cctx) { if(cctx && *cctx) {
_libssh2_cipher_dtor(&(*cctx)->h); _libssh2_cipher_dtor(&(*cctx)->h);
LIBSSH2_FREE(session, *cctx); LIBSSH2_FREE(session, *cctx);
*abstract = NULL; *abstract = NULL;
@@ -252,13 +252,13 @@ crypt_init_arcfour128(LIBSSH2_SESSION * session,
{ {
int rc; int rc;
rc = crypt_init (session, method, iv, free_iv, secret, free_secret, rc = crypt_init(session, method, iv, free_iv, secret, free_secret,
encrypt, abstract); encrypt, abstract);
if (rc == 0) { if(rc == 0) {
struct crypt_ctx *cctx = *(struct crypt_ctx **) abstract; struct crypt_ctx *cctx = *(struct crypt_ctx **) abstract;
unsigned char block[8]; unsigned char block[8];
size_t discard = 1536; size_t discard = 1536;
for (; discard; discard -= 8) for(; discard; discard -= 8)
_libssh2_cipher_crypt(&cctx->h, cctx->algo, cctx->encrypt, block, _libssh2_cipher_crypt(&cctx->h, cctx->algo, cctx->encrypt, block,
method->blocksize); method->blocksize);
} }

8
src/global.c
View File

@@ -44,7 +44,7 @@ static int _libssh2_init_flags = 0;
LIBSSH2_API int LIBSSH2_API int
libssh2_init(int flags) libssh2_init(int flags)
{ {
if (_libssh2_initialized == 0 && !(flags & LIBSSH2_INIT_NO_CRYPTO)) { if(_libssh2_initialized == 0 && !(flags & LIBSSH2_INIT_NO_CRYPTO)) {
libssh2_crypto_init(); libssh2_crypto_init();
#if LIBSSH2_AES_CTR #if LIBSSH2_AES_CTR
_libssh2_init_aes_ctr(); _libssh2_init_aes_ctr();
@@ -60,12 +60,12 @@ libssh2_init(int flags)
LIBSSH2_API void LIBSSH2_API void
libssh2_exit(void) libssh2_exit(void)
{ {
if (_libssh2_initialized == 0) if(_libssh2_initialized == 0)
return; return;
_libssh2_initialized--; _libssh2_initialized--;
if (!(_libssh2_init_flags & LIBSSH2_INIT_NO_CRYPTO)) { if(!(_libssh2_init_flags & LIBSSH2_INIT_NO_CRYPTO)) {
libssh2_crypto_exit(); libssh2_crypto_exit();
} }
@@ -75,6 +75,6 @@ libssh2_exit(void)
void void
_libssh2_init_if_needed(void) _libssh2_init_if_needed(void)
{ {
if (_libssh2_initialized == 0) if(_libssh2_initialized == 0)
(void)libssh2_init (0); (void)libssh2_init (0);
} }

112
src/hostkey.c
View File

@@ -70,7 +70,7 @@ hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session,
(void) hostkey_data_len; (void) hostkey_data_len;
if (*abstract) { if(*abstract) {
hostkey_method_ssh_rsa_dtor(session, abstract); hostkey_method_ssh_rsa_dtor(session, abstract);
*abstract = NULL; *abstract = NULL;
} }
@@ -79,7 +79,7 @@ hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session,
len = _libssh2_ntohu32(s); len = _libssh2_ntohu32(s);
s += 4; s += 4;
if (len != 7 || strncmp((char *) s, "ssh-rsa", 7) != 0) { if(len != 7 || strncmp((char *) s, "ssh-rsa", 7) != 0) {
return -1; return -1;
} }
s += 7; s += 7;
@@ -95,7 +95,7 @@ hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session,
ret = _libssh2_rsa_new(&rsactx, e, e_len, n, n_len, NULL, 0, ret = _libssh2_rsa_new(&rsactx, e, e_len, n, n_len, NULL, 0,
NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0); NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0);
if (ret) { if(ret) {
return -1; return -1;
} }
@@ -118,13 +118,13 @@ hostkey_method_ssh_rsa_initPEM(LIBSSH2_SESSION * session,
libssh2_rsa_ctx *rsactx; libssh2_rsa_ctx *rsactx;
int ret; int ret;
if (*abstract) { if(*abstract) {
hostkey_method_ssh_rsa_dtor(session, abstract); hostkey_method_ssh_rsa_dtor(session, abstract);
*abstract = NULL; *abstract = NULL;
} }
ret = _libssh2_rsa_new_private(&rsactx, session, privkeyfile, passphrase); ret = _libssh2_rsa_new_private(&rsactx, session, privkeyfile, passphrase);
if (ret) { if(ret) {
return -1; return -1;
} }
@@ -148,7 +148,7 @@ hostkey_method_ssh_rsa_initPEMFromMemory(LIBSSH2_SESSION * session,
libssh2_rsa_ctx *rsactx; libssh2_rsa_ctx *rsactx;
int ret; int ret;
if (*abstract) { if(*abstract) {
hostkey_method_ssh_rsa_dtor(session, abstract); hostkey_method_ssh_rsa_dtor(session, abstract);
*abstract = NULL; *abstract = NULL;
} }
@@ -156,7 +156,7 @@ hostkey_method_ssh_rsa_initPEMFromMemory(LIBSSH2_SESSION * session,
ret = _libssh2_rsa_new_private_frommemory(&rsactx, session, ret = _libssh2_rsa_new_private_frommemory(&rsactx, session,
privkeyfiledata, privkeyfiledata,
privkeyfiledata_len, passphrase); privkeyfiledata_len, passphrase);
if (ret) { if(ret) {
return -1; return -1;
} }
@@ -218,7 +218,7 @@ hostkey_method_ssh_rsa_signv(LIBSSH2_SESSION * session,
ret = _libssh2_rsa_sha1_sign(session, rsactx, hash, SHA_DIGEST_LENGTH, ret = _libssh2_rsa_sha1_sign(session, rsactx, hash, SHA_DIGEST_LENGTH,
signature, signature_len); signature, signature_len);
if (ret) { if(ret) {
return -1; return -1;
} }
@@ -287,7 +287,7 @@ hostkey_method_ssh_dss_init(LIBSSH2_SESSION * session,
(void) hostkey_data_len; (void) hostkey_data_len;
if (*abstract) { if(*abstract) {
hostkey_method_ssh_dss_dtor(session, abstract); hostkey_method_ssh_dss_dtor(session, abstract);
*abstract = NULL; *abstract = NULL;
} }
@@ -295,7 +295,7 @@ hostkey_method_ssh_dss_init(LIBSSH2_SESSION * session,
s = hostkey_data; s = hostkey_data;
len = _libssh2_ntohu32(s); len = _libssh2_ntohu32(s);
s += 4; s += 4;
if (len != 7 || strncmp((char *) s, "ssh-dss", 7) != 0) { if(len != 7 || strncmp((char *) s, "ssh-dss", 7) != 0) {
return -1; return -1;
} }
s += 7; s += 7;
@@ -319,7 +319,7 @@ hostkey_method_ssh_dss_init(LIBSSH2_SESSION * session,
ret = _libssh2_dsa_new(&dsactx, p, p_len, q, q_len, ret = _libssh2_dsa_new(&dsactx, p, p_len, q, q_len,
g, g_len, y, y_len, NULL, 0); g, g_len, y, y_len, NULL, 0);
if (ret) { if(ret) {
return -1; return -1;
} }
@@ -342,13 +342,13 @@ hostkey_method_ssh_dss_initPEM(LIBSSH2_SESSION * session,
libssh2_dsa_ctx *dsactx; libssh2_dsa_ctx *dsactx;
int ret; int ret;
if (*abstract) { if(*abstract) {
hostkey_method_ssh_dss_dtor(session, abstract); hostkey_method_ssh_dss_dtor(session, abstract);
*abstract = NULL; *abstract = NULL;
} }
ret = _libssh2_dsa_new_private(&dsactx, session, privkeyfile, passphrase); ret = _libssh2_dsa_new_private(&dsactx, session, privkeyfile, passphrase);
if (ret) { if(ret) {
return -1; return -1;
} }
@@ -372,7 +372,7 @@ hostkey_method_ssh_dss_initPEMFromMemory(LIBSSH2_SESSION * session,
libssh2_dsa_ctx *dsactx; libssh2_dsa_ctx *dsactx;
int ret; int ret;
if (*abstract) { if(*abstract) {
hostkey_method_ssh_dss_dtor(session, abstract); hostkey_method_ssh_dss_dtor(session, abstract);
*abstract = NULL; *abstract = NULL;
} }
@@ -380,7 +380,7 @@ hostkey_method_ssh_dss_initPEMFromMemory(LIBSSH2_SESSION * session,
ret = _libssh2_dsa_new_private_frommemory(&dsactx, session, ret = _libssh2_dsa_new_private_frommemory(&dsactx, session,
privkeyfiledata, privkeyfiledata,
privkeyfiledata_len, passphrase); privkeyfiledata_len, passphrase);
if (ret) { if(ret) {
return -1; return -1;
} }
@@ -406,7 +406,7 @@ hostkey_method_ssh_dss_sig_verify(LIBSSH2_SESSION * session,
/* Skip past keyname_len(4) + keyname(7){"ssh-dss"} + signature_len(4) */ /* Skip past keyname_len(4) + keyname(7){"ssh-dss"} + signature_len(4) */
sig += 15; sig += 15;
sig_len -= 15; sig_len -= 15;
if (sig_len != 40) { if(sig_len != 40) {
return _libssh2_error(session, LIBSSH2_ERROR_PROTO, return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
"Invalid DSS signature length"); "Invalid DSS signature length");
} }
@@ -432,7 +432,7 @@ hostkey_method_ssh_dss_signv(LIBSSH2_SESSION * session,
int i; int i;
*signature = LIBSSH2_CALLOC(session, 2 * SHA_DIGEST_LENGTH); *signature = LIBSSH2_CALLOC(session, 2 * SHA_DIGEST_LENGTH);
if (!*signature) { if(!*signature) {
return -1; return -1;
} }
@@ -444,7 +444,7 @@ hostkey_method_ssh_dss_signv(LIBSSH2_SESSION * session,
} }
libssh2_sha1_final(ctx, hash); libssh2_sha1_final(ctx, hash);
if (_libssh2_dsa_sha1_sign(dsactx, hash, SHA_DIGEST_LENGTH, *signature)) { if(_libssh2_dsa_sha1_sign(dsactx, hash, SHA_DIGEST_LENGTH, *signature)) {
LIBSSH2_FREE(session, *signature); LIBSSH2_FREE(session, *signature);
return -1; return -1;
} }
@@ -509,28 +509,31 @@ hostkey_method_ssh_ecdsa_init(LIBSSH2_SESSION * session,
size_t len, key_len, n_len; size_t len, key_len, n_len;
libssh2_curve_type type; libssh2_curve_type type;
if (abstract != NULL && *abstract) { if(abstract != NULL && *abstract) {
hostkey_method_ssh_ecdsa_dtor(session, abstract); hostkey_method_ssh_ecdsa_dtor(session, abstract);
*abstract = NULL; *abstract = NULL;
} }
if ( hostkey_data_len < 23 ) if(hostkey_data_len < 23)
return -1; return -1;
s = hostkey_data; s = hostkey_data;
len = _libssh2_ntohu32(s); len = _libssh2_ntohu32(s);
s += 4; s += 4;
if (len != 19 ) if(len != 19)
return -1; return -1;
if (strncmp((char*) s, "ecdsa-sha2-nistp256", 19) == 0 ) { if(strncmp((char *) s, "ecdsa-sha2-nistp256", 19) == 0) {
type = LIBSSH2_EC_CURVE_NISTP256; type = LIBSSH2_EC_CURVE_NISTP256;
} else if(strncmp((char*) s, "ecdsa-sha2-nistp384", 19) == 0 ) { }
else if(strncmp((char *) s, "ecdsa-sha2-nistp384", 19) == 0) {
type = LIBSSH2_EC_CURVE_NISTP384; type = LIBSSH2_EC_CURVE_NISTP384;
} else if(strncmp((char*) s, "ecdsa-sha2-nistp521", 19) == 0 ) { }
else if(strncmp((char *) s, "ecdsa-sha2-nistp521", 19) == 0) {
type = LIBSSH2_EC_CURVE_NISTP521; type = LIBSSH2_EC_CURVE_NISTP521;
} else { }
else {
return -1; return -1;
} }
s += 19; s += 19;
@@ -539,14 +542,16 @@ hostkey_method_ssh_ecdsa_init(LIBSSH2_SESSION * session,
n_len = _libssh2_ntohu32(s); n_len = _libssh2_ntohu32(s);
s += 4; s += 4;
if (n_len != 8) if(n_len != 8)
return -1; return -1;
if ( type == LIBSSH2_EC_CURVE_NISTP256 && strncmp((char*)s, "nistp256", 8) != 0) { if(type == LIBSSH2_EC_CURVE_NISTP256 && strncmp((char *)s, "nistp256", 8) != 0) {
return -1; return -1;
} else if ( type == LIBSSH2_EC_CURVE_NISTP384 && strncmp((char*)s, "nistp384", 8) != 0) { }
else if(type == LIBSSH2_EC_CURVE_NISTP384 && strncmp((char *)s, "nistp384", 8) != 0) {
return -1; return -1;
} else if ( type == LIBSSH2_EC_CURVE_NISTP521 && strncmp((char*)s, "nistp521", 8) != 0) { }
else if(type == LIBSSH2_EC_CURVE_NISTP521 && strncmp((char *)s, "nistp521", 8) != 0) {
return -1; return -1;
} }
@@ -558,10 +563,10 @@ hostkey_method_ssh_ecdsa_init(LIBSSH2_SESSION * session,
k = s; k = s;
if (_libssh2_ecdsa_curve_name_with_octal_new(&ecdsactx, k, key_len, type) ) if(_libssh2_ecdsa_curve_name_with_octal_new(&ecdsactx, k, key_len, type) )
return -1; return -1;
if ( abstract != NULL ) if(abstract != NULL)
*abstract = ecdsactx; *abstract = ecdsactx;
return 0; return 0;
@@ -581,14 +586,14 @@ hostkey_method_ssh_ecdsa_initPEM(LIBSSH2_SESSION * session,
libssh2_ecdsa_ctx *ec_ctx = NULL; libssh2_ecdsa_ctx *ec_ctx = NULL;
int ret; int ret;
if (abstract != NULL && *abstract) { if(abstract != NULL && *abstract) {
hostkey_method_ssh_ecdsa_dtor(session, abstract); hostkey_method_ssh_ecdsa_dtor(session, abstract);
*abstract = NULL; *abstract = NULL;
} }
ret = _libssh2_ecdsa_new_private(&ec_ctx, session, privkeyfile, passphrase); ret = _libssh2_ecdsa_new_private(&ec_ctx, session, privkeyfile, passphrase);
if ( abstract != NULL ) if(abstract != NULL)
*abstract = ec_ctx; *abstract = ec_ctx;
return ret; return ret;
@@ -609,7 +614,7 @@ hostkey_method_ssh_ecdsa_initPEMFromMemory(LIBSSH2_SESSION * session,
libssh2_ecdsa_ctx *ec_ctx = NULL; libssh2_ecdsa_ctx *ec_ctx = NULL;
int ret; int ret;
if (abstract != NULL && *abstract) { if(abstract != NULL && *abstract) {
hostkey_method_ssh_ecdsa_dtor(session, abstract); hostkey_method_ssh_ecdsa_dtor(session, abstract);
*abstract = NULL; *abstract = NULL;
} }
@@ -617,11 +622,11 @@ hostkey_method_ssh_ecdsa_initPEMFromMemory(LIBSSH2_SESSION * session,
ret = _libssh2_ecdsa_new_private_frommemory(&ec_ctx, session, ret = _libssh2_ecdsa_new_private_frommemory(&ec_ctx, session,
privkeyfiledata, privkeyfiledata,
privkeyfiledata_len, passphrase); privkeyfiledata_len, passphrase);
if (ret) { if(ret) {
return -1; return -1;
} }
if (abstract != NULL) if(abstract != NULL)
*abstract = ec_ctx; *abstract = ec_ctx;
return 0; return 0;
@@ -645,7 +650,7 @@ hostkey_method_ssh_ecdsa_sig_verify(LIBSSH2_SESSION * session,
(void) session; (void) session;
if ( sig_len < 35 ) if(sig_len < 35)
return -1; return -1;
/* Skip past keyname_len(4) + keyname(19){"ecdsa-sha2-nistp256"} + signature_len(4) */ /* Skip past keyname_len(4) + keyname(19){"ecdsa-sha2-nistp256"} + signature_len(4) */
@@ -697,13 +702,16 @@ hostkey_method_ssh_ecdsa_signv(LIBSSH2_SESSION * session,
libssh2_curve_type type = _libssh2_ecdsa_key_get_curve_type(ec_ctx); libssh2_curve_type type = _libssh2_ecdsa_key_get_curve_type(ec_ctx);
int ret = 0; int ret = 0;
if ( type == LIBSSH2_EC_CURVE_NISTP256 ) { if(type == LIBSSH2_EC_CURVE_NISTP256) {
LIBSSH2_HOSTKEY_METHOD_EC_SIGNV_HASH(256); LIBSSH2_HOSTKEY_METHOD_EC_SIGNV_HASH(256);
}else if ( type == LIBSSH2_EC_CURVE_NISTP384 ) { }
else if(type == LIBSSH2_EC_CURVE_NISTP384) {
LIBSSH2_HOSTKEY_METHOD_EC_SIGNV_HASH(384); LIBSSH2_HOSTKEY_METHOD_EC_SIGNV_HASH(384);
}else if ( type == LIBSSH2_EC_CURVE_NISTP521 ){ }
else if(type == LIBSSH2_EC_CURVE_NISTP521) {
LIBSSH2_HOSTKEY_METHOD_EC_SIGNV_HASH(512); LIBSSH2_HOSTKEY_METHOD_EC_SIGNV_HASH(512);
}else{ }
else {
return -1; return -1;
} }
@@ -721,7 +729,7 @@ hostkey_method_ssh_ecdsa_dtor(LIBSSH2_SESSION * session, void **abstract)
libssh2_ecdsa_ctx *keyctx = (libssh2_ecdsa_ctx *) (*abstract); libssh2_ecdsa_ctx *keyctx = (libssh2_ecdsa_ctx *) (*abstract);
(void) session; (void) session;
if (keyctx != NULL) if(keyctx != NULL)
_libssh2_ecdsa_free(keyctx); _libssh2_ecdsa_free(keyctx);
*abstract = NULL; *abstract = NULL;
@@ -799,7 +807,7 @@ libssh2_hostkey_methods(void)
LIBSSH2_API const char * LIBSSH2_API const char *
libssh2_hostkey_hash(LIBSSH2_SESSION * session, int hash_type) libssh2_hostkey_hash(LIBSSH2_SESSION * session, int hash_type)
{ {
switch (hash_type) { switch(hash_type) {
#if LIBSSH2_MD5 #if LIBSSH2_MD5
case LIBSSH2_HOSTKEY_HASH_MD5: case LIBSSH2_HOSTKEY_HASH_MD5:
return (session->server_hostkey_md5_valid) return (session->server_hostkey_md5_valid)
@@ -840,28 +848,28 @@ static int hostkey_type(const unsigned char *hostkey, size_t len)
0, 0, 0, 0x13, 'e', 'c', 'd', 's', 'a', '-', 's', 'h', 'a', '2', '-', 'n', 'i', 's', 't', 'p', '5', '2', '1' 0, 0, 0, 0x13, 'e', 'c', 'd', 's', 'a', '-', 's', 'h', 'a', '2', '-', 'n', 'i', 's', 't', 'p', '5', '2', '1'
}; };
if (len < 11) if(len < 11)
return LIBSSH2_HOSTKEY_TYPE_UNKNOWN; return LIBSSH2_HOSTKEY_TYPE_UNKNOWN;
if (!memcmp(rsa, hostkey, 11)) if(!memcmp(rsa, hostkey, 11))
return LIBSSH2_HOSTKEY_TYPE_RSA; return LIBSSH2_HOSTKEY_TYPE_RSA;
if (!memcmp(dss, hostkey, 11)) if(!memcmp(dss, hostkey, 11))
return LIBSSH2_HOSTKEY_TYPE_DSS; return LIBSSH2_HOSTKEY_TYPE_DSS;
if ( len < 15 ) if(len < 15)
return LIBSSH2_HOSTKEY_TYPE_UNKNOWN; return LIBSSH2_HOSTKEY_TYPE_UNKNOWN;
if ( len < 23 ) if(len < 23)
return LIBSSH2_HOSTKEY_TYPE_UNKNOWN; return LIBSSH2_HOSTKEY_TYPE_UNKNOWN;
if (!memcmp(ecdsa_256, hostkey, 23)) if(!memcmp(ecdsa_256, hostkey, 23))
return LIBSSH2_HOSTKEY_TYPE_ECDSA; return LIBSSH2_HOSTKEY_TYPE_ECDSA;
if (!memcmp(ecdsa_384, hostkey, 23)) if(!memcmp(ecdsa_384, hostkey, 23))
return LIBSSH2_HOSTKEY_TYPE_ECDSA; return LIBSSH2_HOSTKEY_TYPE_ECDSA;
if (!memcmp(ecdsa_521, hostkey, 23)) if(!memcmp(ecdsa_521, hostkey, 23))
return LIBSSH2_HOSTKEY_TYPE_ECDSA; return LIBSSH2_HOSTKEY_TYPE_ECDSA;
return LIBSSH2_HOSTKEY_TYPE_UNKNOWN; return LIBSSH2_HOSTKEY_TYPE_UNKNOWN;
@@ -879,7 +887,7 @@ libssh2_session_hostkey(LIBSSH2_SESSION *session, size_t *len, int *type)
if(session->server_hostkey_len) { if(session->server_hostkey_len) {
if(len) if(len)
*len = session->server_hostkey_len; *len = session->server_hostkey_len;
if (type) if(type)
*type = hostkey_type(session->server_hostkey, *type = hostkey_type(session->server_hostkey,
session->server_hostkey_len); session->server_hostkey_len);
return (char *) session->server_hostkey; return (char *) session->server_hostkey;

19
src/keepalive.c
View File

@@ -46,7 +46,7 @@ libssh2_keepalive_config (LIBSSH2_SESSION *session,
int want_reply, int want_reply,
unsigned interval) unsigned interval)
{ {
if (interval == 1) if(interval == 1)
session->keepalive_interval = 2; session->keepalive_interval = 2;
else else
session->keepalive_interval = interval; session->keepalive_interval = interval;
@@ -59,20 +59,20 @@ libssh2_keepalive_send (LIBSSH2_SESSION *session,
{ {
time_t now; time_t now;
if (!session->keepalive_interval) { if(!session->keepalive_interval) {
if (seconds_to_next) if(seconds_to_next)
*seconds_to_next = 0; *seconds_to_next = 0;
return 0; return 0;
} }
now = time (NULL); now = time(NULL);
if (session->keepalive_last_sent + session->keepalive_interval <= now) { if(session->keepalive_last_sent + session->keepalive_interval <= now) {
/* Format is /* Format is
"SSH_MSG_GLOBAL_REQUEST || 4-byte len || str || want-reply". */ "SSH_MSG_GLOBAL_REQUEST || 4-byte len || str || want-reply". */
unsigned char keepalive_data[] unsigned char keepalive_data[]
= "\x50\x00\x00\x00\x15keepalive@libssh2.orgW"; = "\x50\x00\x00\x00\x15keepalive@libssh2.orgW";
size_t len = sizeof (keepalive_data) - 1; size_t len = sizeof(keepalive_data) - 1;
int rc; int rc;
keepalive_data[len - 1] = keepalive_data[len - 1] =
@@ -81,16 +81,17 @@ libssh2_keepalive_send (LIBSSH2_SESSION *session,
rc = _libssh2_transport_send(session, keepalive_data, len, NULL, 0); rc = _libssh2_transport_send(session, keepalive_data, len, NULL, 0);
/* Silently ignore PACKET_EAGAIN here: if the write buffer is /* Silently ignore PACKET_EAGAIN here: if the write buffer is
already full, sending another keepalive is not useful. */ already full, sending another keepalive is not useful. */
if (rc && rc != LIBSSH2_ERROR_EAGAIN) { if(rc && rc != LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
"Unable to send keepalive message"); "Unable to send keepalive message");
return rc; return rc;
} }
session->keepalive_last_sent = now; session->keepalive_last_sent = now;
if (seconds_to_next) if(seconds_to_next)
*seconds_to_next = session->keepalive_interval; *seconds_to_next = session->keepalive_interval;
} else if (seconds_to_next) { }
else if(seconds_to_next) {
*seconds_to_next = (int) (session->keepalive_last_sent - now) *seconds_to_next = (int) (session->keepalive_last_sent - now)
+ session->keepalive_interval; + session->keepalive_interval;
} }

781
src/kex.c
View File

File diff suppressed because it is too large Load Diff

85
src/knownhost.c
View File

@@ -71,7 +71,7 @@ static void free_host(LIBSSH2_SESSION *session, struct known_host *entry)
if(entry) { if(entry) {
if(entry->comment) if(entry->comment)
LIBSSH2_FREE(session, entry->comment); LIBSSH2_FREE(session, entry->comment);
if (entry->key_type_name) if(entry->key_type_name)
LIBSSH2_FREE(session, entry->key_type_name); LIBSSH2_FREE(session, entry->key_type_name);
if(entry->key) if(entry->key)
LIBSSH2_FREE(session, entry->key); LIBSSH2_FREE(session, entry->key);
@@ -149,7 +149,8 @@ knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
return _libssh2_error(hosts->session, LIBSSH2_ERROR_INVAL, return _libssh2_error(hosts->session, LIBSSH2_ERROR_INVAL,
"No key type set"); "No key type set");
if(!(entry = LIBSSH2_CALLOC(hosts->session, sizeof(struct known_host)))) entry = LIBSSH2_CALLOC(hosts->session, sizeof(struct known_host));
if(!entry)
return _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for known host " "Unable to allocate memory for known host "
"entry"); "entry");
@@ -159,13 +160,13 @@ knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
switch(entry->typemask & LIBSSH2_KNOWNHOST_TYPE_MASK) { switch(entry->typemask & LIBSSH2_KNOWNHOST_TYPE_MASK) {
case LIBSSH2_KNOWNHOST_TYPE_PLAIN: case LIBSSH2_KNOWNHOST_TYPE_PLAIN:
case LIBSSH2_KNOWNHOST_TYPE_CUSTOM: case LIBSSH2_KNOWNHOST_TYPE_CUSTOM:
entry->name = LIBSSH2_ALLOC(hosts->session, hostlen+1); entry->name = LIBSSH2_ALLOC(hosts->session, hostlen + 1);
if(!entry->name) { if(!entry->name) {
rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC, rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for host name"); "Unable to allocate memory for host name");
goto error; goto error;
} }
memcpy(entry->name, host, hostlen+1); memcpy(entry->name, host, hostlen + 1);
entry->name_len = hostlen; entry->name_len = hostlen;
break; break;
case LIBSSH2_KNOWNHOST_TYPE_SHA1: case LIBSSH2_KNOWNHOST_TYPE_SHA1:
@@ -193,14 +194,14 @@ knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
/* the provided key is base64 encoded already */ /* the provided key is base64 encoded already */
if(!keylen) if(!keylen)
keylen = strlen(key); keylen = strlen(key);
entry->key = LIBSSH2_ALLOC(hosts->session, keylen+1); entry->key = LIBSSH2_ALLOC(hosts->session, keylen + 1);
if(!entry->key) { if(!entry->key) {
rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC, rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for key"); "Unable to allocate memory for key");
goto error; goto error;
} }
memcpy(entry->key, key, keylen+1); memcpy(entry->key, key, keylen + 1);
entry->key[keylen]=0; /* force a terminating zero trailer */ entry->key[keylen] = 0; /* force a terminating zero trailer */
} }
else { else {
/* key is raw, we base64 encode it and store it as such */ /* key is raw, we base64 encode it and store it as such */
@@ -216,28 +217,28 @@ knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
entry->key = ptr; entry->key = ptr;
} }
if (key_type_name && ((typemask & LIBSSH2_KNOWNHOST_KEY_MASK) == if(key_type_name && ((typemask & LIBSSH2_KNOWNHOST_KEY_MASK) ==
LIBSSH2_KNOWNHOST_KEY_UNKNOWN)) { LIBSSH2_KNOWNHOST_KEY_UNKNOWN)) {
entry->key_type_name = LIBSSH2_ALLOC(hosts->session, key_type_len+1); entry->key_type_name = LIBSSH2_ALLOC(hosts->session, key_type_len + 1);
if (!entry->key_type_name) { if(!entry->key_type_name) {
rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC, rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for key type"); "Unable to allocate memory for key type");
goto error; goto error;
} }
memcpy(entry->key_type_name, key_type_name, key_type_len); memcpy(entry->key_type_name, key_type_name, key_type_len);
entry->key_type_name[key_type_len]=0; entry->key_type_name[key_type_len] = 0;
entry->key_type_len = key_type_len; entry->key_type_len = key_type_len;
} }
if (comment) { if(comment) {
entry->comment = LIBSSH2_ALLOC(hosts->session, commentlen+1); entry->comment = LIBSSH2_ALLOC(hosts->session, commentlen + 1);
if(!entry->comment) { if(!entry->comment) {
rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC, rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for comment"); "Unable to allocate memory for comment");
goto error; goto error;
} }
memcpy(entry->comment, comment, commentlen+1); memcpy(entry->comment, comment, commentlen + 1);
entry->comment[commentlen]=0; /* force a terminating zero trailer */ entry->comment[commentlen] = 0; /* force a terminating zero trailer */
entry->comment_len = commentlen; entry->comment_len = commentlen;
} }
else { else {
@@ -370,7 +371,7 @@ knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
plain 'host' */ plain 'host' */
if(port >= 0) { if(port >= 0) {
int len = snprintf(hostbuff, sizeof(hostbuff), "[%s]:%d", hostp, port); int len = snprintf(hostbuff, sizeof(hostbuff), "[%s]:%d", hostp, port);
if (len < 0 || len >= (int)sizeof(hostbuff)) { if(len < 0 || len >= (int)sizeof(hostbuff)) {
_libssh2_error(hosts->session, _libssh2_error(hosts->session,
LIBSSH2_ERROR_BUFFER_TOO_SMALL, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
"Known-host write buffer too small"); "Known-host write buffer too small");
@@ -401,7 +402,7 @@ knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
do { do {
node = _libssh2_list_first(&hosts->head); node = _libssh2_list_first(&hosts->head);
while (node) { while(node) {
switch(node->typemask & LIBSSH2_KNOWNHOST_TYPE_MASK) { switch(node->typemask & LIBSSH2_KNOWNHOST_TYPE_MASK) {
case LIBSSH2_KNOWNHOST_TYPE_PLAIN: case LIBSSH2_KNOWNHOST_TYPE_PLAIN:
if(type == LIBSSH2_KNOWNHOST_TYPE_PLAIN) if(type == LIBSSH2_KNOWNHOST_TYPE_PLAIN)
@@ -450,13 +451,13 @@ knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
- if key_type is set to zero, ignore it an match always - if key_type is set to zero, ignore it an match always
- otherwise match when both key types are equal - otherwise match when both key types are equal
*/ */
if ( (host_key_type != LIBSSH2_KNOWNHOST_KEY_UNKNOWN ) && if(host_key_type != LIBSSH2_KNOWNHOST_KEY_UNKNOWN &&
( (host_key_type == 0) || (host_key_type == 0 ||
(host_key_type == known_key_type) ) ) { host_key_type == known_key_type)) {
/* host name and key type match, now compare the keys */ /* host name and key type match, now compare the keys */
if(!strcmp(key, node->key)) { if(!strcmp(key, node->key)) {
/* they match! */ /* they match! */
if (ext) if(ext)
*ext = knownhost_to_external(node); *ext = knownhost_to_external(node);
badkey = NULL; badkey = NULL;
rc = LIBSSH2_KNOWNHOST_CHECK_MATCH; rc = LIBSSH2_KNOWNHOST_CHECK_MATCH;
@@ -472,14 +473,14 @@ knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
} }
match = 0; /* don't count this as a match anymore */ match = 0; /* don't count this as a match anymore */
} }
node= _libssh2_list_next(&node->node); node = _libssh2_list_next(&node->node);
} }
host = hostp; host = hostp;
} while(!match && --numcheck); } while(!match && --numcheck);
if(badkey) { if(badkey) {
/* key mismatch */ /* key mismatch */
if (ext) if(ext)
*ext = knownhost_to_external(badkey); *ext = knownhost_to_external(badkey);
rc = LIBSSH2_KNOWNHOST_CHECK_MISMATCH; rc = LIBSSH2_KNOWNHOST_CHECK_MISMATCH;
} }
@@ -646,7 +647,7 @@ static int oldstyle_hostline(LIBSSH2_KNOWNHOSTS *hosts,
/* copy host name to the temp buffer and zero terminate */ /* copy host name to the temp buffer and zero terminate */
memcpy(hostbuf, name, namelen); memcpy(hostbuf, name, namelen);
hostbuf[namelen]=0; hostbuf[namelen] = 0;
rc = knownhost_add(hosts, hostbuf, NULL, rc = knownhost_add(hosts, hostbuf, NULL,
key_type_name, key_type_len, key_type_name, key_type_len,
@@ -685,7 +686,7 @@ static int hashed_hostline(LIBSSH2_KNOWNHOSTS *hosts,
for(p = salt; *p && (*p != '|'); p++) for(p = salt; *p && (*p != '|'); p++)
; ;
if(*p=='|') { if(*p == '|') {
const char *hash = NULL; const char *hash = NULL;
size_t saltlen = p - salt; size_t saltlen = p - salt;
if(saltlen >= (sizeof(saltbuf)-1)) /* weird length */ if(saltlen >= (sizeof(saltbuf)-1)) /* weird length */
@@ -698,11 +699,11 @@ static int hashed_hostline(LIBSSH2_KNOWNHOSTS *hosts,
saltbuf[saltlen] = 0; /* zero terminate */ saltbuf[saltlen] = 0; /* zero terminate */
salt = saltbuf; /* point to the stack based buffer */ salt = saltbuf; /* point to the stack based buffer */
hash = p+1; /* the host hash is after the separator */ hash = p + 1; /* the host hash is after the separator */
/* now make the host point to the hash */ /* now make the host point to the hash */
host = hash; host = hash;
hostlen -= saltlen+1; /* deduct the salt and separator */ hostlen -= saltlen + 1; /* deduct the salt and separator */
/* check that the lengths seem sensible */ /* check that the lengths seem sensible */
if(hostlen >= sizeof(hostbuf)-1) if(hostlen >= sizeof(hostbuf)-1)
@@ -712,7 +713,7 @@ static int hashed_hostline(LIBSSH2_KNOWNHOSTS *hosts,
"(unexpected length)"); "(unexpected length)");
memcpy(hostbuf, host, hostlen); memcpy(hostbuf, host, hostlen);
hostbuf[hostlen]=0; hostbuf[hostlen] = 0;
return knownhost_add(hosts, hostbuf, salt, return knownhost_add(hosts, hostbuf, salt,
key_type_name, key_type_len, key_type_name, key_type_len,
@@ -766,16 +767,16 @@ static int hostline(LIBSSH2_KNOWNHOSTS *hosts,
default: default:
key_type_name = key; key_type_name = key;
while (keylen && *key && while(keylen && *key &&
(*key != ' ') && (*key != '\t')) { (*key != ' ') && (*key != '\t')) {
key++; key++;
keylen--; keylen--;
} }
key_type_len = key - key_type_name; key_type_len = key - key_type_name;
if (!strncmp(key_type_name, "ssh-dss", key_type_len)) if(!strncmp(key_type_name, "ssh-dss", key_type_len))
key_type = LIBSSH2_KNOWNHOST_KEY_SSHDSS; key_type = LIBSSH2_KNOWNHOST_KEY_SSHDSS;
else if (!strncmp(key_type_name, "ssh-rsa", key_type_len)) else if(!strncmp(key_type_name, "ssh-rsa", key_type_len))
key_type = LIBSSH2_KNOWNHOST_KEY_SSHRSA; key_type = LIBSSH2_KNOWNHOST_KEY_SSHRSA;
else else
key_type = LIBSSH2_KNOWNHOST_KEY_UNKNOWN; key_type = LIBSSH2_KNOWNHOST_KEY_UNKNOWN;
@@ -800,7 +801,7 @@ static int hostline(LIBSSH2_KNOWNHOSTS *hosts,
keylen -= commentlen; keylen -= commentlen;
/* Distinguish empty comment (a space) from no comment (no space) */ /* Distinguish empty comment (a space) from no comment (no space) */
if (commentlen == 0) if(commentlen == 0)
comment = NULL; comment = NULL;
/* skip whitespaces */ /* skip whitespaces */
@@ -879,7 +880,7 @@ libssh2_knownhost_readline(LIBSSH2_KNOWNHOSTS *hosts,
cp = line; cp = line;
/* skip leading whitespaces */ /* skip leading whitespaces */
while(len && ((*cp==' ') || (*cp == '\t'))) { while(len && ((*cp == ' ') || (*cp == '\t'))) {
cp++; cp++;
len--; len--;
} }
@@ -892,7 +893,7 @@ libssh2_knownhost_readline(LIBSSH2_KNOWNHOSTS *hosts,
hostp = cp; hostp = cp;
/* move over the host to the separator */ /* move over the host to the separator */
while(len && *cp && (*cp!=' ') && (*cp != '\t')) { while(len && *cp && (*cp != ' ') && (*cp != '\t')) {
cp++; cp++;
len--; len--;
} }
@@ -900,7 +901,7 @@ libssh2_knownhost_readline(LIBSSH2_KNOWNHOSTS *hosts,
hostlen = cp - hostp; hostlen = cp - hostp;
/* the key starts after the whitespaces */ /* the key starts after the whitespaces */
while(len && *cp && ((*cp==' ') || (*cp == '\t'))) { while(len && *cp && ((*cp == ' ') || (*cp == '\t'))) {
cp++; cp++;
len--; len--;
} }
@@ -1018,7 +1019,7 @@ knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
break; break;
case LIBSSH2_KNOWNHOST_KEY_UNKNOWN: case LIBSSH2_KNOWNHOST_KEY_UNKNOWN:
key_type_name = node->key_type_name; key_type_name = node->key_type_name;
if (key_type_name) { if(key_type_name) {
key_type_len = node->key_type_len; key_type_len = node->key_type_len;
break; break;
} }
@@ -1033,7 +1034,7 @@ knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
- Hashed (SHA1) or unhashed hostname - Hashed (SHA1) or unhashed hostname
- key name or no key name (RSA1) - key name or no key name (RSA1)
- comment or no comment - comment or no comment
This means there are 2^3 different formats: This means there are 2^3 different formats:
("|1|%s|%s %s %s %s\n", salt, hashed_host, key_name, key, comment) ("|1|%s|%s %s %s %s\n", salt, hashed_host, key_name, key, comment)
("|1|%s|%s %s %s\n", salt, hashed_host, key_name, key) ("|1|%s|%s %s %s\n", salt, hashed_host, key_name, key)
@@ -1043,7 +1044,7 @@ knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
("%s %s %s\n", host, key_name, key) ("%s %s %s\n", host, key_name, key)
("%s %s %s\n", host, key, comment) ("%s %s %s\n", host, key, comment)
("%s %s\n", host, key) ("%s %s\n", host, key)
Even if the buffer is too small, we have to set outlen to the number of Even if the buffer is too small, we have to set outlen to the number of
characters the complete line would have taken. We also don't write characters the complete line would have taken. We also don't write
anything to the buffer unless we are sure we can write everything to the anything to the buffer unless we are sure we can write everything to the
@@ -1087,10 +1088,10 @@ knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
if(node->comment && key_type_len) if(node->comment && key_type_len)
snprintf(buf, buflen, "|1|%s|%s %s %s %s\n", saltalloc, snprintf(buf, buflen, "|1|%s|%s %s %s %s\n", saltalloc,
namealloc, key_type_name, node->key, node->comment); namealloc, key_type_name, node->key, node->comment);
else if (node->comment) else if(node->comment)
snprintf(buf, buflen, "|1|%s|%s %s %s\n", saltalloc, namealloc, snprintf(buf, buflen, "|1|%s|%s %s %s\n", saltalloc, namealloc,
node->key, node->comment); node->key, node->comment);
else if (key_type_len) else if(key_type_len)
snprintf(buf, buflen, "|1|%s|%s %s %s\n", saltalloc, namealloc, snprintf(buf, buflen, "|1|%s|%s %s %s\n", saltalloc, namealloc,
key_type_name, node->key); key_type_name, node->key);
else else
@@ -1109,10 +1110,10 @@ knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
if(node->comment && key_type_len) if(node->comment && key_type_len)
snprintf(buf, buflen, "%s %s %s %s\n", node->name, snprintf(buf, buflen, "%s %s %s %s\n", node->name,
key_type_name, node->key, node->comment); key_type_name, node->key, node->comment);
else if (node->comment) else if(node->comment)
snprintf(buf, buflen, "%s %s %s\n", node->name, node->key, snprintf(buf, buflen, "%s %s %s\n", node->name, node->key,
node->comment); node->comment);
else if (key_type_len) else if(key_type_len)
snprintf(buf, buflen, "%s %s %s\n", node->name, key_type_name, snprintf(buf, buflen, "%s %s %s\n", node->name, key_type_name,
node->key); node->key);
else else

131
src/libgcrypt.c
View File

@@ -66,17 +66,18 @@ _libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
(void) e2data; (void) e2data;
(void) e2len; (void) e2len;
if (ddata) { if(ddata) {
rc = gcry_sexp_build rc = gcry_sexp_build
(rsa, NULL, (rsa, NULL,
"(private-key(rsa(n%b)(e%b)(d%b)(q%b)(p%b)(u%b)))", "(private-key(rsa(n%b)(e%b)(d%b)(q%b)(p%b)(u%b)))",
nlen, ndata, elen, edata, dlen, ddata, plen, pdata, nlen, ndata, elen, edata, dlen, ddata, plen, pdata,
qlen, qdata, coefflen, coeffdata); qlen, qdata, coefflen, coeffdata);
} else { }
else {
rc = gcry_sexp_build(rsa, NULL, "(public-key(rsa(n%b)(e%b)))", rc = gcry_sexp_build(rsa, NULL, "(public-key(rsa(n%b)(e%b)))",
nlen, ndata, elen, edata); nlen, ndata, elen, edata);
} }
if (rc) { if(rc) {
*rsa = NULL; *rsa = NULL;
return -1; return -1;
} }
@@ -99,12 +100,12 @@ _libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsa,
rc = gcry_sexp_build(&s_hash, NULL, rc = gcry_sexp_build(&s_hash, NULL,
"(data (flags pkcs1) (hash sha1 %b))", "(data (flags pkcs1) (hash sha1 %b))",
SHA_DIGEST_LENGTH, hash); SHA_DIGEST_LENGTH, hash);
if (rc != 0) { if(rc != 0) {
return -1; return -1;
} }
rc = gcry_sexp_build(&s_sig, NULL, "(sig-val(rsa(s %b)))", sig_len, sig); rc = gcry_sexp_build(&s_sig, NULL, "(sig-val(rsa(s %b)))", sig_len, sig);
if (rc != 0) { if(rc != 0) {
gcry_sexp_release(s_hash); gcry_sexp_release(s_hash);
return -1; return -1;
} }
@@ -130,18 +131,19 @@ _libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
{ {
int rc; int rc;
if (x_len) { if(x_len) {
rc = gcry_sexp_build rc = gcry_sexp_build
(dsactx, NULL, (dsactx, NULL,
"(private-key(dsa(p%b)(q%b)(g%b)(y%b)(x%b)))", "(private-key(dsa(p%b)(q%b)(g%b)(y%b)(x%b)))",
p_len, p, q_len, q, g_len, g, y_len, y, x_len, x); p_len, p, q_len, q, g_len, g, y_len, y, x_len, x);
} else { }
else {
rc = gcry_sexp_build(dsactx, NULL, rc = gcry_sexp_build(dsactx, NULL,
"(public-key(dsa(p%b)(q%b)(g%b)(y%b)))", "(public-key(dsa(p%b)(q%b)(g%b)(y%b)))",
p_len, p, q_len, q, g_len, g, y_len, y); p_len, p, q_len, q, g_len, g, y_len, y);
} }
if (rc) { if(rc) {
*dsactx = NULL; *dsactx = NULL;
return -1; return -1;
} }
@@ -173,7 +175,7 @@ _libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
unsigned int nlen, elen, dlen, plen, qlen, e1len, e2len, coefflen; unsigned int nlen, elen, dlen, plen, qlen, e1len, e2len, coefflen;
fp = fopen(filename, "r"); fp = fopen(filename, "r");
if (!fp) { if(!fp) {
return -1; return -1;
} }
@@ -183,72 +185,72 @@ _libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
passphrase, passphrase,
fp, &data, &datalen); fp, &data, &datalen);
fclose(fp); fclose(fp);
if (ret) { if(ret) {
return -1; return -1;
} }
save_data = data; save_data = data;
if (_libssh2_pem_decode_sequence(&data, &datalen)) { if(_libssh2_pem_decode_sequence(&data, &datalen)) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
/* First read Version field (should be 0). */ /* First read Version field (should be 0). */
ret = _libssh2_pem_decode_integer(&data, &datalen, &n, &nlen); ret = _libssh2_pem_decode_integer(&data, &datalen, &n, &nlen);
if (ret != 0 || (nlen != 1 && *n != '\0')) { if(ret != 0 || (nlen != 1 && *n != '\0')) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
ret = _libssh2_pem_decode_integer(&data, &datalen, &n, &nlen); ret = _libssh2_pem_decode_integer(&data, &datalen, &n, &nlen);
if (ret != 0) { if(ret != 0) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
ret = _libssh2_pem_decode_integer(&data, &datalen, &e, &elen); ret = _libssh2_pem_decode_integer(&data, &datalen, &e, &elen);
if (ret != 0) { if(ret != 0) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
ret = _libssh2_pem_decode_integer(&data, &datalen, &d, &dlen); ret = _libssh2_pem_decode_integer(&data, &datalen, &d, &dlen);
if (ret != 0) { if(ret != 0) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen); ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen);
if (ret != 0) { if(ret != 0) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
ret = _libssh2_pem_decode_integer(&data, &datalen, &q, &qlen); ret = _libssh2_pem_decode_integer(&data, &datalen, &q, &qlen);
if (ret != 0) { if(ret != 0) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
ret = _libssh2_pem_decode_integer(&data, &datalen, &e1, &e1len); ret = _libssh2_pem_decode_integer(&data, &datalen, &e1, &e1len);
if (ret != 0) { if(ret != 0) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
ret = _libssh2_pem_decode_integer(&data, &datalen, &e2, &e2len); ret = _libssh2_pem_decode_integer(&data, &datalen, &e2, &e2len);
if (ret != 0) { if(ret != 0) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
ret = _libssh2_pem_decode_integer(&data, &datalen, &coeff, &coefflen); ret = _libssh2_pem_decode_integer(&data, &datalen, &coeff, &coefflen);
if (ret != 0) { if(ret != 0) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
if (_libssh2_rsa_new(rsa, e, elen, n, nlen, d, dlen, p, plen, if(_libssh2_rsa_new(rsa, e, elen, n, nlen, d, dlen, p, plen,
q, qlen, e1, e1len, e2, e2len, coeff, coefflen)) { q, qlen, e1, e1len, e2, e2len, coeff, coefflen)) {
ret = -1; ret = -1;
goto fail; goto fail;
@@ -285,7 +287,7 @@ _libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
unsigned int plen, qlen, glen, ylen, xlen; unsigned int plen, qlen, glen, ylen, xlen;
fp = fopen(filename, "r"); fp = fopen(filename, "r");
if (!fp) { if(!fp) {
return -1; return -1;
} }
@@ -295,60 +297,60 @@ _libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
passphrase, passphrase,
fp, &data, &datalen); fp, &data, &datalen);
fclose(fp); fclose(fp);
if (ret) { if(ret) {
return -1; return -1;
} }
save_data = data; save_data = data;
if (_libssh2_pem_decode_sequence(&data, &datalen)) { if(_libssh2_pem_decode_sequence(&data, &datalen)) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
/* First read Version field (should be 0). */ /* First read Version field (should be 0). */
ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen); ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen);
if (ret != 0 || (plen != 1 && *p != '\0')) { if(ret != 0 || (plen != 1 && *p != '\0')) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen); ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen);
if (ret != 0) { if(ret != 0) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
ret = _libssh2_pem_decode_integer(&data, &datalen, &q, &qlen); ret = _libssh2_pem_decode_integer(&data, &datalen, &q, &qlen);
if (ret != 0) { if(ret != 0) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
ret = _libssh2_pem_decode_integer(&data, &datalen, &g, &glen); ret = _libssh2_pem_decode_integer(&data, &datalen, &g, &glen);
if (ret != 0) { if(ret != 0) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
ret = _libssh2_pem_decode_integer(&data, &datalen, &y, &ylen); ret = _libssh2_pem_decode_integer(&data, &datalen, &y, &ylen);
if (ret != 0) { if(ret != 0) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
ret = _libssh2_pem_decode_integer(&data, &datalen, &x, &xlen); ret = _libssh2_pem_decode_integer(&data, &datalen, &x, &xlen);
if (ret != 0) { if(ret != 0) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
if (datalen != 0) { if(datalen != 0) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
if (_libssh2_dsa_new(dsa, p, plen, q, qlen, g, glen, y, ylen, x, xlen)) { if(_libssh2_dsa_new(dsa, p, plen, q, qlen, g, glen, y, ylen, x, xlen)) {
ret = -1; ret = -1;
goto fail; goto fail;
} }
@@ -373,11 +375,11 @@ _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
const char *tmp; const char *tmp;
size_t size; size_t size;
if (hash_len != SHA_DIGEST_LENGTH) { if(hash_len != SHA_DIGEST_LENGTH) {
return -1; return -1;
} }
if (gcry_sexp_build(&data, NULL, if(gcry_sexp_build(&data, NULL,
"(data (flags pkcs1) (hash sha1 %b))", "(data (flags pkcs1) (hash sha1 %b))",
hash_len, hash)) { hash_len, hash)) {
return -1; return -1;
@@ -387,27 +389,27 @@ _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
gcry_sexp_release(data); gcry_sexp_release(data);
if (rc != 0) { if(rc != 0) {
return -1; return -1;
} }
data = gcry_sexp_find_token(sig_sexp, "s", 0); data = gcry_sexp_find_token(sig_sexp, "s", 0);
if (!data) { if(!data) {
return -1; return -1;
} }
tmp = gcry_sexp_nth_data(data, 1, &size); tmp = gcry_sexp_nth_data(data, 1, &size);
if (!tmp) { if(!tmp) {
return -1; return -1;
} }
if (tmp[0] == '\0') { if(tmp[0] == '\0') {
tmp++; tmp++;
size--; size--;
} }
*signature = LIBSSH2_ALLOC(session, size); *signature = LIBSSH2_ALLOC(session, size);
if (!*signature) { if(!*signature) {
return -1; return -1;
} }
memcpy(*signature, tmp, size); memcpy(*signature, tmp, size);
@@ -428,14 +430,14 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
const char *tmp; const char *tmp;
size_t size; size_t size;
if (hash_len != SHA_DIGEST_LENGTH) { if(hash_len != SHA_DIGEST_LENGTH) {
return -1; return -1;
} }
memcpy(zhash + 1, hash, hash_len); memcpy(zhash + 1, hash, hash_len);
zhash[0] = 0; zhash[0] = 0;
if (gcry_sexp_build(&data, NULL, "(data (value %b))", hash_len + 1, zhash)) { if(gcry_sexp_build(&data, NULL, "(data (value %b))", hash_len + 1, zhash)) {
return -1; return -1;
} }
@@ -443,7 +445,7 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
gcry_sexp_release(data); gcry_sexp_release(data);
if (ret != 0) { if(ret != 0) {
return -1; return -1;
} }
@@ -452,19 +454,19 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
/* Extract R. */ /* Extract R. */
data = gcry_sexp_find_token(sig_sexp, "r", 0); data = gcry_sexp_find_token(sig_sexp, "r", 0);
if (!data) if(!data)
goto err; goto err;
tmp = gcry_sexp_nth_data(data, 1, &size); tmp = gcry_sexp_nth_data(data, 1, &size);
if (!tmp) if(!tmp)
goto err; goto err;
if (tmp[0] == '\0') { if(tmp[0] == '\0') {
tmp++; tmp++;
size--; size--;
} }
if (size < 1 || size > 20) if(size < 1 || size > 20)
goto err; goto err;
memcpy(sig + (20 - size), tmp, size); memcpy(sig + (20 - size), tmp, size);
@@ -474,19 +476,19 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
/* Extract S. */ /* Extract S. */
data = gcry_sexp_find_token(sig_sexp, "s", 0); data = gcry_sexp_find_token(sig_sexp, "s", 0);
if (!data) if(!data)
goto err; goto err;
tmp = gcry_sexp_nth_data(data, 1, &size); tmp = gcry_sexp_nth_data(data, 1, &size);
if (!tmp) if(!tmp)
goto err; goto err;
if (tmp[0] == '\0') { if(tmp[0] == '\0') {
tmp++; tmp++;
size--; size--;
} }
if (size < 1 || size > 20) if(size < 1 || size > 20)
goto err; goto err;
memcpy(sig + 20 + (20 - size), tmp, size); memcpy(sig + 20 + (20 - size), tmp, size);
@@ -496,10 +498,10 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
ret = -1; ret = -1;
out: out:
if (sig_sexp) { if(sig_sexp) {
gcry_sexp_release(sig_sexp); gcry_sexp_release(sig_sexp);
} }
if (data) { if(data) {
gcry_sexp_release(data); gcry_sexp_release(data);
} }
return ret; return ret;
@@ -517,12 +519,12 @@ _libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
libssh2_sha1(m, m_len, hash + 1); libssh2_sha1(m, m_len, hash + 1);
hash[0] = 0; hash[0] = 0;
if (gcry_sexp_build(&s_hash, NULL, "(data(flags raw)(value %b))", if(gcry_sexp_build(&s_hash, NULL, "(data(flags raw)(value %b))",
SHA_DIGEST_LENGTH + 1, hash)) { SHA_DIGEST_LENGTH + 1, hash)) {
return -1; return -1;
} }
if (gcry_sexp_build(&s_sig, NULL, "(sig-val(dsa(r %b)(s %b)))", if(gcry_sexp_build(&s_sig, NULL, "(sig-val(dsa(r %b)(s %b)))",
20, sig, 20, sig + 20)) { 20, sig, 20, sig + 20)) {
gcry_sexp_release(s_hash); gcry_sexp_release(s_hash);
return -1; return -1;
@@ -541,30 +543,30 @@ _libssh2_cipher_init(_libssh2_cipher_ctx * h,
unsigned char *iv, unsigned char *secret, int encrypt) unsigned char *iv, unsigned char *secret, int encrypt)
{ {
int ret; int ret;
int cipher = _libssh2_gcry_cipher (algo); int cipher = _libssh2_gcry_cipher(algo);
int mode = _libssh2_gcry_mode (algo); int mode = _libssh2_gcry_mode(algo);
int keylen = gcry_cipher_get_algo_keylen(cipher); int keylen = gcry_cipher_get_algo_keylen(cipher);
(void) encrypt; (void) encrypt;
ret = gcry_cipher_open(h, cipher, mode, 0); ret = gcry_cipher_open(h, cipher, mode, 0);
if (ret) { if(ret) {
return -1; return -1;
} }
ret = gcry_cipher_setkey(*h, secret, keylen); ret = gcry_cipher_setkey(*h, secret, keylen);
if (ret) { if(ret) {
gcry_cipher_close(*h); gcry_cipher_close(*h);
return -1; return -1;
} }
if (mode != GCRY_CIPHER_MODE_STREAM) { if(mode != GCRY_CIPHER_MODE_STREAM) {
int blklen = gcry_cipher_get_algo_blklen(cipher); int blklen = gcry_cipher_get_algo_blklen(cipher);
if (mode == GCRY_CIPHER_MODE_CTR) if(mode == GCRY_CIPHER_MODE_CTR)
ret = gcry_cipher_setctr(*h, iv, blklen); ret = gcry_cipher_setctr(*h, iv, blklen);
else else
ret = gcry_cipher_setiv(*h, iv, blklen); ret = gcry_cipher_setiv(*h, iv, blklen);
if (ret) { if(ret) {
gcry_cipher_close(*h); gcry_cipher_close(*h);
return -1; return -1;
} }
@@ -578,12 +580,13 @@ _libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,
_libssh2_cipher_type(algo), _libssh2_cipher_type(algo),
int encrypt, unsigned char *block, size_t blklen) int encrypt, unsigned char *block, size_t blklen)
{ {
int cipher = _libssh2_gcry_cipher (algo); int cipher = _libssh2_gcry_cipher(algo);
int ret; int ret;
if (encrypt) { if(encrypt) {
ret = gcry_cipher_encrypt(*ctx, block, blklen, block, blklen); ret = gcry_cipher_encrypt(*ctx, block, blklen, block, blklen);
} else { }
else {
ret = gcry_cipher_decrypt(*ctx, block, blklen, block, blklen); ret = gcry_cipher_decrypt(*ctx, block, blklen, block, blklen);
} }
return ret; return ret;

66
src/libgcrypt.h
View File

@@ -73,82 +73,82 @@
/* returns 0 in case of failure */ /* returns 0 in case of failure */
#define libssh2_sha1_init(ctx) \ #define libssh2_sha1_init(ctx) \
(GPG_ERR_NO_ERROR == gcry_md_open (ctx, GCRY_MD_SHA1, 0)) (GPG_ERR_NO_ERROR == gcry_md_open(ctx, GCRY_MD_SHA1, 0))
#define libssh2_sha1_update(ctx, data, len) \ #define libssh2_sha1_update(ctx, data, len) \
gcry_md_write (ctx, (unsigned char *) data, len) gcry_md_write(ctx, (unsigned char *) data, len)
#define libssh2_sha1_final(ctx, out) \ #define libssh2_sha1_final(ctx, out) \
memcpy (out, gcry_md_read (ctx, 0), SHA_DIGEST_LENGTH), gcry_md_close (ctx) memcpy(out, gcry_md_read(ctx, 0), SHA_DIGEST_LENGTH), gcry_md_close(ctx)
#define libssh2_sha1(message, len, out) \ #define libssh2_sha1(message, len, out) \
gcry_md_hash_buffer (GCRY_MD_SHA1, out, message, len) gcry_md_hash_buffer(GCRY_MD_SHA1, out, message, len)
#define libssh2_sha256_ctx gcry_md_hd_t #define libssh2_sha256_ctx gcry_md_hd_t
#define libssh2_sha256_init(ctx) \ #define libssh2_sha256_init(ctx) \
(GPG_ERR_NO_ERROR == gcry_md_open (ctx, GCRY_MD_SHA256, 0)) (GPG_ERR_NO_ERROR == gcry_md_open(ctx, GCRY_MD_SHA256, 0))
#define libssh2_sha256_update(ctx, data, len) \ #define libssh2_sha256_update(ctx, data, len) \
gcry_md_write (ctx, (unsigned char *) data, len) gcry_md_write(ctx, (unsigned char *) data, len)
#define libssh2_sha256_final(ctx, out) \ #define libssh2_sha256_final(ctx, out) \
memcpy (out, gcry_md_read (ctx, 0), SHA256_DIGEST_LENGTH), gcry_md_close (ctx) memcpy(out, gcry_md_read(ctx, 0), SHA256_DIGEST_LENGTH), gcry_md_close(ctx)
#define libssh2_sha256(message, len, out) \ #define libssh2_sha256(message, len, out) \
gcry_md_hash_buffer (GCRY_MD_SHA256, out, message, len) gcry_md_hash_buffer(GCRY_MD_SHA256, out, message, len)
#define libssh2_sha384_ctx gcry_md_hd_t #define libssh2_sha384_ctx gcry_md_hd_t
#define libssh2_sha384_init(ctx) \ #define libssh2_sha384_init(ctx) \
(GPG_ERR_NO_ERROR == gcry_md_open (ctx, GCRY_MD_SHA384, 0)) (GPG_ERR_NO_ERROR == gcry_md_open(ctx, GCRY_MD_SHA384, 0))
#define libssh2_sha384_update(ctx, data, len) \ #define libssh2_sha384_update(ctx, data, len) \
gcry_md_write (ctx, (unsigned char *) data, len) gcry_md_write(ctx, (unsigned char *) data, len)
#define libssh2_sha384_final(ctx, out) \ #define libssh2_sha384_final(ctx, out) \
memcpy (out, gcry_md_read (ctx, 0), SHA384_DIGEST_LENGTH), gcry_md_close (ctx) memcpy(out, gcry_md_read(ctx, 0), SHA384_DIGEST_LENGTH), gcry_md_close(ctx)
#define libssh2_sha384(message, len, out) \ #define libssh2_sha384(message, len, out) \
gcry_md_hash_buffer (GCRY_MD_SHA384, out, message, len) gcry_md_hash_buffer(GCRY_MD_SHA384, out, message, len)
#define libssh2_sha512_ctx gcry_md_hd_t #define libssh2_sha512_ctx gcry_md_hd_t
#define libssh2_sha512_init(ctx) \ #define libssh2_sha512_init(ctx) \
(GPG_ERR_NO_ERROR == gcry_md_open (ctx, GCRY_MD_SHA512, 0)) (GPG_ERR_NO_ERROR == gcry_md_open(ctx, GCRY_MD_SHA512, 0))
#define libssh2_sha512_update(ctx, data, len) \ #define libssh2_sha512_update(ctx, data, len) \
gcry_md_write (ctx, (unsigned char *) data, len) gcry_md_write(ctx, (unsigned char *) data, len)
#define libssh2_sha512_final(ctx, out) \ #define libssh2_sha512_final(ctx, out) \
memcpy (out, gcry_md_read (ctx, 0), SHA512_DIGEST_LENGTH), gcry_md_close (ctx) memcpy(out, gcry_md_read(ctx, 0), SHA512_DIGEST_LENGTH), gcry_md_close(ctx)
#define libssh2_sha512(message, len, out) \ #define libssh2_sha512(message, len, out) \
gcry_md_hash_buffer (GCRY_MD_SHA512, out, message, len) gcry_md_hash_buffer(GCRY_MD_SHA512, out, message, len)
#define libssh2_md5_ctx gcry_md_hd_t #define libssh2_md5_ctx gcry_md_hd_t
/* returns 0 in case of failure */ /* returns 0 in case of failure */
#define libssh2_md5_init(ctx) \ #define libssh2_md5_init(ctx) \
(GPG_ERR_NO_ERROR == gcry_md_open (ctx, GCRY_MD_MD5, 0)) (GPG_ERR_NO_ERROR == gcry_md_open(ctx, GCRY_MD_MD5, 0))
#define libssh2_md5_update(ctx, data, len) \ #define libssh2_md5_update(ctx, data, len) \
gcry_md_write (ctx, (unsigned char *) data, len) gcry_md_write(ctx, (unsigned char *) data, len)
#define libssh2_md5_final(ctx, out) \ #define libssh2_md5_final(ctx, out) \
memcpy (out, gcry_md_read (ctx, 0), MD5_DIGEST_LENGTH), gcry_md_close (ctx) memcpy(out, gcry_md_read(ctx, 0), MD5_DIGEST_LENGTH), gcry_md_close(ctx)
#define libssh2_md5(message, len, out) \ #define libssh2_md5(message, len, out) \
gcry_md_hash_buffer (GCRY_MD_MD5, out, message, len) gcry_md_hash_buffer(GCRY_MD_MD5, out, message, len)
#define libssh2_hmac_ctx gcry_md_hd_t #define libssh2_hmac_ctx gcry_md_hd_t
#define libssh2_hmac_ctx_init(ctx) #define libssh2_hmac_ctx_init(ctx)
#define libssh2_hmac_sha1_init(ctx, key, keylen) \ #define libssh2_hmac_sha1_init(ctx, key, keylen) \
gcry_md_open (ctx, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC), \ gcry_md_open(ctx, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC), \
gcry_md_setkey (*ctx, key, keylen) gcry_md_setkey(*ctx, key, keylen)
#define libssh2_hmac_md5_init(ctx, key, keylen) \ #define libssh2_hmac_md5_init(ctx, key, keylen) \
gcry_md_open (ctx, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC), \ gcry_md_open(ctx, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC), \
gcry_md_setkey (*ctx, key, keylen) gcry_md_setkey(*ctx, key, keylen)
#define libssh2_hmac_ripemd160_init(ctx, key, keylen) \ #define libssh2_hmac_ripemd160_init(ctx, key, keylen) \
gcry_md_open (ctx, GCRY_MD_RMD160, GCRY_MD_FLAG_HMAC), \ gcry_md_open(ctx, GCRY_MD_RMD160, GCRY_MD_FLAG_HMAC), \
gcry_md_setkey (*ctx, key, keylen) gcry_md_setkey(*ctx, key, keylen)
#define libssh2_hmac_sha256_init(ctx, key, keylen) \ #define libssh2_hmac_sha256_init(ctx, key, keylen) \
gcry_md_open (ctx, GCRY_MD_SHA256, GCRY_MD_FLAG_HMAC), \ gcry_md_open(ctx, GCRY_MD_SHA256, GCRY_MD_FLAG_HMAC), \
gcry_md_setkey (*ctx, key, keylen) gcry_md_setkey(*ctx, key, keylen)
#define libssh2_hmac_sha512_init(ctx, key, keylen) \ #define libssh2_hmac_sha512_init(ctx, key, keylen) \
gcry_md_open (ctx, GCRY_MD_SHA512, GCRY_MD_FLAG_HMAC), \ gcry_md_open(ctx, GCRY_MD_SHA512, GCRY_MD_FLAG_HMAC), \
gcry_md_setkey (*ctx, key, keylen) gcry_md_setkey(*ctx, key, keylen)
#define libssh2_hmac_update(ctx, data, datalen) \ #define libssh2_hmac_update(ctx, data, datalen) \
gcry_md_write (ctx, (unsigned char *) data, datalen) gcry_md_write(ctx, (unsigned char *) data, datalen)
#define libssh2_hmac_final(ctx, data) \ #define libssh2_hmac_final(ctx, data) \
memcpy (data, gcry_md_read (ctx, 0), \ memcpy(data, gcry_md_read(ctx, 0), \
gcry_md_get_algo_dlen (gcry_md_get_algo (ctx))) gcry_md_get_algo_dlen(gcry_md_get_algo(ctx)))
#define libssh2_hmac_cleanup(ctx) gcry_md_close (*ctx); #define libssh2_hmac_cleanup(ctx) gcry_md_close (*ctx);
#define libssh2_crypto_init() gcry_control (GCRYCTL_DISABLE_SECMEM) #define libssh2_crypto_init() gcry_control (GCRYCTL_DISABLE_SECMEM)

10
src/libssh2_priv.h
View File

@@ -118,13 +118,13 @@
struct iovec { struct iovec {
size_t iov_len; size_t iov_len;
void * iov_base; void *iov_base;
}; };
static inline int writev(int sock, struct iovec *iov, int nvecs) static inline int writev(int sock, struct iovec *iov, int nvecs)
{ {
DWORD ret; DWORD ret;
if (WSASend(sock, (LPWSABUF)iov, nvecs, &ret, 0, NULL, NULL) == 0) { if(WSASend(sock, (LPWSABUF)iov, nvecs, &ret, 0, NULL, NULL) == 0) {
return ret; return ret;
} }
return -1; return -1;
@@ -649,7 +649,7 @@ struct _LIBSSH2_SESSION
#ifdef LIBSSH2DEBUG #ifdef LIBSSH2DEBUG
int showmask; /* what debug/trace messages to display */ int showmask; /* what debug/trace messages to display */
libssh2_trace_handler_func tracehandler; /* callback to display trace messages */ libssh2_trace_handler_func tracehandler; /* callback to display trace messages */
void* tracehandler_context; /* context for the trace handler */ void *tracehandler_context; /* context for the trace handler */
#endif #endif
/* State variables used in libssh2_banner_send() */ /* State variables used in libssh2_banner_send() */
@@ -1064,13 +1064,13 @@ int _libssh2_pem_decode_integer(unsigned char **data, unsigned int *datalen,
unsigned char **i, unsigned int *ilen); unsigned char **i, unsigned int *ilen);
/* global.c */ /* global.c */
void _libssh2_init_if_needed (void); void _libssh2_init_if_needed(void);
#define ARRAY_SIZE(a) (sizeof ((a)) / sizeof ((a)[0])) #define ARRAY_SIZE(a) (sizeof ((a)) / sizeof ((a)[0]))
/* define to output the libssh2_int64_t type in a *printf() */ /* define to output the libssh2_int64_t type in a *printf() */
#if defined( __BORLANDC__ ) || defined( _MSC_VER ) || defined( __MINGW32__ ) #if defined(__BORLANDC__) || defined(_MSC_VER) || defined(__MINGW32__)
#define LIBSSH2_INT64_T_FORMAT "I64d" #define LIBSSH2_INT64_T_FORMAT "I64d"
#else #else
#define LIBSSH2_INT64_T_FORMAT "lld" #define LIBSSH2_INT64_T_FORMAT "lld"

12
src/mac.c
View File

@@ -86,7 +86,7 @@ mac_method_common_init(LIBSSH2_SESSION * session, unsigned char *key,
static int static int
mac_method_common_dtor(LIBSSH2_SESSION * session, void **abstract) mac_method_common_dtor(LIBSSH2_SESSION * session, void **abstract)
{ {
if (*abstract) { if(*abstract) {
LIBSSH2_FREE(session, *abstract); LIBSSH2_FREE(session, *abstract);
} }
*abstract = NULL; *abstract = NULL;
@@ -118,7 +118,7 @@ mac_method_hmac_sha2_512_hash(LIBSSH2_SESSION * session,
libssh2_hmac_sha512_init(&ctx, *abstract, 64); libssh2_hmac_sha512_init(&ctx, *abstract, 64);
libssh2_hmac_update(ctx, seqno_buf, 4); libssh2_hmac_update(ctx, seqno_buf, 4);
libssh2_hmac_update(ctx, packet, packet_len); libssh2_hmac_update(ctx, packet, packet_len);
if (addtl && addtl_len) { if(addtl && addtl_len) {
libssh2_hmac_update(ctx, addtl, addtl_len); libssh2_hmac_update(ctx, addtl, addtl_len);
} }
libssh2_hmac_final(ctx, buf); libssh2_hmac_final(ctx, buf);
@@ -163,7 +163,7 @@ mac_method_hmac_sha2_256_hash(LIBSSH2_SESSION * session,
libssh2_hmac_sha256_init(&ctx, *abstract, 32); libssh2_hmac_sha256_init(&ctx, *abstract, 32);
libssh2_hmac_update(ctx, seqno_buf, 4); libssh2_hmac_update(ctx, seqno_buf, 4);
libssh2_hmac_update(ctx, packet, packet_len); libssh2_hmac_update(ctx, packet, packet_len);
if (addtl && addtl_len) { if(addtl && addtl_len) {
libssh2_hmac_update(ctx, addtl, addtl_len); libssh2_hmac_update(ctx, addtl, addtl_len);
} }
libssh2_hmac_final(ctx, buf); libssh2_hmac_final(ctx, buf);
@@ -208,7 +208,7 @@ mac_method_hmac_sha1_hash(LIBSSH2_SESSION * session,
libssh2_hmac_sha1_init(&ctx, *abstract, 20); libssh2_hmac_sha1_init(&ctx, *abstract, 20);
libssh2_hmac_update(ctx, seqno_buf, 4); libssh2_hmac_update(ctx, seqno_buf, 4);
libssh2_hmac_update(ctx, packet, packet_len); libssh2_hmac_update(ctx, packet, packet_len);
if (addtl && addtl_len) { if(addtl && addtl_len) {
libssh2_hmac_update(ctx, addtl, addtl_len); libssh2_hmac_update(ctx, addtl, addtl_len);
} }
libssh2_hmac_final(ctx, buf); libssh2_hmac_final(ctx, buf);
@@ -281,7 +281,7 @@ mac_method_hmac_md5_hash(LIBSSH2_SESSION * session, unsigned char *buf,
libssh2_hmac_md5_init(&ctx, *abstract, 16); libssh2_hmac_md5_init(&ctx, *abstract, 16);
libssh2_hmac_update(ctx, seqno_buf, 4); libssh2_hmac_update(ctx, seqno_buf, 4);
libssh2_hmac_update(ctx, packet, packet_len); libssh2_hmac_update(ctx, packet, packet_len);
if (addtl && addtl_len) { if(addtl && addtl_len) {
libssh2_hmac_update(ctx, addtl, addtl_len); libssh2_hmac_update(ctx, addtl, addtl_len);
} }
libssh2_hmac_final(ctx, buf); libssh2_hmac_final(ctx, buf);
@@ -354,7 +354,7 @@ mac_method_hmac_ripemd160_hash(LIBSSH2_SESSION * session,
libssh2_hmac_ripemd160_init(&ctx, *abstract, 20); libssh2_hmac_ripemd160_init(&ctx, *abstract, 20);
libssh2_hmac_update(ctx, seqno_buf, 4); libssh2_hmac_update(ctx, seqno_buf, 4);
libssh2_hmac_update(ctx, packet, packet_len); libssh2_hmac_update(ctx, packet, packet_len);
if (addtl && addtl_len) { if(addtl && addtl_len) {
libssh2_hmac_update(ctx, addtl, addtl_len); libssh2_hmac_update(ctx, addtl, addtl_len);
} }
libssh2_hmac_final(ctx, buf); libssh2_hmac_final(ctx, buf);

119
src/mbedtls.c
View File

@@ -18,7 +18,7 @@ _libssh2_mbedtls_init(void)
ret = mbedtls_ctr_drbg_seed(&_libssh2_mbedtls_ctr_drbg, ret = mbedtls_ctr_drbg_seed(&_libssh2_mbedtls_ctr_drbg,
mbedtls_entropy_func, mbedtls_entropy_func,
&_libssh2_mbedtls_entropy, NULL, 0); &_libssh2_mbedtls_entropy, NULL, 0);
if (ret != 0) if(ret != 0)
mbedtls_ctr_drbg_free(&_libssh2_mbedtls_ctr_drbg); mbedtls_ctr_drbg_free(&_libssh2_mbedtls_ctr_drbg);
} }
@@ -44,11 +44,11 @@ _libssh2_mbedtls_safe_free(void *buf, int len)
(void)len; (void)len;
#endif #endif
if (!buf) if(!buf)
return; return;
#ifdef LIBSSH2_CLEAR_MEMORY #ifdef LIBSSH2_CLEAR_MEMORY
if (len > 0) if(len > 0)
memset(buf, 0, len); memset(buf, 0, len);
#endif #endif
@@ -65,7 +65,7 @@ _libssh2_mbedtls_cipher_init(_libssh2_cipher_ctx *ctx,
const mbedtls_cipher_info_t *cipher_info; const mbedtls_cipher_info_t *cipher_info;
int ret, op; int ret, op;
if (!ctx) if(!ctx)
return -1; return -1;
op = encrypt == 0 ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT; op = encrypt == 0 ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT;
@@ -99,11 +99,10 @@ _libssh2_mbedtls_cipher_crypt(_libssh2_cipher_ctx *ctx,
(void) encrypt; (void) encrypt;
(void) algo; (void) algo;
osize = blocklen+mbedtls_cipher_get_block_size(ctx); osize = blocklen + mbedtls_cipher_get_block_size(ctx);
output = (unsigned char *)mbedtls_calloc(osize, sizeof(char)); output = (unsigned char *)mbedtls_calloc(osize, sizeof(char));
if(output) if(output) {
{
ret = mbedtls_cipher_reset(ctx); ret = mbedtls_cipher_reset(ctx);
if(!ret) if(!ret)
@@ -112,7 +111,7 @@ _libssh2_mbedtls_cipher_crypt(_libssh2_cipher_ctx *ctx,
if(!ret) if(!ret)
ret = mbedtls_cipher_finish(ctx, output + olen, &finish_olen); ret = mbedtls_cipher_finish(ctx, output + olen, &finish_olen);
if (!ret) { if(!ret) {
olen += finish_olen; olen += finish_olen;
memcpy(block, output, olen); memcpy(block, output, olen);
} }
@@ -148,8 +147,8 @@ _libssh2_mbedtls_hash_init(mbedtls_md_context_t *ctx,
mbedtls_md_init(ctx); mbedtls_md_init(ctx);
ret = mbedtls_md_setup(ctx, md_info, hmac); ret = mbedtls_md_setup(ctx, md_info, hmac);
if (!ret){ if(!ret) {
if (hmac) if(hmac)
ret = mbedtls_md_hmac_starts(ctx, key, keylen); ret = mbedtls_md_hmac_starts(ctx, key, keylen);
else else
ret = mbedtls_md_starts(ctx); ret = mbedtls_md_starts(ctx);
@@ -196,7 +195,7 @@ _libssh2_mbedtls_bignum_init(void)
_libssh2_bn *bignum; _libssh2_bn *bignum;
bignum = (_libssh2_bn *)mbedtls_calloc(1, sizeof(_libssh2_bn)); bignum = (_libssh2_bn *)mbedtls_calloc(1, sizeof(_libssh2_bn));
if (bignum) { if(bignum) {
mbedtls_mpi_init(bignum); mbedtls_mpi_init(bignum);
} }
@@ -210,18 +209,18 @@ _libssh2_mbedtls_bignum_random(_libssh2_bn *bn, int bits, int top, int bottom)
int err; int err;
int i; int i;
if (!bn || bits <= 0) if(!bn || bits <= 0)
return -1; return -1;
len = (bits + 7) >> 3; len = (bits + 7) >> 3;
err = mbedtls_mpi_fill_random(bn, len, mbedtls_ctr_drbg_random, &_libssh2_mbedtls_ctr_drbg); err = mbedtls_mpi_fill_random(bn, len, mbedtls_ctr_drbg_random, &_libssh2_mbedtls_ctr_drbg);
if (err) if(err)
return -1; return -1;
/* Zero unsued bits above the most significant bit*/ /* Zero unsued bits above the most significant bit*/
for(i=len*8-1;bits<=i;--i) { for(i = len*8 - 1; bits <= i; --i) {
err = mbedtls_mpi_set_bit(bn, i, 0); err = mbedtls_mpi_set_bit(bn, i, 0);
if (err) if(err)
return -1; return -1;
} }
@@ -230,16 +229,16 @@ _libssh2_mbedtls_bignum_random(_libssh2_bn *bn, int bits, int top, int bottom)
and if top is 1, the two most significant bits of the number will be set and if top is 1, the two most significant bits of the number will be set
to 1, so that the product of two such random numbers will always have 2*bits length. to 1, so that the product of two such random numbers will always have 2*bits length.
*/ */
for(i=0;i<=top;++i) { for(i = 0; i <= top; ++i) {
err = mbedtls_mpi_set_bit(bn, bits-i-1, 1); err = mbedtls_mpi_set_bit(bn, bits-i-1, 1);
if (err) if(err)
return -1; return -1;
} }
/* make odd by setting first bit in least significant byte */ /* make odd by setting first bit in least significant byte */
if (bottom) { if(bottom) {
err = mbedtls_mpi_set_bit(bn, 0, 1); err = mbedtls_mpi_set_bit(bn, 0, 1);
if (err) if(err)
return -1; return -1;
} }
@@ -275,42 +274,37 @@ _libssh2_mbedtls_rsa_new(libssh2_rsa_ctx **rsa,
libssh2_rsa_ctx *ctx; libssh2_rsa_ctx *ctx;
ctx = (libssh2_rsa_ctx *) mbedtls_calloc(1, sizeof(libssh2_rsa_ctx)); ctx = (libssh2_rsa_ctx *) mbedtls_calloc(1, sizeof(libssh2_rsa_ctx));
if (ctx != NULL) { if(ctx != NULL) {
mbedtls_rsa_init(ctx, MBEDTLS_RSA_PKCS_V15, 0); mbedtls_rsa_init(ctx, MBEDTLS_RSA_PKCS_V15, 0);
} }
else else
return -1; return -1;
if( (ret = mbedtls_mpi_read_binary(&(ctx->E), edata, elen) ) != 0 || if((ret = mbedtls_mpi_read_binary(&(ctx->E), edata, elen) ) != 0 ||
(ret = mbedtls_mpi_read_binary(&(ctx->N), ndata, nlen) ) != 0 ) (ret = mbedtls_mpi_read_binary(&(ctx->N), ndata, nlen) ) != 0) {
{
ret = -1; ret = -1;
} }
if (!ret) if(!ret) {
{
ctx->len = mbedtls_mpi_size(&(ctx->N)); ctx->len = mbedtls_mpi_size(&(ctx->N));
} }
if (!ret && ddata) if(!ret && ddata) {
{ if((ret = mbedtls_mpi_read_binary(&(ctx->D), ddata, dlen) ) != 0 ||
if( (ret = mbedtls_mpi_read_binary(&(ctx->D) , ddata, dlen) ) != 0 || (ret = mbedtls_mpi_read_binary(&(ctx->P), pdata, plen) ) != 0 ||
(ret = mbedtls_mpi_read_binary(&(ctx->P) , pdata, plen) ) != 0 || (ret = mbedtls_mpi_read_binary(&(ctx->Q), qdata, qlen) ) != 0 ||
(ret = mbedtls_mpi_read_binary(&(ctx->Q) , qdata, qlen) ) != 0 || (ret = mbedtls_mpi_read_binary(&(ctx->DP), e1data, e1len) ) != 0 ||
(ret = mbedtls_mpi_read_binary(&(ctx->DP), e1data, e1len) ) != 0 || (ret = mbedtls_mpi_read_binary(&(ctx->DQ), e2data, e2len) ) != 0 ||
(ret = mbedtls_mpi_read_binary(&(ctx->DQ), e2data, e2len) ) != 0 || (ret = mbedtls_mpi_read_binary(&(ctx->QP), coeffdata, coefflen) ) != 0) {
(ret = mbedtls_mpi_read_binary(&(ctx->QP), coeffdata, coefflen) ) != 0 )
{
ret = -1; ret = -1;
} }
ret = mbedtls_rsa_check_privkey(ctx); ret = mbedtls_rsa_check_privkey(ctx);
} }
else if (!ret) else if(!ret) {
{
ret = mbedtls_rsa_check_pubkey(ctx); ret = mbedtls_rsa_check_pubkey(ctx);
} }
if (ret && ctx) { if(ret && ctx) {
_libssh2_mbedtls_rsa_free(ctx); _libssh2_mbedtls_rsa_free(ctx);
ctx = NULL; ctx = NULL;
} }
@@ -328,15 +322,14 @@ _libssh2_mbedtls_rsa_new_private(libssh2_rsa_ctx **rsa,
mbedtls_pk_context pkey; mbedtls_pk_context pkey;
*rsa = (libssh2_rsa_ctx *) LIBSSH2_ALLOC(session, sizeof(libssh2_rsa_ctx)); *rsa = (libssh2_rsa_ctx *) LIBSSH2_ALLOC(session, sizeof(libssh2_rsa_ctx));
if (*rsa == NULL) if(*rsa == NULL)
return -1; return -1;
mbedtls_rsa_init(*rsa, MBEDTLS_RSA_PKCS_V15, 0); mbedtls_rsa_init(*rsa, MBEDTLS_RSA_PKCS_V15, 0);
mbedtls_pk_init(&pkey); mbedtls_pk_init(&pkey);
ret = mbedtls_pk_parse_keyfile(&pkey, filename, (char *)passphrase); ret = mbedtls_pk_parse_keyfile(&pkey, filename, (char *)passphrase);
if( ret != 0 || mbedtls_pk_get_type(&pkey) != MBEDTLS_PK_RSA) if(ret != 0 || mbedtls_pk_get_type(&pkey) != MBEDTLS_PK_RSA) {
{
mbedtls_pk_free(&pkey); mbedtls_pk_free(&pkey);
mbedtls_rsa_free(*rsa); mbedtls_rsa_free(*rsa);
LIBSSH2_FREE(session, *rsa); LIBSSH2_FREE(session, *rsa);
@@ -361,16 +354,15 @@ _libssh2_mbedtls_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
int ret; int ret;
mbedtls_pk_context pkey; mbedtls_pk_context pkey;
*rsa = (libssh2_rsa_ctx *) mbedtls_calloc( 1, sizeof( libssh2_rsa_ctx ) ); *rsa = (libssh2_rsa_ctx *) mbedtls_calloc(1, sizeof(libssh2_rsa_ctx));
if (*rsa == NULL) if(*rsa == NULL)
return -1; return -1;
mbedtls_pk_init(&pkey); mbedtls_pk_init(&pkey);
ret = mbedtls_pk_parse_key(&pkey, (unsigned char *)filedata, ret = mbedtls_pk_parse_key(&pkey, (unsigned char *)filedata,
filedata_len, NULL, 0); filedata_len, NULL, 0);
if( ret != 0 || mbedtls_pk_get_type(&pkey) != MBEDTLS_PK_RSA) if(ret != 0 || mbedtls_pk_get_type(&pkey) != MBEDTLS_PK_RSA) {
{
mbedtls_pk_free(&pkey); mbedtls_pk_free(&pkey);
mbedtls_rsa_free(*rsa); mbedtls_rsa_free(*rsa);
LIBSSH2_FREE(session, *rsa); LIBSSH2_FREE(session, *rsa);
@@ -421,14 +413,14 @@ _libssh2_mbedtls_rsa_sha1_sign(LIBSSH2_SESSION *session,
sig_len = rsa->len; sig_len = rsa->len;
sig = LIBSSH2_ALLOC(session, sig_len); sig = LIBSSH2_ALLOC(session, sig_len);
if (!sig) { if(!sig) {
return -1; return -1;
} }
ret = mbedtls_rsa_pkcs1_sign(rsa, NULL, NULL, MBEDTLS_RSA_PRIVATE, ret = mbedtls_rsa_pkcs1_sign(rsa, NULL, NULL, MBEDTLS_RSA_PRIVATE,
MBEDTLS_MD_SHA1, SHA_DIGEST_LENGTH, MBEDTLS_MD_SHA1, SHA_DIGEST_LENGTH,
hash, sig); hash, sig);
if (ret) { if(ret) {
LIBSSH2_FREE(session, sig); LIBSSH2_FREE(session, sig);
return -1; return -1;
} }
@@ -453,8 +445,8 @@ gen_publickey_from_rsa(LIBSSH2_SESSION *session,
{ {
int e_bytes, n_bytes; int e_bytes, n_bytes;
unsigned long len; unsigned long len;
unsigned char* key; unsigned char *key;
unsigned char* p; unsigned char *p;
e_bytes = mbedtls_mpi_size(&rsa->E); e_bytes = mbedtls_mpi_size(&rsa->E);
n_bytes = mbedtls_mpi_size(&rsa->N); n_bytes = mbedtls_mpi_size(&rsa->N);
@@ -463,7 +455,7 @@ gen_publickey_from_rsa(LIBSSH2_SESSION *session,
len = 4 + 7 + 4 + e_bytes + 4 + n_bytes; len = 4 + 7 + 4 + e_bytes + 4 + n_bytes;
key = LIBSSH2_ALLOC(session, len); key = LIBSSH2_ALLOC(session, len);
if (!key) { if(!key) {
return NULL; return NULL;
} }
@@ -499,35 +491,36 @@ _libssh2_mbedtls_pub_priv_key(LIBSSH2_SESSION *session,
size_t keylen = 0, mthlen = 0; size_t keylen = 0, mthlen = 0;
int ret; int ret;
if( mbedtls_pk_get_type(pkey) != MBEDTLS_PK_RSA ) if(mbedtls_pk_get_type(pkey) != MBEDTLS_PK_RSA) {
{
mbedtls_pk_free(pkey); mbedtls_pk_free(pkey);
return _libssh2_error(session, LIBSSH2_ERROR_FILE, return _libssh2_error(session, LIBSSH2_ERROR_FILE,
"Key type not supported"); "Key type not supported");
} }
// write method /* write method */
mthlen = 7; mthlen = 7;
mth = LIBSSH2_ALLOC(session, mthlen); mth = LIBSSH2_ALLOC(session, mthlen);
if (mth) { if(mth) {
memcpy(mth, "ssh-rsa", mthlen); memcpy(mth, "ssh-rsa", mthlen);
} else { }
else {
ret = -1; ret = -1;
} }
mbedtls_rsa_context *rsa = mbedtls_pk_rsa(*pkey); mbedtls_rsa_context *rsa = mbedtls_pk_rsa(*pkey);
key = gen_publickey_from_rsa(session, rsa, &keylen); key = gen_publickey_from_rsa(session, rsa, &keylen);
if (key == NULL) { if(key == NULL) {
ret = -1; ret = -1;
} }
// write output /* write output */
if (ret) { if(ret) {
if (mth) if(mth)
LIBSSH2_FREE(session, mth); LIBSSH2_FREE(session, mth);
if (key) if(key)
LIBSSH2_FREE(session, key); LIBSSH2_FREE(session, key);
} else { }
else {
*method = mth; *method = mth;
*method_len = mthlen; *method_len = mthlen;
*pubkeydata = key; *pubkeydata = key;
@@ -552,8 +545,7 @@ _libssh2_mbedtls_pub_priv_keyfile(LIBSSH2_SESSION *session,
mbedtls_pk_init(&pkey); mbedtls_pk_init(&pkey);
ret = mbedtls_pk_parse_keyfile(&pkey, privatekey, passphrase); ret = mbedtls_pk_parse_keyfile(&pkey, privatekey, passphrase);
if( ret != 0 ) if(ret != 0) {
{
mbedtls_strerror(ret, (char *)buf, sizeof(buf)); mbedtls_strerror(ret, (char *)buf, sizeof(buf));
mbedtls_pk_free(&pkey); mbedtls_pk_free(&pkey);
return _libssh2_error(session, LIBSSH2_ERROR_FILE, buf); return _libssh2_error(session, LIBSSH2_ERROR_FILE, buf);
@@ -584,8 +576,7 @@ _libssh2_mbedtls_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
mbedtls_pk_init(&pkey); mbedtls_pk_init(&pkey);
ret = mbedtls_pk_parse_key(&pkey, (unsigned char *)privatekeydata, ret = mbedtls_pk_parse_key(&pkey, (unsigned char *)privatekeydata,
privatekeydata_len, NULL, 0); privatekeydata_len, NULL, 0);
if( ret != 0 ) if(ret != 0) {
{
mbedtls_strerror(ret, (char *)buf, sizeof(buf)); mbedtls_strerror(ret, (char *)buf, sizeof(buf));
mbedtls_pk_free(&pkey); mbedtls_pk_free(&pkey);
return _libssh2_error(session, LIBSSH2_ERROR_FILE, buf); return _libssh2_error(session, LIBSSH2_ERROR_FILE, buf);

201
src/misc.c
View File

@@ -51,18 +51,18 @@
#include <stdio.h> #include <stdio.h>
#include <errno.h> #include <errno.h>
int _libssh2_error_flags(LIBSSH2_SESSION* session, int errcode, const char* errmsg, int errflags) int _libssh2_error_flags(LIBSSH2_SESSION* session, int errcode, const char *errmsg, int errflags)
{ {
if (session->err_flags & LIBSSH2_ERR_FLAG_DUP) if(session->err_flags & LIBSSH2_ERR_FLAG_DUP)
LIBSSH2_FREE(session, (char *)session->err_msg); LIBSSH2_FREE(session, (char *)session->err_msg);
session->err_code = errcode; session->err_code = errcode;
session->err_flags = 0; session->err_flags = 0;
if ((errmsg != NULL) && ((errflags & LIBSSH2_ERR_FLAG_DUP) != 0)) { if((errmsg != NULL) && ((errflags & LIBSSH2_ERR_FLAG_DUP) != 0)) {
size_t len = strlen(errmsg); size_t len = strlen(errmsg);
char *copy = LIBSSH2_ALLOC(session, len + 1); char *copy = LIBSSH2_ALLOC(session, len + 1);
if (copy) { if(copy) {
memcpy(copy, errmsg, len + 1); memcpy(copy, errmsg, len + 1);
session->err_flags = LIBSSH2_ERR_FLAG_DUP; session->err_flags = LIBSSH2_ERR_FLAG_DUP;
session->err_msg = copy; session->err_msg = copy;
@@ -86,7 +86,7 @@ int _libssh2_error_flags(LIBSSH2_SESSION* session, int errcode, const char* errm
return errcode; return errcode;
} }
int _libssh2_error(LIBSSH2_SESSION* session, int errcode, const char* errmsg) int _libssh2_error(LIBSSH2_SESSION* session, int errcode, const char *errmsg)
{ {
return _libssh2_error_flags(session, errcode, errmsg, 0); return _libssh2_error_flags(session, errcode, errmsg, 0);
} }
@@ -94,7 +94,7 @@ int _libssh2_error(LIBSSH2_SESSION* session, int errcode, const char* errmsg)
#ifdef WIN32 #ifdef WIN32
static int wsa2errno(void) static int wsa2errno(void)
{ {
switch (WSAGetLastError()) { switch(WSAGetLastError()) {
case WSAEWOULDBLOCK: case WSAEWOULDBLOCK:
return EAGAIN; return EAGAIN;
@@ -127,20 +127,20 @@ _libssh2_recv(libssh2_socket_t sock, void *buffer, size_t length,
rc = recv(sock, buffer, length, flags); rc = recv(sock, buffer, length, flags);
#ifdef WIN32 #ifdef WIN32
if (rc < 0 ) if(rc < 0)
return -wsa2errno(); return -wsa2errno();
#elif defined(__VMS) #elif defined(__VMS)
if (rc < 0 ){ if(rc < 0) {
if ( errno == EWOULDBLOCK ) if(errno == EWOULDBLOCK)
return -EAGAIN; return -EAGAIN;
else else
return -errno; return -errno;
} }
#else #else
if (rc < 0 ){ if(rc < 0) {
/* Sometimes the first recv() function call sets errno to ENOENT on /* Sometimes the first recv() function call sets errno to ENOENT on
Solaris and HP-UX */ Solaris and HP-UX */
if ( errno == ENOENT ) if(errno == ENOENT)
return -EAGAIN; return -EAGAIN;
else else
return -errno; return -errno;
@@ -163,17 +163,17 @@ _libssh2_send(libssh2_socket_t sock, const void *buffer, size_t length,
rc = send(sock, buffer, length, flags); rc = send(sock, buffer, length, flags);
#ifdef WIN32 #ifdef WIN32
if (rc < 0 ) if(rc < 0)
return -wsa2errno(); return -wsa2errno();
#elif defined(__VMS) #elif defined(__VMS)
if (rc < 0 ) { if(rc < 0) {
if ( errno == EWOULDBLOCK ) if(errno == EWOULDBLOCK)
return -EAGAIN; return -EAGAIN;
else else
return -errno; return -errno;
} }
#else #else
if (rc < 0 ) if(rc < 0)
return -errno; return -errno;
#endif #endif
return rc; return rc;
@@ -269,15 +269,16 @@ libssh2_base64_decode(LIBSSH2_SESSION *session, char **data,
*data = LIBSSH2_ALLOC(session, (3 * src_len / 4) + 1); *data = LIBSSH2_ALLOC(session, (3 * src_len / 4) + 1);
d = (unsigned char *) *data; d = (unsigned char *) *data;
if (!d) { if(!d) {
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for base64 decoding"); "Unable to allocate memory for base64 decoding");
} }
for(s = (unsigned char *) src; ((char *) s) < (src + src_len); s++) { for(s = (unsigned char *) src; ((char *) s) < (src + src_len); s++) {
if ((v = base64_reverse_table[*s]) < 0) v = base64_reverse_table[*s];
if(v < 0)
continue; continue;
switch (i % 4) { switch(i % 4) {
case 0: case 0:
d[len] = (unsigned char)(v << 2); d[len] = (unsigned char)(v << 2);
break; break;
@@ -295,7 +296,7 @@ libssh2_base64_decode(LIBSSH2_SESSION *session, char **data,
} }
i++; i++;
} }
if ((i % 4) == 1) { if((i % 4) == 1) {
/* Invalid -- We have a byte which belongs exclusively to a partial /* Invalid -- We have a byte which belongs exclusively to a partial
octet */ octet */
LIBSSH2_FREE(session, *data); LIBSSH2_FREE(session, *data);
@@ -322,68 +323,68 @@ static const char table64[]=
size_t _libssh2_base64_encode(LIBSSH2_SESSION *session, size_t _libssh2_base64_encode(LIBSSH2_SESSION *session,
const char *inp, size_t insize, char **outptr) const char *inp, size_t insize, char **outptr)
{ {
unsigned char ibuf[3]; unsigned char ibuf[3];
unsigned char obuf[4]; unsigned char obuf[4];
int i; int i;
int inputparts; int inputparts;
char *output; char *output;
char *base64data; char *base64data;
const char *indata = inp; const char *indata = inp;
*outptr = NULL; /* set to NULL in case of failure before we reach the end */ *outptr = NULL; /* set to NULL in case of failure before we reach the end */
if(0 == insize) if(0 == insize)
insize = strlen(indata); insize = strlen(indata);
base64data = output = LIBSSH2_ALLOC(session, insize*4/3+4); base64data = output = LIBSSH2_ALLOC(session, insize * 4 / 3 + 4);
if(NULL == output) if(NULL == output)
return 0; return 0;
while(insize > 0) { while(insize > 0) {
for (i = inputparts = 0; i < 3; i++) { for(i = inputparts = 0; i < 3; i++) {
if(insize > 0) { if(insize > 0) {
inputparts++; inputparts++;
ibuf[i] = *indata; ibuf[i] = *indata;
indata++; indata++;
insize--; insize--;
} }
else else
ibuf[i] = 0; ibuf[i] = 0;
}
obuf[0] = (unsigned char) ((ibuf[0] & 0xFC) >> 2);
obuf[1] = (unsigned char) (((ibuf[0] & 0x03) << 4) | \
((ibuf[1] & 0xF0) >> 4));
obuf[2] = (unsigned char) (((ibuf[1] & 0x0F) << 2) | \
((ibuf[2] & 0xC0) >> 6));
obuf[3] = (unsigned char) (ibuf[2] & 0x3F);
switch(inputparts) {
case 1: /* only one byte read */
snprintf(output, 5, "%c%c==",
table64[obuf[0]],
table64[obuf[1]]);
break;
case 2: /* two bytes read */
snprintf(output, 5, "%c%c%c=",
table64[obuf[0]],
table64[obuf[1]],
table64[obuf[2]]);
break;
default:
snprintf(output, 5, "%c%c%c%c",
table64[obuf[0]],
table64[obuf[1]],
table64[obuf[2]],
table64[obuf[3]]);
break;
}
output += 4;
} }
*output = 0;
*outptr = base64data; /* make it return the actual data memory */
obuf[0] = (unsigned char) ((ibuf[0] & 0xFC) >> 2); return strlen(base64data); /* return the length of the new data */
obuf[1] = (unsigned char) (((ibuf[0] & 0x03) << 4) | \
((ibuf[1] & 0xF0) >> 4));
obuf[2] = (unsigned char) (((ibuf[1] & 0x0F) << 2) | \
((ibuf[2] & 0xC0) >> 6));
obuf[3] = (unsigned char) (ibuf[2] & 0x3F);
switch(inputparts) {
case 1: /* only one byte read */
snprintf(output, 5, "%c%c==",
table64[obuf[0]],
table64[obuf[1]]);
break;
case 2: /* two bytes read */
snprintf(output, 5, "%c%c%c=",
table64[obuf[0]],
table64[obuf[1]],
table64[obuf[2]]);
break;
default:
snprintf(output, 5, "%c%c%c%c",
table64[obuf[0]],
table64[obuf[1]],
table64[obuf[2]],
table64[obuf[3]] );
break;
}
output += 4;
}
*output=0;
*outptr = base64data; /* make it return the actual data memory */
return strlen(base64data); /* return the length of the new data */
} }
/* ---- End of Base64 Encoding ---- */ /* ---- End of Base64 Encoding ---- */
@@ -404,7 +405,7 @@ libssh2_trace(LIBSSH2_SESSION * session, int bitmask)
} }
LIBSSH2_API int LIBSSH2_API int
libssh2_trace_sethandler(LIBSSH2_SESSION *session, void* handler_context, libssh2_trace_sethandler(LIBSSH2_SESSION *session, void *handler_context,
libssh2_trace_handler_func callback) libssh2_trace_handler_func callback)
{ {
session->tracehandler = callback; session->tracehandler = callback;
@@ -432,18 +433,18 @@ _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
"Publickey", "Publickey",
"Socket", "Socket",
}; };
const char* contexttext = contexts[0]; const char *contexttext = contexts[0];
unsigned int contextindex; unsigned int contextindex;
if (!(session->showmask & context)) { if(!(session->showmask & context)) {
/* no such output asked for */ /* no such output asked for */
return; return;
} }
/* Find the first matching context string for this message */ /* Find the first matching context string for this message */
for (contextindex = 0; contextindex < ARRAY_SIZE(contexts); for(contextindex = 0; contextindex < ARRAY_SIZE(contexts);
contextindex++) { contextindex++) {
if ((context & (1 << contextindex)) != 0) { if((context & (1 << contextindex)) != 0) {
contexttext = contexts[contextindex]; contexttext = contexts[contextindex];
break; break;
} }
@@ -458,7 +459,7 @@ _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
len = snprintf(buffer, buflen, "[libssh2] %d.%06d %s: ", len = snprintf(buffer, buflen, "[libssh2] %d.%06d %s: ",
(int)now.tv_sec, (int)now.tv_usec, contexttext); (int)now.tv_sec, (int)now.tv_usec, contexttext);
if (len >= buflen) if(len >= buflen)
msglen = buflen - 1; msglen = buflen - 1;
else { else {
buflen -= len; buflen -= len;
@@ -469,7 +470,7 @@ _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
msglen += len < buflen ? len : buflen - 1; msglen += len < buflen ? len : buflen - 1;
} }
if (session->tracehandler) if(session->tracehandler)
(session->tracehandler)(session, session->tracehandler_context, buffer, (session->tracehandler)(session, session->tracehandler_context, buffer,
msglen); msglen);
else else
@@ -486,7 +487,7 @@ libssh2_trace(LIBSSH2_SESSION * session, int bitmask)
} }
LIBSSH2_API int LIBSSH2_API int
libssh2_trace_sethandler(LIBSSH2_SESSION *session, void* handler_context, libssh2_trace_sethandler(LIBSSH2_SESSION *session, void *handler_context,
libssh2_trace_handler_func callback) libssh2_trace_handler_func callback)
{ {
(void) session; (void) session;
@@ -616,21 +617,20 @@ void _libssh2_list_insert(struct list_node *after, /* insert before this */
#define _W32_FT_OFFSET (116444736000000000) #define _W32_FT_OFFSET (116444736000000000)
int __cdecl _libssh2_gettimeofday(struct timeval *tp, void *tzp) int __cdecl _libssh2_gettimeofday(struct timeval *tp, void *tzp)
{ {
union { union {
unsigned __int64 ns100; /*time since 1 Jan 1601 in 100ns units */ unsigned __int64 ns100; /*time since 1 Jan 1601 in 100ns units */
FILETIME ft; FILETIME ft;
} _now; } _now;
(void)tzp; (void)tzp;
if(tp) if(tp) {
{ GetSystemTimeAsFileTime(&_now.ft);
GetSystemTimeAsFileTime (&_now.ft); tp->tv_usec = (long)((_now.ns100 / 10) % 1000000);
tp->tv_usec=(long)((_now.ns100 / 10) % 1000000 ); tp->tv_sec = (long)((_now.ns100 - _W32_FT_OFFSET) / 10000000);
tp->tv_sec= (long)((_now.ns100 - _W32_FT_OFFSET) / 10000000);
} }
/* Always return 0 as per Open Group Base Specifications Issue 6. /* Always return 0 as per Open Group Base Specifications Issue 6.
Do not set errno on error. */ Do not set errno on error. */
return 0; return 0;
} }
@@ -654,7 +654,7 @@ void _libssh2_xor_data(unsigned char *output,
{ {
size_t i; size_t i;
for (i = 0; i < length; i++) for(i = 0; i < length; i++)
*output++ = *input1++ ^ *input2++; *output++ = *input1++ ^ *input2++;
} }
@@ -665,12 +665,11 @@ void _libssh2_aes_ctr_increment(unsigned char *ctr,
{ {
unsigned char *pc; unsigned char *pc;
unsigned int val, carry; unsigned int val, carry;
pc = ctr + length - 1; pc = ctr + length - 1;
carry = 1; carry = 1;
while(pc >= ctr) while(pc >= ctr) {
{
val = (unsigned int)*pc + carry; val = (unsigned int)*pc + carry;
*pc-- = val & 0xFF; *pc-- = val & 0xFF;
carry = val >> 8; carry = val >> 8;

4
src/misc.h
View File

@@ -49,8 +49,8 @@ struct list_node {
struct list_head *head; struct list_head *head;
}; };
int _libssh2_error_flags(LIBSSH2_SESSION* session, int errcode, const char* errmsg, int errflags); int _libssh2_error_flags(LIBSSH2_SESSION* session, int errcode, const char *errmsg, int errflags);
int _libssh2_error(LIBSSH2_SESSION* session, int errcode, const char* errmsg); int _libssh2_error(LIBSSH2_SESSION* session, int errcode, const char *errmsg);
void _libssh2_list_init(struct list_head *head); void _libssh2_list_init(struct list_head *head);

286
src/openssl.c
View File

@@ -59,7 +59,7 @@ write_bn(unsigned char *buf, const BIGNUM *bn, int bn_bytes)
*p = 0; *p = 0;
BN_bn2bin(bn, p + 1); BN_bn2bin(bn, p + 1);
if (!(*(p + 1) & 0x80)) { if(!(*(p + 1) & 0x80)) {
memmove(p, p + 1, --bn_bytes); memmove(p, p + 1, --bn_bytes);
} }
_libssh2_htonu32(p - 4, bn_bytes); /* Post write bn size. */ _libssh2_htonu32(p - 4, bn_bytes); /* Post write bn size. */
@@ -100,7 +100,7 @@ _libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
n = BN_new(); n = BN_new();
BN_bin2bn(ndata, nlen, n); BN_bin2bn(ndata, nlen, n);
if (ddata) { if(ddata) {
d = BN_new(); d = BN_new();
BN_bin2bn(ddata, dlen, d); BN_bin2bn(ddata, dlen, d);
@@ -154,7 +154,7 @@ _libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsactx,
unsigned char hash[SHA_DIGEST_LENGTH]; unsigned char hash[SHA_DIGEST_LENGTH];
int ret; int ret;
if (_libssh2_sha1(m, m_len, hash)) if(_libssh2_sha1(m, m_len, hash))
return -1; /* failure */ return -1; /* failure */
ret = RSA_verify(NID_sha1, hash, SHA_DIGEST_LENGTH, ret = RSA_verify(NID_sha1, hash, SHA_DIGEST_LENGTH,
(unsigned char *) sig, sig_len, rsactx); (unsigned char *) sig, sig_len, rsactx);
@@ -192,7 +192,7 @@ _libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
pub_key = BN_new(); pub_key = BN_new();
BN_bin2bn(y, y_len, pub_key); BN_bin2bn(y, y_len, pub_key);
if (x_len) { if(x_len) {
priv_key = BN_new(); priv_key = BN_new();
BN_bin2bn(x, x_len, priv_key); BN_bin2bn(x, x_len, priv_key);
} }
@@ -239,7 +239,7 @@ _libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
dsasig->r = r; dsasig->r = r;
dsasig->s = s; dsasig->s = s;
#endif #endif
if (!_libssh2_sha1(m, m_len, hash)) if(!_libssh2_sha1(m, m_len, hash))
/* _libssh2_sha1() succeeded */ /* _libssh2_sha1() succeeded */
ret = DSA_do_verify(hash, SHA_DIGEST_LENGTH, dsasig, dsactx); ret = DSA_do_verify(hash, SHA_DIGEST_LENGTH, dsasig, dsactx);
@@ -276,20 +276,20 @@ _libssh2_ecdsa_curve_type_from_name(const char *name, libssh2_curve_type *out_ty
int ret = 0; int ret = 0;
libssh2_curve_type type; libssh2_curve_type type;
if ( name == NULL || strlen(name) != 19 ) if(name == NULL || strlen(name) != 19)
return -1; return -1;
if ( strcmp(name, "ecdsa-sha2-nistp256") == 0) if(strcmp(name, "ecdsa-sha2-nistp256") == 0)
type = LIBSSH2_EC_CURVE_NISTP256; type = LIBSSH2_EC_CURVE_NISTP256;
else if ( strcmp(name, "ecdsa-sha2-nistp384") == 0) else if(strcmp(name, "ecdsa-sha2-nistp384") == 0)
type = LIBSSH2_EC_CURVE_NISTP384; type = LIBSSH2_EC_CURVE_NISTP384;
else if ( strcmp(name, "ecdsa-sha2-nistp521") == 0) else if(strcmp(name, "ecdsa-sha2-nistp521") == 0)
type = LIBSSH2_EC_CURVE_NISTP521; type = LIBSSH2_EC_CURVE_NISTP521;
else { else {
ret = -1; ret = -1;
} }
if (ret == 0 && out_type) { if(ret == 0 && out_type) {
*out_type = type; *out_type = type;
} }
@@ -313,16 +313,16 @@ _libssh2_ecdsa_curve_name_with_octal_new(libssh2_ecdsa_ctx ** ec_ctx,
EC_KEY *ec_key = EC_KEY_new_by_curve_name(curve); EC_KEY *ec_key = EC_KEY_new_by_curve_name(curve);
EC_POINT *point = NULL; EC_POINT *point = NULL;
if ( ec_key ) { if(ec_key) {
ec_group = EC_KEY_get0_group(ec_key); ec_group = EC_KEY_get0_group(ec_key);
point = EC_POINT_new(ec_group); point = EC_POINT_new(ec_group);
ret = EC_POINT_oct2point(ec_group, point, k, k_len, NULL); ret = EC_POINT_oct2point(ec_group, point, k, k_len, NULL);
ret = EC_KEY_set_public_key(ec_key, point); ret = EC_KEY_set_public_key(ec_key, point);
if (point != NULL) if(point != NULL)
EC_POINT_free(point); EC_POINT_free(point);
if ( ec_ctx != NULL ) if(ec_ctx != NULL)
*ec_ctx = ec_key; *ec_ctx = ec_key;
} }
@@ -366,16 +366,18 @@ _libssh2_ecdsa_verify(libssh2_ecdsa_ctx * ctx,
BN_bin2bn(s, s_len, ecdsa_sig_.s); BN_bin2bn(s, s_len, ecdsa_sig_.s);
#endif #endif
if ( type == LIBSSH2_EC_CURVE_NISTP256 ) { if(type == LIBSSH2_EC_CURVE_NISTP256) {
LIBSSH2_ECDSA_VERIFY(256); LIBSSH2_ECDSA_VERIFY(256);
}else if ( type == LIBSSH2_EC_CURVE_NISTP384 ) { }
else if(type == LIBSSH2_EC_CURVE_NISTP384) {
LIBSSH2_ECDSA_VERIFY(384); LIBSSH2_ECDSA_VERIFY(384);
}else if ( type == LIBSSH2_EC_CURVE_NISTP521 ) { }
else if(type == LIBSSH2_EC_CURVE_NISTP521) {
LIBSSH2_ECDSA_VERIFY(512); LIBSSH2_ECDSA_VERIFY(512);
} }
#if HAVE_OPAQUE_STRUCTS #if HAVE_OPAQUE_STRUCTS
if ( ecdsa_sig ) if(ecdsa_sig)
ECDSA_SIG_free(ecdsa_sig); ECDSA_SIG_free(ecdsa_sig);
#else #else
BN_clear_free(ecdsa_sig_.s); BN_clear_free(ecdsa_sig_.s);
@@ -416,7 +418,7 @@ _libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,
#else #else
ret = EVP_Cipher(ctx, buf, block, blocksize); ret = EVP_Cipher(ctx, buf, block, blocksize);
#endif #endif
if (ret == 1) { if(ret == 1) {
memcpy(block, buf, blocksize); memcpy(block, buf, blocksize);
} }
return ret == 1 ? 0 : 1; return ret == 1 ? 0 : 1;
@@ -446,7 +448,7 @@ aes_ctr_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
const EVP_CIPHER *aes_cipher; const EVP_CIPHER *aes_cipher;
(void) enc; (void) enc;
switch (EVP_CIPHER_CTX_key_length(ctx)) { switch(EVP_CIPHER_CTX_key_length(ctx)) {
case 16: case 16:
aes_cipher = EVP_aes_128_ecb(); aes_cipher = EVP_aes_128_ecb();
break; break;
@@ -461,7 +463,7 @@ aes_ctr_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
} }
c = malloc(sizeof(*c)); c = malloc(sizeof(*c));
if (c == NULL) if(c == NULL)
return 0; return 0;
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
@@ -469,12 +471,12 @@ aes_ctr_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
#else #else
c->aes_ctx = malloc(sizeof(EVP_CIPHER_CTX)); c->aes_ctx = malloc(sizeof(EVP_CIPHER_CTX));
#endif #endif
if (c->aes_ctx == NULL) { if(c->aes_ctx == NULL) {
free(c); free(c);
return 0; return 0;
} }
if (EVP_EncryptInit(c->aes_ctx, aes_cipher, key, NULL) != 1) { if(EVP_EncryptInit(c->aes_ctx, aes_cipher, key, NULL) != 1) {
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
EVP_CIPHER_CTX_free(c->aes_ctx); EVP_CIPHER_CTX_free(c->aes_ctx);
#else #else
@@ -502,10 +504,10 @@ aes_ctr_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
unsigned char b1[AES_BLOCK_SIZE]; unsigned char b1[AES_BLOCK_SIZE];
int outlen = 0; int outlen = 0;
if (inl != 16) /* libssh2 only ever encrypt one block */ if(inl != 16) /* libssh2 only ever encrypt one block */
return 0; return 0;
if (c == NULL) { if(c == NULL) {
return 0; return 0;
} }
@@ -516,7 +518,7 @@ aes_ctr_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
the ciphertext block C1. The counter X is then incremented the ciphertext block C1. The counter X is then incremented
*/ */
if (EVP_EncryptUpdate(c->aes_ctx, b1, &outlen, c->ctr, AES_BLOCK_SIZE) != 1) { if(EVP_EncryptUpdate(c->aes_ctx, b1, &outlen, c->ctr, AES_BLOCK_SIZE) != 1) {
return 0; return 0;
} }
@@ -531,11 +533,11 @@ aes_ctr_cleanup(EVP_CIPHER_CTX *ctx) /* cleanup ctx */
{ {
aes_ctr_ctx *c = EVP_CIPHER_CTX_get_app_data(ctx); aes_ctr_ctx *c = EVP_CIPHER_CTX_get_app_data(ctx);
if (c == NULL) { if(c == NULL) {
return 1; return 1;
} }
if (c->aes_ctx != NULL) { if(c->aes_ctx != NULL) {
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
EVP_CIPHER_CTX_free(c->aes_ctx); EVP_CIPHER_CTX_free(c->aes_ctx);
#else #else
@@ -554,7 +556,7 @@ make_ctr_evp (size_t keylen, EVP_CIPHER *aes_ctr_cipher, int type)
{ {
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
aes_ctr_cipher = EVP_CIPHER_meth_new(type, 16, keylen); aes_ctr_cipher = EVP_CIPHER_meth_new(type, 16, keylen);
if (aes_ctr_cipher) { if(aes_ctr_cipher) {
EVP_CIPHER_meth_set_iv_length(aes_ctr_cipher, 16); EVP_CIPHER_meth_set_iv_length(aes_ctr_cipher, 16);
EVP_CIPHER_meth_set_init(aes_ctr_cipher, aes_ctr_init); EVP_CIPHER_meth_set_init(aes_ctr_cipher, aes_ctr_init);
EVP_CIPHER_meth_set_do_cipher(aes_ctr_cipher, aes_ctr_do_cipher); EVP_CIPHER_meth_set_do_cipher(aes_ctr_cipher, aes_ctr_do_cipher);
@@ -578,12 +580,12 @@ _libssh2_EVP_aes_128_ctr(void)
{ {
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
static EVP_CIPHER * aes_ctr_cipher; static EVP_CIPHER * aes_ctr_cipher;
return !aes_ctr_cipher? return !aes_ctr_cipher ?
make_ctr_evp (16, aes_ctr_cipher, NID_aes_128_ctr) : aes_ctr_cipher; make_ctr_evp(16, aes_ctr_cipher, NID_aes_128_ctr) : aes_ctr_cipher;
#else #else
static EVP_CIPHER aes_ctr_cipher; static EVP_CIPHER aes_ctr_cipher;
return !aes_ctr_cipher.key_len? return !aes_ctr_cipher.key_len ?
make_ctr_evp (16, &aes_ctr_cipher, 0) : &aes_ctr_cipher; make_ctr_evp(16, &aes_ctr_cipher, 0) : &aes_ctr_cipher;
#endif #endif
} }
@@ -592,12 +594,12 @@ _libssh2_EVP_aes_192_ctr(void)
{ {
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
static EVP_CIPHER * aes_ctr_cipher; static EVP_CIPHER * aes_ctr_cipher;
return !aes_ctr_cipher? return !aes_ctr_cipher ?
make_ctr_evp (24, aes_ctr_cipher, NID_aes_192_ctr) : aes_ctr_cipher; make_ctr_evp(24, aes_ctr_cipher, NID_aes_192_ctr) : aes_ctr_cipher;
#else #else
static EVP_CIPHER aes_ctr_cipher; static EVP_CIPHER aes_ctr_cipher;
return !aes_ctr_cipher.key_len? return !aes_ctr_cipher.key_len ?
make_ctr_evp (24, &aes_ctr_cipher, 0) : &aes_ctr_cipher; make_ctr_evp(24, &aes_ctr_cipher, 0) : &aes_ctr_cipher;
#endif #endif
} }
@@ -606,12 +608,12 @@ _libssh2_EVP_aes_256_ctr(void)
{ {
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
static EVP_CIPHER * aes_ctr_cipher; static EVP_CIPHER * aes_ctr_cipher;
return !aes_ctr_cipher? return !aes_ctr_cipher ?
make_ctr_evp (32, aes_ctr_cipher, NID_aes_256_ctr) : aes_ctr_cipher; make_ctr_evp(32, aes_ctr_cipher, NID_aes_256_ctr) : aes_ctr_cipher;
#else #else
static EVP_CIPHER aes_ctr_cipher; static EVP_CIPHER aes_ctr_cipher;
return !aes_ctr_cipher.key_len? return !aes_ctr_cipher.key_len ?
make_ctr_evp (32, &aes_ctr_cipher, 0) : &aes_ctr_cipher; make_ctr_evp(32, &aes_ctr_cipher, 0) : &aes_ctr_cipher;
#endif #endif
} }
@@ -635,7 +637,7 @@ passphrase_cb(char *buf, int size, int rwflag, char *passphrase)
int passphrase_len = strlen(passphrase); int passphrase_len = strlen(passphrase);
(void) rwflag; (void) rwflag;
if (passphrase_len > (size - 1)) { if(passphrase_len > (size - 1)) {
passphrase_len = size - 1; passphrase_len = size - 1;
} }
memcpy(buf, passphrase, passphrase_len); memcpy(buf, passphrase, passphrase_len);
@@ -645,12 +647,12 @@ passphrase_cb(char *buf, int size, int rwflag, char *passphrase)
} }
typedef void * (*pem_read_bio_func)(BIO *, void **, pem_password_cb *, typedef void * (*pem_read_bio_func)(BIO *, void **, pem_password_cb *,
void * u); void *u);
static int static int
read_private_key_from_memory(void ** key_ctx, read_private_key_from_memory(void **key_ctx,
pem_read_bio_func read_private_key, pem_read_bio_func read_private_key,
const char * filedata, const char *filedata,
size_t filedata_len, size_t filedata_len,
unsigned const char *passphrase) unsigned const char *passphrase)
{ {
@@ -659,7 +661,7 @@ read_private_key_from_memory(void ** key_ctx,
*key_ctx = NULL; *key_ctx = NULL;
bp = BIO_new_mem_buf((char *)filedata, filedata_len); bp = BIO_new_mem_buf((char *)filedata, filedata_len);
if (!bp) { if(!bp) {
return -1; return -1;
} }
*key_ctx = read_private_key(bp, NULL, (pem_password_cb *) passphrase_cb, *key_ctx = read_private_key(bp, NULL, (pem_password_cb *) passphrase_cb,
@@ -670,9 +672,9 @@ read_private_key_from_memory(void ** key_ctx,
} }
static int static int
read_private_key_from_file(void ** key_ctx, read_private_key_from_file(void **key_ctx,
pem_read_bio_func read_private_key, pem_read_bio_func read_private_key,
const char * filename, const char *filename,
unsigned const char *passphrase) unsigned const char *passphrase)
{ {
BIO * bp; BIO * bp;
@@ -680,7 +682,7 @@ read_private_key_from_file(void ** key_ctx,
*key_ctx = NULL; *key_ctx = NULL;
bp = BIO_new_file(filename, "r"); bp = BIO_new_file(filename, "r");
if (!bp) { if(!bp) {
return -1; return -1;
} }
@@ -716,7 +718,7 @@ _libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
(pem_read_bio_func) &PEM_read_bio_RSAPrivateKey; (pem_read_bio_func) &PEM_read_bio_RSAPrivateKey;
(void) session; (void) session;
_libssh2_init_if_needed (); _libssh2_init_if_needed();
return read_private_key_from_file((void **) rsa, read_rsa, return read_private_key_from_file((void **) rsa, read_rsa,
filename, passphrase); filename, passphrase);
@@ -748,7 +750,7 @@ _libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
(pem_read_bio_func) &PEM_read_bio_DSAPrivateKey; (pem_read_bio_func) &PEM_read_bio_DSAPrivateKey;
(void) session; (void) session;
_libssh2_init_if_needed (); _libssh2_init_if_needed();
return read_private_key_from_file((void **) dsa, read_dsa, return read_private_key_from_file((void **) dsa, read_dsa,
filename, passphrase); filename, passphrase);
@@ -781,7 +783,7 @@ _libssh2_ecdsa_new_private(libssh2_ecdsa_ctx ** ec_ctx,
pem_read_bio_func read_ec = (pem_read_bio_func) &PEM_read_bio_ECPrivateKey; pem_read_bio_func read_ec = (pem_read_bio_func) &PEM_read_bio_ECPrivateKey;
(void) session; (void) session;
_libssh2_init_if_needed (); _libssh2_init_if_needed();
return read_private_key_from_file((void **) ec_ctx, read_ec, return read_private_key_from_file((void **) ec_ctx, read_ec,
filename, passphrase); filename, passphrase);
@@ -804,13 +806,13 @@ _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
sig_len = RSA_size(rsactx); sig_len = RSA_size(rsactx);
sig = LIBSSH2_ALLOC(session, sig_len); sig = LIBSSH2_ALLOC(session, sig_len);
if (!sig) { if(!sig) {
return -1; return -1;
} }
ret = RSA_sign(NID_sha1, hash, hash_len, sig, &sig_len, rsactx); ret = RSA_sign(NID_sha1, hash, hash_len, sig, &sig_len, rsactx);
if (!ret) { if(!ret) {
LIBSSH2_FREE(session, sig); LIBSSH2_FREE(session, sig);
return -1; return -1;
} }
@@ -834,7 +836,7 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
(void) hash_len; (void) hash_len;
sig = DSA_do_sign(hash, SHA_DIGEST_LENGTH, dsactx); sig = DSA_do_sign(hash, SHA_DIGEST_LENGTH, dsactx);
if (!sig) { if(!sig) {
return -1; return -1;
} }
@@ -845,12 +847,12 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
s = sig->s; s = sig->s;
#endif #endif
r_len = BN_num_bytes(r); r_len = BN_num_bytes(r);
if (r_len < 1 || r_len > 20) { if(r_len < 1 || r_len > 20) {
DSA_SIG_free(sig); DSA_SIG_free(sig);
return -1; return -1;
} }
s_len = BN_num_bytes(s); s_len = BN_num_bytes(s);
if (s_len < 1 || s_len > 20) { if(s_len < 1 || s_len > 20) {
DSA_SIG_free(sig); DSA_SIG_free(sig);
return -1; return -1;
} }
@@ -882,7 +884,7 @@ _libssh2_ecdsa_sign(LIBSSH2_SESSION * session, libssh2_ecdsa_ctx * ec_ctx,
unsigned char *out_buffer = NULL; unsigned char *out_buffer = NULL;
ECDSA_SIG *sig = ECDSA_do_sign(hash, hash_len, ec_ctx); ECDSA_SIG *sig = ECDSA_do_sign(hash, hash_len, ec_ctx);
if ( sig == NULL ) if(sig == NULL)
return -1; return -1;
#if HAVE_OPAQUE_STRUCTS #if HAVE_OPAQUE_STRUCTS
ECDSA_SIG_get0(sig, &pr, &ps); ECDSA_SIG_get0(sig, &pr, &ps);
@@ -895,7 +897,7 @@ _libssh2_ecdsa_sign(LIBSSH2_SESSION * session, libssh2_ecdsa_ctx * ec_ctx,
s_len = BN_num_bytes(ps) + 1; s_len = BN_num_bytes(ps) + 1;
temp_buffer = malloc(r_len + s_len + 8); temp_buffer = malloc(r_len + s_len + 8);
if ( temp_buffer == NULL ) { if(temp_buffer == NULL) {
rc = -1; rc = -1;
goto clean_exit; goto clean_exit;
} }
@@ -907,7 +909,7 @@ _libssh2_ecdsa_sign(LIBSSH2_SESSION * session, libssh2_ecdsa_ctx * ec_ctx,
out_buffer_len = (size_t)(sp - temp_buffer); out_buffer_len = (size_t)(sp - temp_buffer);
out_buffer = LIBSSH2_CALLOC(session, out_buffer_len); out_buffer = LIBSSH2_CALLOC(session, out_buffer_len);
if ( out_buffer == NULL ) { if(out_buffer == NULL) {
rc = -1; rc = -1;
goto clean_exit; goto clean_exit;
} }
@@ -919,10 +921,10 @@ _libssh2_ecdsa_sign(LIBSSH2_SESSION * session, libssh2_ecdsa_ctx * ec_ctx,
clean_exit: clean_exit:
if ( temp_buffer != NULL ) if(temp_buffer != NULL)
free(temp_buffer); free(temp_buffer);
if ( sig ) if(sig)
ECDSA_SIG_free(sig); ECDSA_SIG_free(sig);
return rc; return rc;
@@ -935,10 +937,10 @@ _libssh2_sha1_init(libssh2_sha1_ctx *ctx)
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
*ctx = EVP_MD_CTX_new(); *ctx = EVP_MD_CTX_new();
if (*ctx == NULL) if(*ctx == NULL)
return 0; return 0;
if (EVP_DigestInit(*ctx, EVP_get_digestbyname("sha1"))) if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha1")))
return 1; return 1;
EVP_MD_CTX_free(*ctx); EVP_MD_CTX_free(*ctx);
@@ -958,10 +960,10 @@ _libssh2_sha1(const unsigned char *message, unsigned long len,
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
EVP_MD_CTX * ctx = EVP_MD_CTX_new(); EVP_MD_CTX * ctx = EVP_MD_CTX_new();
if (ctx == NULL) if(ctx == NULL)
return 1; /* error */ return 1; /* error */
if (EVP_DigestInit(ctx, EVP_get_digestbyname("sha1"))) { if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha1"))) {
EVP_DigestUpdate(ctx, message, len); EVP_DigestUpdate(ctx, message, len);
EVP_DigestFinal(ctx, out, NULL); EVP_DigestFinal(ctx, out, NULL);
EVP_MD_CTX_free(ctx); EVP_MD_CTX_free(ctx);
@@ -972,7 +974,7 @@ _libssh2_sha1(const unsigned char *message, unsigned long len,
EVP_MD_CTX ctx; EVP_MD_CTX ctx;
EVP_MD_CTX_init(&ctx); EVP_MD_CTX_init(&ctx);
if (EVP_DigestInit(&ctx, EVP_get_digestbyname("sha1"))) { if(EVP_DigestInit(&ctx, EVP_get_digestbyname("sha1"))) {
EVP_DigestUpdate(&ctx, message, len); EVP_DigestUpdate(&ctx, message, len);
EVP_DigestFinal(&ctx, out, NULL); EVP_DigestFinal(&ctx, out, NULL);
return 0; /* success */ return 0; /* success */
@@ -987,10 +989,10 @@ _libssh2_sha256_init(libssh2_sha256_ctx *ctx)
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
*ctx = EVP_MD_CTX_new(); *ctx = EVP_MD_CTX_new();
if (*ctx == NULL) if(*ctx == NULL)
return 0; return 0;
if (EVP_DigestInit(*ctx, EVP_get_digestbyname("sha256"))) if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha256")))
return 1; return 1;
EVP_MD_CTX_free(*ctx); EVP_MD_CTX_free(*ctx);
@@ -1010,7 +1012,7 @@ _libssh2_sha256(const unsigned char *message, unsigned long len,
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
EVP_MD_CTX * ctx = EVP_MD_CTX_new(); EVP_MD_CTX * ctx = EVP_MD_CTX_new();
if (ctx == NULL) if(ctx == NULL)
return 1; /* error */ return 1; /* error */
if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha256"))) { if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha256"))) {
@@ -1039,10 +1041,10 @@ _libssh2_sha384_init(libssh2_sha384_ctx *ctx)
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
*ctx = EVP_MD_CTX_new(); *ctx = EVP_MD_CTX_new();
if (*ctx == NULL) if(*ctx == NULL)
return 0; return 0;
if (EVP_DigestInit(*ctx, EVP_get_digestbyname("sha384"))) if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha384")))
return 1; return 1;
EVP_MD_CTX_free(*ctx); EVP_MD_CTX_free(*ctx);
@@ -1062,7 +1064,7 @@ _libssh2_sha384(const unsigned char *message, unsigned long len,
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
EVP_MD_CTX * ctx = EVP_MD_CTX_new(); EVP_MD_CTX * ctx = EVP_MD_CTX_new();
if (ctx == NULL) if(ctx == NULL)
return 1; /* error */ return 1; /* error */
if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha384"))) { if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha384"))) {
@@ -1091,10 +1093,10 @@ _libssh2_sha512_init(libssh2_sha512_ctx *ctx)
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
*ctx = EVP_MD_CTX_new(); *ctx = EVP_MD_CTX_new();
if (*ctx == NULL) if(*ctx == NULL)
return 0; return 0;
if (EVP_DigestInit(*ctx, EVP_get_digestbyname("sha512"))) if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha512")))
return 1; return 1;
EVP_MD_CTX_free(*ctx); EVP_MD_CTX_free(*ctx);
@@ -1114,7 +1116,7 @@ _libssh2_sha512(const unsigned char *message, unsigned long len,
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
EVP_MD_CTX * ctx = EVP_MD_CTX_new(); EVP_MD_CTX * ctx = EVP_MD_CTX_new();
if (ctx == NULL) if(ctx == NULL)
return 1; /* error */ return 1; /* error */
if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha512"))) { if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha512"))) {
@@ -1143,10 +1145,10 @@ _libssh2_md5_init(libssh2_md5_ctx *ctx)
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
*ctx = EVP_MD_CTX_new(); *ctx = EVP_MD_CTX_new();
if (*ctx == NULL) if(*ctx == NULL)
return 0; return 0;
if (EVP_DigestInit(*ctx, EVP_get_digestbyname("md5"))) if(EVP_DigestInit(*ctx, EVP_get_digestbyname("md5")))
return 1; return 1;
EVP_MD_CTX_free(*ctx); EVP_MD_CTX_free(*ctx);
@@ -1165,8 +1167,8 @@ gen_publickey_from_rsa(LIBSSH2_SESSION *session, RSA *rsa,
{ {
int e_bytes, n_bytes; int e_bytes, n_bytes;
unsigned long len; unsigned long len;
unsigned char* key; unsigned char *key;
unsigned char* p; unsigned char *p;
const BIGNUM * e; const BIGNUM * e;
const BIGNUM * n; const BIGNUM * n;
#ifdef HAVE_OPAQUE_STRUCTS #ifdef HAVE_OPAQUE_STRUCTS
@@ -1182,7 +1184,7 @@ gen_publickey_from_rsa(LIBSSH2_SESSION *session, RSA *rsa,
len = 4 + 7 + 4 + e_bytes + 4 + n_bytes; len = 4 + 7 + 4 + e_bytes + 4 + n_bytes;
key = LIBSSH2_ALLOC(session, len); key = LIBSSH2_ALLOC(session, len);
if (key == NULL) { if(key == NULL) {
return NULL; return NULL;
} }
@@ -1208,8 +1210,8 @@ gen_publickey_from_dsa(LIBSSH2_SESSION* session, DSA *dsa,
{ {
int p_bytes, q_bytes, g_bytes, k_bytes; int p_bytes, q_bytes, g_bytes, k_bytes;
unsigned long len; unsigned long len;
unsigned char* key; unsigned char *key;
unsigned char* p; unsigned char *p;
const BIGNUM * p_bn; const BIGNUM * p_bn;
const BIGNUM * q; const BIGNUM * q;
@@ -1237,7 +1239,7 @@ gen_publickey_from_dsa(LIBSSH2_SESSION* session, DSA *dsa,
len = 4 + 7 + 4 + p_bytes + 4 + q_bytes + 4 + g_bytes + 4 + k_bytes; len = 4 + 7 + 4 + p_bytes + 4 + q_bytes + 4 + g_bytes + 4 + k_bytes;
key = LIBSSH2_ALLOC(session, len); key = LIBSSH2_ALLOC(session, len);
if (key == NULL) { if(key == NULL) {
return NULL; return NULL;
} }
@@ -1268,8 +1270,8 @@ gen_publickey_from_rsa_evp(LIBSSH2_SESSION *session,
EVP_PKEY *pk) EVP_PKEY *pk)
{ {
RSA* rsa = NULL; RSA* rsa = NULL;
unsigned char* key; unsigned char *key;
unsigned char* method_buf = NULL; unsigned char *method_buf = NULL;
size_t key_len; size_t key_len;
_libssh2_debug(session, _libssh2_debug(session,
@@ -1277,18 +1279,18 @@ gen_publickey_from_rsa_evp(LIBSSH2_SESSION *session,
"Computing public key from RSA private key envelop"); "Computing public key from RSA private key envelop");
rsa = EVP_PKEY_get1_RSA(pk); rsa = EVP_PKEY_get1_RSA(pk);
if (rsa == NULL) { if(rsa == NULL) {
/* Assume memory allocation error... what else could it be ? */ /* Assume memory allocation error... what else could it be ? */
goto __alloc_error; goto __alloc_error;
} }
method_buf = LIBSSH2_ALLOC(session, 7); /* ssh-rsa. */ method_buf = LIBSSH2_ALLOC(session, 7); /* ssh-rsa. */
if (method_buf == NULL) { if(method_buf == NULL) {
goto __alloc_error; goto __alloc_error;
} }
key = gen_publickey_from_rsa(session, rsa, &key_len); key = gen_publickey_from_rsa(session, rsa, &key_len);
if (key == NULL) { if(key == NULL) {
goto __alloc_error; goto __alloc_error;
} }
RSA_free(rsa); RSA_free(rsa);
@@ -1301,10 +1303,10 @@ gen_publickey_from_rsa_evp(LIBSSH2_SESSION *session,
return 0; return 0;
__alloc_error: __alloc_error:
if (rsa != NULL) { if(rsa != NULL) {
RSA_free(rsa); RSA_free(rsa);
} }
if (method_buf != NULL) { if(method_buf != NULL) {
LIBSSH2_FREE(session, method_buf); LIBSSH2_FREE(session, method_buf);
} }
@@ -1323,8 +1325,8 @@ gen_publickey_from_dsa_evp(LIBSSH2_SESSION *session,
EVP_PKEY *pk) EVP_PKEY *pk)
{ {
DSA* dsa = NULL; DSA* dsa = NULL;
unsigned char* key; unsigned char *key;
unsigned char* method_buf = NULL; unsigned char *method_buf = NULL;
size_t key_len; size_t key_len;
_libssh2_debug(session, _libssh2_debug(session,
@@ -1332,18 +1334,18 @@ gen_publickey_from_dsa_evp(LIBSSH2_SESSION *session,
"Computing public key from DSA private key envelop"); "Computing public key from DSA private key envelop");
dsa = EVP_PKEY_get1_DSA(pk); dsa = EVP_PKEY_get1_DSA(pk);
if (dsa == NULL) { if(dsa == NULL) {
/* Assume memory allocation error... what else could it be ? */ /* Assume memory allocation error... what else could it be ? */
goto __alloc_error; goto __alloc_error;
} }
method_buf = LIBSSH2_ALLOC(session, 7); /* ssh-dss. */ method_buf = LIBSSH2_ALLOC(session, 7); /* ssh-dss. */
if (method_buf == NULL) { if(method_buf == NULL) {
goto __alloc_error; goto __alloc_error;
} }
key = gen_publickey_from_dsa(session, dsa, &key_len); key = gen_publickey_from_dsa(session, dsa, &key_len);
if (key == NULL) { if(key == NULL) {
goto __alloc_error; goto __alloc_error;
} }
DSA_free(dsa); DSA_free(dsa);
@@ -1356,10 +1358,10 @@ gen_publickey_from_dsa_evp(LIBSSH2_SESSION *session,
return 0; return 0;
__alloc_error: __alloc_error:
if (dsa != NULL) { if(dsa != NULL) {
DSA_free(dsa); DSA_free(dsa);
} }
if (method_buf != NULL) { if(method_buf != NULL) {
LIBSSH2_FREE(session, method_buf); LIBSSH2_FREE(session, method_buf);
} }
@@ -1382,7 +1384,7 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
int rc = 0; int rc = 0;
EC_KEY *ec = NULL; EC_KEY *ec = NULL;
unsigned char *p; unsigned char *p;
unsigned char* method_buf = NULL; unsigned char *method_buf = NULL;
unsigned char *key; unsigned char *key;
size_t key_len = 0; size_t key_len = 0;
unsigned char *octal_value = NULL; unsigned char *octal_value = NULL;
@@ -1397,11 +1399,11 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
"Computing public key from EC private key envelop"); "Computing public key from EC private key envelop");
bn_ctx = BN_CTX_new(); bn_ctx = BN_CTX_new();
if ( bn_ctx == NULL ) if(bn_ctx == NULL)
return -1; return -1;
ec = EVP_PKEY_get1_EC_KEY(pk); ec = EVP_PKEY_get1_EC_KEY(pk);
if ( ec == NULL ) { if(ec == NULL) {
rc = -1; rc = -1;
goto clean_exit; goto clean_exit;
} }
@@ -1411,16 +1413,16 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
type = _libssh2_ecdsa_key_get_curve_type(ec); type = _libssh2_ecdsa_key_get_curve_type(ec);
method_buf = LIBSSH2_ALLOC(session, 19); method_buf = LIBSSH2_ALLOC(session, 19);
if (method_buf == NULL) { if(method_buf == NULL) {
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"out of memory"); "out of memory");
} }
if ( type == LIBSSH2_EC_CURVE_NISTP256 ) if(type == LIBSSH2_EC_CURVE_NISTP256)
memcpy(method_buf, "ecdsa-sha2-nistp256", 19); memcpy(method_buf, "ecdsa-sha2-nistp256", 19);
else if ( type == LIBSSH2_EC_CURVE_NISTP384 ) else if(type == LIBSSH2_EC_CURVE_NISTP384)
memcpy(method_buf, "ecdsa-sha2-nistp384", 19); memcpy(method_buf, "ecdsa-sha2-nistp384", 19);
else if ( type == LIBSSH2_EC_CURVE_NISTP521 ) else if(type == LIBSSH2_EC_CURVE_NISTP521)
memcpy(method_buf, "ecdsa-sha2-nistp521", 19); memcpy(method_buf, "ecdsa-sha2-nistp521", 19);
else { else {
_libssh2_debug(session, _libssh2_debug(session,
@@ -1432,19 +1434,19 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
/* get length */ /* get length */
octal_len = EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED, NULL, 0, bn_ctx); octal_len = EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED, NULL, 0, bn_ctx);
if (octal_len > EC_MAX_POINT_LEN) { if(octal_len > EC_MAX_POINT_LEN) {
rc = -1; rc = -1;
goto clean_exit; goto clean_exit;
} }
octal_value = malloc(octal_len); octal_value = malloc(octal_len);
if ( octal_value == NULL ) { if(octal_value == NULL) {
rc = -1; rc = -1;
goto clean_exit; goto clean_exit;
} }
/* convert to octal */ /* convert to octal */
if (EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED, if(EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED,
octal_value, octal_len, bn_ctx) != octal_len) { octal_value, octal_len, bn_ctx) != octal_len) {
rc = -1; rc = -1;
goto clean_exit; goto clean_exit;
@@ -1453,7 +1455,7 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
/* Key form is: type_len(4) + type(19) + domain_len(4) + domain(8) + pub_key_len(4) + pub_key(~65). */ /* Key form is: type_len(4) + type(19) + domain_len(4) + domain(8) + pub_key_len(4) + pub_key(~65). */
key_len = 4 + 19 + 4 + 8 + 4 + octal_len; key_len = 4 + 19 + 4 + 8 + 4 + octal_len;
key = LIBSSH2_ALLOC(session, key_len); key = LIBSSH2_ALLOC(session, key_len);
if (key == NULL) { if(key == NULL) {
rc = -1; rc = -1;
goto clean_exit; goto clean_exit;
} }
@@ -1462,13 +1464,13 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
p = key; p = key;
/* Key type */ /* Key type */
_libssh2_store_str(&p, (const char*)method_buf, 19); _libssh2_store_str(&p, (const char *)method_buf, 19);
/* Name domain */ /* Name domain */
_libssh2_store_str(&p, (const char*)method_buf + 11, 8); _libssh2_store_str(&p, (const char *)method_buf + 11, 8);
/* Public key */ /* Public key */
_libssh2_store_str(&p, (const char*)octal_value, octal_len); _libssh2_store_str(&p, (const char *)octal_value, octal_len);
*method = method_buf; *method = method_buf;
*method_len = 19; *method_len = 19;
@@ -1477,20 +1479,20 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
clean_exit: clean_exit:
if ( ec != NULL) if(ec != NULL)
EC_KEY_free(ec); EC_KEY_free(ec);
if (bn_ctx != NULL) { if(bn_ctx != NULL) {
BN_CTX_free(bn_ctx); BN_CTX_free(bn_ctx);
} }
if ( octal_value != NULL ) if(octal_value != NULL)
free(octal_value); free(octal_value);
if ( rc == 0 ) if(rc == 0)
return 0; return 0;
if (method_buf != NULL ) if(method_buf != NULL)
LIBSSH2_FREE(session, method_buf); LIBSSH2_FREE(session, method_buf);
return -1; return -1;
@@ -1518,7 +1520,7 @@ _libssh2_ecdsa_create_key(_libssh2_ec_key **out_private_key,
/* create key */ /* create key */
BN_CTX *bn_ctx = BN_CTX_new(); BN_CTX *bn_ctx = BN_CTX_new();
if (!bn_ctx) if(!bn_ctx)
return -1; return -1;
private_key = EC_KEY_new_by_curve_name(curve_type); private_key = EC_KEY_new_by_curve_name(curve_type);
@@ -1529,24 +1531,24 @@ _libssh2_ecdsa_create_key(_libssh2_ec_key **out_private_key,
/* get length */ /* get length */
octal_len = EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED, NULL, 0, bn_ctx); octal_len = EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED, NULL, 0, bn_ctx);
if (octal_len > EC_MAX_POINT_LEN) { if(octal_len > EC_MAX_POINT_LEN) {
ret = -1; ret = -1;
goto clean_exit; goto clean_exit;
} }
/* convert to octal */ /* convert to octal */
if (EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED, if(EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED,
octal_value, octal_len, bn_ctx) != octal_len){ octal_value, octal_len, bn_ctx) != octal_len) {
ret = -1; ret = -1;
goto clean_exit; goto clean_exit;
} }
if (out_private_key != NULL) if(out_private_key != NULL)
*out_private_key = private_key; *out_private_key = private_key;
if (out_public_key_octal) { if(out_public_key_octal) {
*out_public_key_octal = malloc(octal_len); *out_public_key_octal = malloc(octal_len);
if (out_public_key_octal == NULL) { if(out_public_key_octal == NULL) {
ret = -1; ret = -1;
goto clean_exit; goto clean_exit;
} }
@@ -1554,12 +1556,12 @@ _libssh2_ecdsa_create_key(_libssh2_ec_key **out_private_key,
memcpy(*out_public_key_octal, octal_value, octal_len); memcpy(*out_public_key_octal, octal_value, octal_len);
} }
if (out_public_key_octal_len != NULL) if(out_public_key_octal_len != NULL)
*out_public_key_octal_len = octal_len; *out_public_key_octal_len = octal_len;
clean_exit: clean_exit:
if (bn_ctx) if(bn_ctx)
BN_CTX_free(bn_ctx); BN_CTX_free(bn_ctx);
return (ret == 1) ? 0 : -1; return (ret == 1) ? 0 : -1;
@@ -1584,34 +1586,34 @@ _libssh2_ecdh_gen_k(_libssh2_bn **k, _libssh2_ec_key *private_key,
BN_CTX *bn_ctx = BN_CTX_new(); BN_CTX *bn_ctx = BN_CTX_new();
if ( !bn_ctx ) if(!bn_ctx)
return -1; return -1;
if ( k == NULL ) if(k == NULL)
return -1; return -1;
private_key_group = EC_KEY_get0_group(private_key); private_key_group = EC_KEY_get0_group(private_key);
server_public_key_point = EC_POINT_new(private_key_group); server_public_key_point = EC_POINT_new(private_key_group);
if ( server_public_key_point == NULL ) if(server_public_key_point == NULL)
return -1; return -1;
rc = EC_POINT_oct2point(private_key_group, server_public_key_point, server_public_key, server_public_key_len, bn_ctx); rc = EC_POINT_oct2point(private_key_group, server_public_key_point, server_public_key, server_public_key_len, bn_ctx);
if ( rc != 1 ) { if(rc != 1) {
ret = -1; ret = -1;
goto clean_exit; goto clean_exit;
} }
secret_len = (EC_GROUP_get_degree(private_key_group) + 7) / 8; secret_len = (EC_GROUP_get_degree(private_key_group) + 7) / 8;
secret = malloc(secret_len); secret = malloc(secret_len);
if (!secret) { if(!secret) {
ret = -1; ret = -1;
goto clean_exit; goto clean_exit;
} }
secret_len = ECDH_compute_key(secret, secret_len, server_public_key_point, private_key, NULL); secret_len = ECDH_compute_key(secret, secret_len, server_public_key_point, private_key, NULL);
if( secret_len <= 0 || secret_len > EC_MAX_POINT_LEN ) { if(secret_len <= 0 || secret_len > EC_MAX_POINT_LEN) {
ret = -1; ret = -1;
goto clean_exit; goto clean_exit;
} }
@@ -1620,13 +1622,13 @@ _libssh2_ecdh_gen_k(_libssh2_bn **k, _libssh2_ec_key *private_key,
clean_exit: clean_exit:
if ( server_public_key_point != NULL ) if(server_public_key_point != NULL)
EC_POINT_free(server_public_key_point); EC_POINT_free(server_public_key_point);
if ( bn_ctx != NULL ) if(bn_ctx != NULL)
BN_CTX_free(bn_ctx); BN_CTX_free(bn_ctx);
if ( secret != NULL ) if(secret != NULL)
free(secret); free(secret);
return ret; return ret;
@@ -1655,7 +1657,7 @@ _libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
privatekey); privatekey);
bp = BIO_new_file(privatekey, "r"); bp = BIO_new_file(privatekey, "r");
if (bp == NULL) { if(bp == NULL) {
return _libssh2_error(session, return _libssh2_error(session,
LIBSSH2_ERROR_FILE, LIBSSH2_ERROR_FILE,
"Unable to extract public key from private key " "Unable to extract public key from private key "
@@ -1663,10 +1665,10 @@ _libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
} }
BIO_reset(bp); BIO_reset(bp);
pk = PEM_read_bio_PrivateKey(bp, NULL, NULL, (void*)passphrase); pk = PEM_read_bio_PrivateKey(bp, NULL, NULL, (void *)passphrase);
BIO_free(bp); BIO_free(bp);
if (pk == NULL) { if(pk == NULL) {
return _libssh2_error(session, return _libssh2_error(session,
LIBSSH2_ERROR_FILE, LIBSSH2_ERROR_FILE,
"Unable to extract public key " "Unable to extract public key "
@@ -1681,7 +1683,7 @@ _libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
pktype = pk->type; pktype = pk->type;
#endif #endif
switch (pktype) { switch(pktype) {
case EVP_PKEY_RSA : case EVP_PKEY_RSA :
st = gen_publickey_from_rsa_evp( st = gen_publickey_from_rsa_evp(
session, method, method_len, pubkeydata, pubkeydata_len, pk); session, method, method_len, pubkeydata, pubkeydata_len, pk);
@@ -1734,15 +1736,15 @@ _libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
"Computing public key from private key."); "Computing public key from private key.");
bp = BIO_new_mem_buf((char *)privatekeydata, privatekeydata_len); bp = BIO_new_mem_buf((char *)privatekeydata, privatekeydata_len);
if (!bp) { if(!bp) {
return -1; return -1;
} }
BIO_reset(bp); BIO_reset(bp);
pk = PEM_read_bio_PrivateKey(bp, NULL, NULL, (void*)passphrase); pk = PEM_read_bio_PrivateKey(bp, NULL, NULL, (void *)passphrase);
BIO_free(bp); BIO_free(bp);
if (pk == NULL) { if(pk == NULL) {
return _libssh2_error(session, return _libssh2_error(session,
LIBSSH2_ERROR_FILE, LIBSSH2_ERROR_FILE,
"Unable to extract public key " "Unable to extract public key "
@@ -1757,7 +1759,7 @@ _libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
pktype = pk->type; pktype = pk->type;
#endif #endif
switch (pktype) { switch(pktype) {
case EVP_PKEY_RSA : case EVP_PKEY_RSA :
st = gen_publickey_from_rsa_evp(session, method, method_len, st = gen_publickey_from_rsa_evp(session, method, method_len,
pubkeydata, pubkeydata_len, pk); pubkeydata, pubkeydata_len, pk);

475
src/os400qc3.c
View File

File diff suppressed because it is too large Load Diff

4
src/os400qc3.h
View File

@@ -296,8 +296,8 @@ typedef struct { /* Diffie-Hellman context. */
Qc3_CTR, 24} Qc3_CTR, 24}
#define _libssh2_cipher_aes256ctr {Qc3_Alg_Block_Cipher, Qc3_AES, 32, \ #define _libssh2_cipher_aes256ctr {Qc3_Alg_Block_Cipher, Qc3_AES, 32, \
Qc3_CTR, 32} Qc3_CTR, 32}
#define _libssh2_cipher_3des {Qc3_Alg_Block_Cipher, Qc3_TDES, 0, \ #define _libssh2_cipher_3des {Qc3_Alg_Block_Cipher, Qc3_TDES, 0, \
Qc3_CBC, 24} Qc3_CBC, 24}
#define _libssh2_cipher_arcfour {Qc3_Alg_Stream_Cipher, Qc3_RC4, 0, 0, 16} #define _libssh2_cipher_arcfour {Qc3_Alg_Stream_Cipher, Qc3_RC4, 0, 0, 16}
#define _libssh2_cipher_dtor(ctx) _libssh2_os400qc3_crypto_dtor(ctx) #define _libssh2_cipher_dtor(ctx) _libssh2_os400qc3_crypto_dtor(ctx)

196
src/packet.c
View File

@@ -87,7 +87,7 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
(void) datalen; (void) datalen;
if (listen_state->state == libssh2_NB_state_idle) { if(listen_state->state == libssh2_NB_state_idle) {
unsigned char *s = data + (sizeof("forwarded-tcpip") - 1) + 5; unsigned char *s = data + (sizeof("forwarded-tcpip") - 1) + 5;
listen_state->sender_channel = _libssh2_ntohu32(s); listen_state->sender_channel = _libssh2_ntohu32(s);
s += 4; s += 4;
@@ -118,9 +118,9 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
listen_state->state = libssh2_NB_state_allocated; listen_state->state = libssh2_NB_state_allocated;
} }
if (listen_state->state != libssh2_NB_state_sent) { if(listen_state->state != libssh2_NB_state_sent) {
while (listn) { while(listn) {
if ((listn->port == (int) listen_state->port) && if((listn->port == (int) listen_state->port) &&
(strlen(listn->host) == listen_state->host_len) && (strlen(listn->host) == listen_state->host_len) &&
(memcmp (listn->host, listen_state->host, (memcmp (listn->host, listen_state->host,
listen_state->host_len) == 0)) { listen_state->host_len) == 0)) {
@@ -128,8 +128,8 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
LIBSSH2_CHANNEL *channel = NULL; LIBSSH2_CHANNEL *channel = NULL;
listen_state->channel = NULL; listen_state->channel = NULL;
if (listen_state->state == libssh2_NB_state_allocated) { if(listen_state->state == libssh2_NB_state_allocated) {
if (listn->queue_maxsize && if(listn->queue_maxsize &&
(listn->queue_maxsize <= listn->queue_size)) { (listn->queue_maxsize <= listn->queue_size)) {
/* Queue is full */ /* Queue is full */
failure_code = SSH_OPEN_RESOURCE_SHORTAGE; failure_code = SSH_OPEN_RESOURCE_SHORTAGE;
@@ -140,7 +140,7 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
} }
channel = LIBSSH2_CALLOC(session, sizeof(LIBSSH2_CHANNEL)); channel = LIBSSH2_CALLOC(session, sizeof(LIBSSH2_CHANNEL));
if (!channel) { if(!channel) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate a channel for " "Unable to allocate a channel for "
"new connection"); "new connection");
@@ -156,7 +156,7 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
channel-> channel->
channel_type_len + channel_type_len +
1); 1);
if (!channel->channel_type) { if(!channel->channel_type) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate a channel for new" "Unable to allocate a channel for new"
" connection"); " connection");
@@ -203,12 +203,12 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
listen_state->state = libssh2_NB_state_created; listen_state->state = libssh2_NB_state_created;
} }
if (listen_state->state == libssh2_NB_state_created) { if(listen_state->state == libssh2_NB_state_created) {
rc = _libssh2_transport_send(session, listen_state->packet, rc = _libssh2_transport_send(session, listen_state->packet,
17, NULL, 0); 17, NULL, 0);
if (rc == LIBSSH2_ERROR_EAGAIN) if(rc == LIBSSH2_ERROR_EAGAIN)
return rc; return rc;
else if (rc) { else if(rc) {
listen_state->state = libssh2_NB_state_idle; listen_state->state = libssh2_NB_state_idle;
return _libssh2_error(session, rc, return _libssh2_error(session, rc,
"Unable to send channel " "Unable to send channel "
@@ -216,7 +216,7 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
} }
/* Link the channel into the end of the queue list */ /* Link the channel into the end of the queue list */
if (listen_state->channel) { if(listen_state->channel) {
_libssh2_list_add(&listn->queue, _libssh2_list_add(&listn->queue,
&listen_state->channel->node); &listen_state->channel->node);
listn->queue_size++; listn->queue_size++;
@@ -243,9 +243,10 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
rc = _libssh2_transport_send(session, listen_state->packet, rc = _libssh2_transport_send(session, listen_state->packet,
packet_len, NULL, 0); packet_len, NULL, 0);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return rc; return rc;
} else if (rc) { }
else if(rc) {
listen_state->state = libssh2_NB_state_idle; listen_state->state = libssh2_NB_state_idle;
return _libssh2_error(session, rc, "Unable to send open failure"); return _libssh2_error(session, rc, "Unable to send open failure");
@@ -273,7 +274,7 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
(void) datalen; (void) datalen;
if (x11open_state->state == libssh2_NB_state_idle) { if(x11open_state->state == libssh2_NB_state_idle) {
unsigned char *s = data + (sizeof("x11") - 1) + 5; unsigned char *s = data + (sizeof("x11") - 1) + 5;
x11open_state->sender_channel = _libssh2_ntohu32(s); x11open_state->sender_channel = _libssh2_ntohu32(s);
s += 4; s += 4;
@@ -295,10 +296,10 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
x11open_state->state = libssh2_NB_state_allocated; x11open_state->state = libssh2_NB_state_allocated;
} }
if (session->x11) { if(session->x11) {
if (x11open_state->state == libssh2_NB_state_allocated) { if(x11open_state->state == libssh2_NB_state_allocated) {
channel = LIBSSH2_CALLOC(session, sizeof(LIBSSH2_CHANNEL)); channel = LIBSSH2_CALLOC(session, sizeof(LIBSSH2_CHANNEL));
if (!channel) { if(!channel) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"allocate a channel for new connection"); "allocate a channel for new connection");
failure_code = SSH_OPEN_RESOURCE_SHORTAGE; failure_code = SSH_OPEN_RESOURCE_SHORTAGE;
@@ -310,7 +311,7 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
channel->channel_type = LIBSSH2_ALLOC(session, channel->channel_type = LIBSSH2_ALLOC(session,
channel->channel_type_len + channel->channel_type_len +
1); 1);
if (!channel->channel_type) { if(!channel->channel_type) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"allocate a channel for new connection"); "allocate a channel for new connection");
LIBSSH2_FREE(session, channel); LIBSSH2_FREE(session, channel);
@@ -350,12 +351,13 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
x11open_state->state = libssh2_NB_state_created; x11open_state->state = libssh2_NB_state_created;
} }
if (x11open_state->state == libssh2_NB_state_created) { if(x11open_state->state == libssh2_NB_state_created) {
rc = _libssh2_transport_send(session, x11open_state->packet, 17, rc = _libssh2_transport_send(session, x11open_state->packet, 17,
NULL, 0); NULL, 0);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return rc; return rc;
} else if (rc) { }
else if(rc) {
x11open_state->state = libssh2_NB_state_idle; x11open_state->state = libssh2_NB_state_idle;
return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
"Unable to send channel open " "Unable to send channel open "
@@ -389,9 +391,10 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
rc = _libssh2_transport_send(session, x11open_state->packet, packet_len, rc = _libssh2_transport_send(session, x11open_state->packet, packet_len,
NULL, 0); NULL, 0);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return rc; return rc;
} else if (rc) { }
else if(rc) {
x11open_state->state = libssh2_NB_state_idle; x11open_state->state = libssh2_NB_state_idle;
return _libssh2_error(session, rc, "Unable to send open failure"); return _libssh2_error(session, rc, "Unable to send open failure");
} }
@@ -416,10 +419,10 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
size_t datalen, int macstate) size_t datalen, int macstate)
{ {
int rc = 0; int rc = 0;
char *message=NULL; char *message = NULL;
char *language=NULL; char *language = NULL;
size_t message_len=0; size_t message_len = 0;
size_t language_len=0; size_t language_len = 0;
LIBSSH2_CHANNEL *channelp = NULL; LIBSSH2_CHANNEL *channelp = NULL;
size_t data_head = 0; size_t data_head = 0;
unsigned char msg = data[0]; unsigned char msg = data[0];
@@ -430,7 +433,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
"Packet type %d received, length=%d", "Packet type %d received, length=%d",
(int) msg, (int) datalen); (int) msg, (int) datalen);
if ((macstate == LIBSSH2_MAC_INVALID) && if((macstate == LIBSSH2_MAC_INVALID) &&
(!session->macerror || (!session->macerror ||
LIBSSH2_MACERROR(session, (char *) data, datalen))) { LIBSSH2_MACERROR(session, (char *) data, datalen))) {
/* Bad MAC input, but no callback set or non-zero return from the /* Bad MAC input, but no callback set or non-zero return from the
@@ -456,9 +459,9 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
break; break;
} }
if (session->packAdd_state == libssh2_NB_state_allocated) { if(session->packAdd_state == libssh2_NB_state_allocated) {
/* A couple exceptions to the packet adding rule: */ /* A couple exceptions to the packet adding rule: */
switch (msg) { switch(msg) {
/* /*
byte SSH_MSG_DISCONNECT byte SSH_MSG_DISCONNECT
@@ -489,9 +492,9 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
} }
else else
/* bad size, clear it */ /* bad size, clear it */
message_len=0; message_len = 0;
} }
if (session->ssh_msg_disconnect) { if(session->ssh_msg_disconnect) {
LIBSSH2_DISCONNECT(session, reason, message, LIBSSH2_DISCONNECT(session, reason, message,
message_len, language, language_len); message_len, language, language_len);
} }
@@ -511,11 +514,12 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
*/ */
case SSH_MSG_IGNORE: case SSH_MSG_IGNORE:
if (datalen >= 2) { if(datalen >= 2) {
if (session->ssh_msg_ignore) { if(session->ssh_msg_ignore) {
LIBSSH2_IGNORE(session, (char *) data + 1, datalen - 1); LIBSSH2_IGNORE(session, (char *) data + 1, datalen - 1);
} }
} else if (session->ssh_msg_ignore) { }
else if(session->ssh_msg_ignore) {
LIBSSH2_IGNORE(session, "", 0); LIBSSH2_IGNORE(session, "", 0);
} }
LIBSSH2_FREE(session, data); LIBSSH2_FREE(session, data);
@@ -531,7 +535,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
case SSH_MSG_DEBUG: case SSH_MSG_DEBUG:
if(datalen >= 2) { if(datalen >= 2) {
int always_display= data[1]; int always_display = data[1];
if(datalen >= 6) { if(datalen >= 6) {
message_len = _libssh2_ntohu32(data + 2); message_len = _libssh2_ntohu32(data + 2);
@@ -546,7 +550,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
} }
} }
if (session->ssh_msg_debug) { if(session->ssh_msg_debug) {
LIBSSH2_DEBUG(session, always_display, message, LIBSSH2_DEBUG(session, always_display, message,
message_len, language, language_len); message_len, language, language_len);
} }
@@ -570,8 +574,8 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
case SSH_MSG_GLOBAL_REQUEST: case SSH_MSG_GLOBAL_REQUEST:
if(datalen >= 5) { if(datalen >= 5) {
uint32_t len =0; uint32_t len = 0;
unsigned char want_reply=0; unsigned char want_reply = 0;
len = _libssh2_ntohu32(data + 1); len = _libssh2_ntohu32(data + 1);
if(datalen >= (6 + len)) { if(datalen >= (6 + len)) {
want_reply = data[5 + len]; want_reply = data[5 + len];
@@ -582,13 +586,13 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
} }
if (want_reply) { if(want_reply) {
static const unsigned char packet = static const unsigned char packet =
SSH_MSG_REQUEST_FAILURE; SSH_MSG_REQUEST_FAILURE;
libssh2_packet_add_jump_point5: libssh2_packet_add_jump_point5:
session->packAdd_state = libssh2_NB_state_jump5; session->packAdd_state = libssh2_NB_state_jump5;
rc = _libssh2_transport_send(session, &packet, 1, NULL, 0); rc = _libssh2_transport_send(session, &packet, 1, NULL, 0);
if (rc == LIBSSH2_ERROR_EAGAIN) if(rc == LIBSSH2_ERROR_EAGAIN)
return rc; return rc;
} }
} }
@@ -624,7 +628,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
_libssh2_channel_locate(session, _libssh2_channel_locate(session,
_libssh2_ntohu32(data + 1)); _libssh2_ntohu32(data + 1));
if (!channelp) { if(!channelp) {
_libssh2_error(session, LIBSSH2_ERROR_CHANNEL_UNKNOWN, _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_UNKNOWN,
"Packet received for unknown channel"); "Packet received for unknown channel");
LIBSSH2_FREE(session, data); LIBSSH2_FREE(session, data);
@@ -634,7 +638,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
#ifdef LIBSSH2DEBUG #ifdef LIBSSH2DEBUG
{ {
uint32_t stream_id = 0; uint32_t stream_id = 0;
if (msg == SSH_MSG_CHANNEL_EXTENDED_DATA) if(msg == SSH_MSG_CHANNEL_EXTENDED_DATA)
stream_id = _libssh2_ntohu32(data + 5); stream_id = _libssh2_ntohu32(data + 5);
_libssh2_debug(session, LIBSSH2_TRACE_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
@@ -645,7 +649,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
stream_id); stream_id);
} }
#endif #endif
if ((channelp->remote.extended_data_ignore_mode == if((channelp->remote.extended_data_ignore_mode ==
LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE) && LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE) &&
(msg == SSH_MSG_CHANNEL_EXTENDED_DATA)) { (msg == SSH_MSG_CHANNEL_EXTENDED_DATA)) {
/* Pretend we didn't receive this */ /* Pretend we didn't receive this */
@@ -654,7 +658,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
_libssh2_debug(session, LIBSSH2_TRACE_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
"Ignoring extended data and refunding %d bytes", "Ignoring extended data and refunding %d bytes",
(int) (datalen - 13)); (int) (datalen - 13));
if (channelp->read_avail + datalen - data_head >= if(channelp->read_avail + datalen - data_head >=
channelp->remote.window_size) channelp->remote.window_size)
datalen = channelp->remote.window_size - datalen = channelp->remote.window_size -
channelp->read_avail + data_head; channelp->read_avail + data_head;
@@ -675,7 +679,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
packAdd_channelp, packAdd_channelp,
datalen - 13, datalen - 13,
1, NULL); 1, NULL);
if (rc == LIBSSH2_ERROR_EAGAIN) if(rc == LIBSSH2_ERROR_EAGAIN)
return rc; return rc;
session->packAdd_state = libssh2_NB_state_idle; session->packAdd_state = libssh2_NB_state_idle;
@@ -686,7 +690,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
* REMEMBER! remote means remote as source of data, * REMEMBER! remote means remote as source of data,
* NOT remote window! * NOT remote window!
*/ */
if (channelp->remote.packet_size < (datalen - data_head)) { if(channelp->remote.packet_size < (datalen - data_head)) {
/* /*
* Spec says we MAY ignore bytes sent beyond * Spec says we MAY ignore bytes sent beyond
* packet_size * packet_size
@@ -697,7 +701,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
" to receive, truncating"); " to receive, truncating");
datalen = channelp->remote.packet_size + data_head; datalen = channelp->remote.packet_size + data_head;
} }
if (channelp->remote.window_size <= channelp->read_avail) { if(channelp->remote.window_size <= channelp->read_avail) {
/* /*
* Spec says we MAY ignore bytes sent beyond * Spec says we MAY ignore bytes sent beyond
* window_size * window_size
@@ -713,7 +717,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
/* Reset EOF status */ /* Reset EOF status */
channelp->remote.eof = 0; channelp->remote.eof = 0;
if (channelp->read_avail + datalen - data_head > if(channelp->read_avail + datalen - data_head >
channelp->remote.window_size) { channelp->remote.window_size) {
_libssh2_error(session, _libssh2_error(session,
LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED, LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED,
@@ -746,7 +750,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
channelp = channelp =
_libssh2_channel_locate(session, _libssh2_channel_locate(session,
_libssh2_ntohu32(data + 1)); _libssh2_ntohu32(data + 1));
if (!channelp) if(!channelp)
/* We may have freed already, just quietly ignore this... */ /* We may have freed already, just quietly ignore this... */
; ;
else { else {
@@ -783,7 +787,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
"Channel %d received request type %.*s (wr %X)", "Channel %d received request type %.*s (wr %X)",
channel, len, data + 9, want_reply); channel, len, data + 9, want_reply);
if (len == sizeof("exit-status") - 1 if(len == sizeof("exit-status") - 1
&& !memcmp("exit-status", data + 9, && !memcmp("exit-status", data + 9,
sizeof("exit-status") - 1)) { sizeof("exit-status") - 1)) {
@@ -792,7 +796,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
channelp = channelp =
_libssh2_channel_locate(session, channel); _libssh2_channel_locate(session, channel);
if (channelp) { if(channelp) {
channelp->exit_status = channelp->exit_status =
_libssh2_ntohu32(data + 9 + sizeof("exit-status")); _libssh2_ntohu32(data + 9 + sizeof("exit-status"));
_libssh2_debug(session, LIBSSH2_TRACE_CONN, _libssh2_debug(session, LIBSSH2_TRACE_CONN,
@@ -804,20 +808,20 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
} }
} }
else if (len == sizeof("exit-signal") - 1 else if(len == sizeof("exit-signal") - 1
&& !memcmp("exit-signal", data + 9, && !memcmp("exit-signal", data + 9,
sizeof("exit-signal") - 1)) { sizeof("exit-signal") - 1)) {
/* command terminated due to signal */ /* command terminated due to signal */
if(datalen >= 20) if(datalen >= 20)
channelp = _libssh2_channel_locate(session, channel); channelp = _libssh2_channel_locate(session, channel);
if (channelp) { if(channelp) {
/* set signal name (without SIG prefix) */ /* set signal name (without SIG prefix) */
uint32_t namelen = uint32_t namelen =
_libssh2_ntohu32(data + 9 + sizeof("exit-signal")); _libssh2_ntohu32(data + 9 + sizeof("exit-signal"));
channelp->exit_signal = channelp->exit_signal =
LIBSSH2_ALLOC(session, namelen + 1); LIBSSH2_ALLOC(session, namelen + 1);
if (!channelp->exit_signal) if(!channelp->exit_signal)
rc = _libssh2_error(session, LIBSSH2_ERROR_ALLOC, rc = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"memory for signal name"); "memory for signal name");
else { else {
@@ -836,14 +840,14 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
} }
if (want_reply) { if(want_reply) {
unsigned char packet[5]; unsigned char packet[5];
libssh2_packet_add_jump_point4: libssh2_packet_add_jump_point4:
session->packAdd_state = libssh2_NB_state_jump4; session->packAdd_state = libssh2_NB_state_jump4;
packet[0] = SSH_MSG_CHANNEL_FAILURE; packet[0] = SSH_MSG_CHANNEL_FAILURE;
memcpy(&packet[1], data+1, 4); memcpy(&packet[1], data + 1, 4);
rc = _libssh2_transport_send(session, packet, 5, NULL, 0); rc = _libssh2_transport_send(session, packet, 5, NULL, 0);
if (rc == LIBSSH2_ERROR_EAGAIN) if(rc == LIBSSH2_ERROR_EAGAIN)
return rc; return rc;
} }
} }
@@ -861,7 +865,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
channelp = channelp =
_libssh2_channel_locate(session, _libssh2_channel_locate(session,
_libssh2_ntohu32(data + 1)); _libssh2_ntohu32(data + 1));
if (!channelp) { if(!channelp) {
/* We may have freed already, just quietly ignore this... */ /* We may have freed already, just quietly ignore this... */
LIBSSH2_FREE(session, data); LIBSSH2_FREE(session, data);
session->packAdd_state = libssh2_NB_state_idle; session->packAdd_state = libssh2_NB_state_idle;
@@ -890,7 +894,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
case SSH_MSG_CHANNEL_OPEN: case SSH_MSG_CHANNEL_OPEN:
if(datalen < 17) if(datalen < 17)
; ;
else if ((datalen >= (sizeof("forwarded-tcpip") + 4)) && else if((datalen >= (sizeof("forwarded-tcpip") + 4)) &&
((sizeof("forwarded-tcpip") - 1) == ((sizeof("forwarded-tcpip") - 1) ==
_libssh2_ntohu32(data + 1)) _libssh2_ntohu32(data + 1))
&& &&
@@ -906,7 +910,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
rc = packet_queue_listener(session, data, datalen, rc = packet_queue_listener(session, data, datalen,
&session->packAdd_Qlstn_state); &session->packAdd_Qlstn_state);
} }
else if ((datalen >= (sizeof("x11") + 4)) && else if((datalen >= (sizeof("x11") + 4)) &&
((sizeof("x11") - 1) == _libssh2_ntohu32(data + 1)) && ((sizeof("x11") - 1) == _libssh2_ntohu32(data + 1)) &&
(memcmp(data + 5, "x11", sizeof("x11") - 1) == 0)) { (memcmp(data + 5, "x11", sizeof("x11") - 1) == 0)) {
@@ -919,7 +923,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
rc = packet_x11_open(session, data, datalen, rc = packet_x11_open(session, data, datalen,
&session->packAdd_x11open_state); &session->packAdd_x11open_state);
} }
if (rc == LIBSSH2_ERROR_EAGAIN) if(rc == LIBSSH2_ERROR_EAGAIN)
return rc; return rc;
LIBSSH2_FREE(session, data); LIBSSH2_FREE(session, data);
@@ -961,10 +965,10 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
session->packAdd_state = libssh2_NB_state_sent; session->packAdd_state = libssh2_NB_state_sent;
} }
if (session->packAdd_state == libssh2_NB_state_sent) { if(session->packAdd_state == libssh2_NB_state_sent) {
LIBSSH2_PACKET *packetp = LIBSSH2_PACKET *packetp =
LIBSSH2_ALLOC(session, sizeof(LIBSSH2_PACKET)); LIBSSH2_ALLOC(session, sizeof(LIBSSH2_PACKET));
if (!packetp) { if(!packetp) {
_libssh2_debug(session, LIBSSH2_ERROR_ALLOC, _libssh2_debug(session, LIBSSH2_ERROR_ALLOC,
"memory for packet"); "memory for packet");
LIBSSH2_FREE(session, data); LIBSSH2_FREE(session, data);
@@ -980,10 +984,10 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
session->packAdd_state = libssh2_NB_state_sent1; session->packAdd_state = libssh2_NB_state_sent1;
} }
if ((msg == SSH_MSG_KEXINIT && if((msg == SSH_MSG_KEXINIT &&
!(session->state & LIBSSH2_STATE_EXCHANGING_KEYS)) || !(session->state & LIBSSH2_STATE_EXCHANGING_KEYS)) ||
(session->packAdd_state == libssh2_NB_state_sent2)) { (session->packAdd_state == libssh2_NB_state_sent2)) {
if (session->packAdd_state == libssh2_NB_state_sent1) { if(session->packAdd_state == libssh2_NB_state_sent1) {
/* /*
* Remote wants new keys * Remote wants new keys
* Well, it's already in the brigade, * Well, it's already in the brigade,
@@ -1012,7 +1016,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
* send NEWKEYS yet, otherwise remote will drop us like a rock * send NEWKEYS yet, otherwise remote will drop us like a rock
*/ */
rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state); rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state);
if (rc == LIBSSH2_ERROR_EAGAIN) if(rc == LIBSSH2_ERROR_EAGAIN)
return rc; return rc;
} }
@@ -1037,8 +1041,8 @@ _libssh2_packet_ask(LIBSSH2_SESSION * session, unsigned char packet_type,
_libssh2_debug(session, LIBSSH2_TRACE_TRANS, _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
"Looking for packet of type: %d", (int) packet_type); "Looking for packet of type: %d", (int) packet_type);
while (packet) { while(packet) {
if (packet->data[0] == packet_type if(packet->data[0] == packet_type
&& (packet->data_len >= (match_ofs + match_len)) && (packet->data_len >= (match_ofs + match_len))
&& (!match_buf || && (!match_buf ||
(memcmp(packet->data + match_ofs, match_buf, (memcmp(packet->data + match_ofs, match_buf,
@@ -1075,7 +1079,7 @@ _libssh2_packet_askv(LIBSSH2_SESSION * session,
int i, packet_types_len = strlen((char *) packet_types); int i, packet_types_len = strlen((char *) packet_types);
for(i = 0; i < packet_types_len; i++) { for(i = 0; i < packet_types_len; i++) {
if (0 == _libssh2_packet_ask(session, packet_types[i], data, if(0 == _libssh2_packet_ask(session, packet_types[i], data,
data_len, match_ofs, data_len, match_ofs,
match_buf, match_len)) { match_buf, match_len)) {
return 0; return 0;
@@ -1102,8 +1106,8 @@ _libssh2_packet_require(LIBSSH2_SESSION * session, unsigned char packet_type,
size_t match_len, size_t match_len,
packet_require_state_t *state) packet_require_state_t *state)
{ {
if (state->start == 0) { if(state->start == 0) {
if (_libssh2_packet_ask(session, packet_type, data, data_len, if(_libssh2_packet_ask(session, packet_type, data, data_len,
match_ofs, match_buf, match_ofs, match_buf,
match_len) == 0) { match_len) == 0) {
/* A packet was available in the packet brigade */ /* A packet was available in the packet brigade */
@@ -1113,26 +1117,28 @@ _libssh2_packet_require(LIBSSH2_SESSION * session, unsigned char packet_type,
state->start = time(NULL); state->start = time(NULL);
} }
while (session->socket_state == LIBSSH2_SOCKET_CONNECTED) { while(session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
int ret = _libssh2_transport_read(session); int ret = _libssh2_transport_read(session);
if (ret == LIBSSH2_ERROR_EAGAIN) if(ret == LIBSSH2_ERROR_EAGAIN)
return ret; return ret;
else if (ret < 0) { else if(ret < 0) {
state->start = 0; state->start = 0;
/* an error which is not just because of blocking */ /* an error which is not just because of blocking */
return ret; return ret;
} else if (ret == packet_type) { }
else if(ret == packet_type) {
/* Be lazy, let packet_ask pull it out of the brigade */ /* Be lazy, let packet_ask pull it out of the brigade */
ret = _libssh2_packet_ask(session, packet_type, data, data_len, ret = _libssh2_packet_ask(session, packet_type, data, data_len,
match_ofs, match_buf, match_len); match_ofs, match_buf, match_len);
state->start = 0; state->start = 0;
return ret; return ret;
} else if (ret == 0) { }
else if(ret == 0) {
/* nothing available, wait until data arrives or we time out */ /* nothing available, wait until data arrives or we time out */
long left = LIBSSH2_READ_TIMEOUT - (long)(time(NULL) - long left = LIBSSH2_READ_TIMEOUT - (long)(time(NULL) -
state->start); state->start);
if (left <= 0) { if(left <= 0) {
state->start = 0; state->start = 0;
return LIBSSH2_ERROR_TIMEOUT; return LIBSSH2_ERROR_TIMEOUT;
} }
@@ -1160,13 +1166,13 @@ _libssh2_packet_burn(LIBSSH2_SESSION * session,
unsigned char i, all_packets[255]; unsigned char i, all_packets[255];
int ret; int ret;
if (*state == libssh2_NB_state_idle) { if(*state == libssh2_NB_state_idle) {
for(i = 1; i < 255; i++) { for(i = 1; i < 255; i++) {
all_packets[i - 1] = i; all_packets[i - 1] = i;
} }
all_packets[254] = 0; all_packets[254] = 0;
if (_libssh2_packet_askv(session, all_packets, &data, &data_len, 0, if(_libssh2_packet_askv(session, all_packets, &data, &data_len, 0,
NULL, 0) == 0) { NULL, 0) == 0) {
i = data[0]; i = data[0];
/* A packet was available in the packet brigade, burn it */ /* A packet was available in the packet brigade, burn it */
@@ -1179,20 +1185,22 @@ _libssh2_packet_burn(LIBSSH2_SESSION * session,
*state = libssh2_NB_state_created; *state = libssh2_NB_state_created;
} }
while (session->socket_state == LIBSSH2_SOCKET_CONNECTED) { while(session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
ret = _libssh2_transport_read(session); ret = _libssh2_transport_read(session);
if (ret == LIBSSH2_ERROR_EAGAIN) { if(ret == LIBSSH2_ERROR_EAGAIN) {
return ret; return ret;
} else if (ret < 0) { }
else if(ret < 0) {
*state = libssh2_NB_state_idle; *state = libssh2_NB_state_idle;
return ret; return ret;
} else if (ret == 0) { }
else if(ret == 0) {
/* FIXME: this might busyloop */ /* FIXME: this might busyloop */
continue; continue;
} }
/* Be lazy, let packet_ask pull it out of the brigade */ /* Be lazy, let packet_ask pull it out of the brigade */
if (0 == if(0 ==
_libssh2_packet_ask(session, (unsigned char)ret, _libssh2_packet_ask(session, (unsigned char)ret,
&data, &data_len, 0, NULL, 0)) { &data, &data_len, 0, NULL, 0)) {
/* Smoke 'em if you got 'em */ /* Smoke 'em if you got 'em */
@@ -1222,37 +1230,37 @@ _libssh2_packet_requirev(LIBSSH2_SESSION *session,
const unsigned char *match_buf, size_t match_len, const unsigned char *match_buf, size_t match_len,
packet_requirev_state_t * state) packet_requirev_state_t * state)
{ {
if (_libssh2_packet_askv(session, packet_types, data, data_len, match_ofs, if(_libssh2_packet_askv(session, packet_types, data, data_len, match_ofs,
match_buf, match_len) == 0) { match_buf, match_len) == 0) {
/* One of the packets listed was available in the packet brigade */ /* One of the packets listed was available in the packet brigade */
state->start = 0; state->start = 0;
return 0; return 0;
} }
if (state->start == 0) { if(state->start == 0) {
state->start = time(NULL); state->start = time(NULL);
} }
while (session->socket_state != LIBSSH2_SOCKET_DISCONNECTED) { while(session->socket_state != LIBSSH2_SOCKET_DISCONNECTED) {
int ret = _libssh2_transport_read(session); int ret = _libssh2_transport_read(session);
if ((ret < 0) && (ret != LIBSSH2_ERROR_EAGAIN)) { if((ret < 0) && (ret != LIBSSH2_ERROR_EAGAIN)) {
state->start = 0; state->start = 0;
return ret; return ret;
} }
if (ret <= 0) { if(ret <= 0) {
long left = LIBSSH2_READ_TIMEOUT - long left = LIBSSH2_READ_TIMEOUT -
(long)(time(NULL) - state->start); (long)(time(NULL) - state->start);
if (left <= 0) { if(left <= 0) {
state->start = 0; state->start = 0;
return LIBSSH2_ERROR_TIMEOUT; return LIBSSH2_ERROR_TIMEOUT;
} }
else if (ret == LIBSSH2_ERROR_EAGAIN) { else if(ret == LIBSSH2_ERROR_EAGAIN) {
return ret; return ret;
} }
} }
if (strchr((char *) packet_types, ret)) { if(strchr((char *) packet_types, ret)) {
/* Be lazy, let packet_ask pull it out of the brigade */ /* Be lazy, let packet_ask pull it out of the brigade */
return _libssh2_packet_askv(session, packet_types, data, return _libssh2_packet_askv(session, packet_types, data,
data_len, match_ofs, match_buf, data_len, match_ofs, match_buf,

133
src/pem.c
View File

@@ -43,23 +43,23 @@ readline(char *line, int line_size, FILE * fp)
{ {
size_t len; size_t len;
if (!line) { if(!line) {
return -1; return -1;
} }
if (!fgets(line, line_size, fp)) { if(!fgets(line, line_size, fp)) {
return -1; return -1;
} }
if (*line) { if(*line) {
len = strlen(line); len = strlen(line);
if (len > 0 && line[len - 1] == '\n') { if(len > 0 && line[len - 1] == '\n') {
line[len - 1] = '\0'; line[len - 1] = '\0';
} }
} }
if (*line) { if(*line) {
len = strlen(line); len = strlen(line);
if (len > 0 && line[len - 1] == '\r') { if(len > 0 && line[len - 1] == '\r') {
line[len - 1] = '\0'; line[len - 1] = '\0';
} }
} }
@@ -76,14 +76,14 @@ readline_memory(char *line, size_t line_size,
off = *filedata_offset; off = *filedata_offset;
for (len = 0; off + len < filedata_len && len < line_size - 1; len++) { for(len = 0; off + len < filedata_len && len < line_size - 1; len++) {
if (filedata[off + len] == '\n' || if(filedata[off + len] == '\n' ||
filedata[off + len] == '\r') { filedata[off + len] == '\r') {
break; break;
} }
} }
if (len) { if(len) {
memcpy(line, filedata + off, len); memcpy(line, filedata + off, len);
*filedata_offset += len; *filedata_offset += len;
} }
@@ -120,62 +120,62 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
do { do {
*line = '\0'; *line = '\0';
if (readline(line, LINE_SIZE, fp)) { if(readline(line, LINE_SIZE, fp)) {
return -1; return -1;
} }
} }
while (strcmp(line, headerbegin) != 0); while(strcmp(line, headerbegin) != 0);
if (readline(line, LINE_SIZE, fp)) { if(readline(line, LINE_SIZE, fp)) {
return -1; return -1;
} }
if (passphrase && if(passphrase &&
memcmp(line, crypt_annotation, strlen(crypt_annotation)) == 0) { memcmp(line, crypt_annotation, strlen(crypt_annotation)) == 0) {
const LIBSSH2_CRYPT_METHOD **all_methods, *cur_method; const LIBSSH2_CRYPT_METHOD **all_methods, *cur_method;
int i; int i;
if (readline(line, LINE_SIZE, fp)) { if(readline(line, LINE_SIZE, fp)) {
ret = -1; ret = -1;
goto out; goto out;
} }
all_methods = libssh2_crypt_methods(); all_methods = libssh2_crypt_methods();
while ((cur_method = *all_methods++)) { while((cur_method = *all_methods++)) {
if (*cur_method->pem_annotation && if(*cur_method->pem_annotation &&
memcmp(line, cur_method->pem_annotation, memcmp(line, cur_method->pem_annotation,
strlen(cur_method->pem_annotation)) == 0) { strlen(cur_method->pem_annotation)) == 0) {
method = cur_method; method = cur_method;
memcpy(iv, line+strlen(method->pem_annotation)+1, memcpy(iv, line + strlen(method->pem_annotation) + 1,
2*method->iv_len); 2*method->iv_len);
} }
} }
/* None of the available crypt methods were able to decrypt the key */ /* None of the available crypt methods were able to decrypt the key */
if (method == NULL) if(method == NULL)
return -1; return -1;
/* Decode IV from hex */ /* Decode IV from hex */
for (i = 0; i < method->iv_len; ++i) { for(i = 0; i < method->iv_len; ++i) {
iv[i] = hex_decode(iv[2*i]) << 4; iv[i] = hex_decode(iv[2*i]) << 4;
iv[i] |= hex_decode(iv[2*i+1]); iv[i] |= hex_decode(iv[2*i + 1]);
} }
/* skip to the next line */ /* skip to the next line */
if (readline(line, LINE_SIZE, fp)) { if(readline(line, LINE_SIZE, fp)) {
ret = -1; ret = -1;
goto out; goto out;
} }
} }
do { do {
if (*line) { if(*line) {
char *tmp; char *tmp;
size_t linelen; size_t linelen;
linelen = strlen(line); linelen = strlen(line);
tmp = LIBSSH2_REALLOC(session, b64data, b64datalen + linelen); tmp = LIBSSH2_REALLOC(session, b64data, b64datalen + linelen);
if (!tmp) { if(!tmp) {
ret = -1; ret = -1;
goto out; goto out;
} }
@@ -186,23 +186,23 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
*line = '\0'; *line = '\0';
if (readline(line, LINE_SIZE, fp)) { if(readline(line, LINE_SIZE, fp)) {
ret = -1; ret = -1;
goto out; goto out;
} }
} while (strcmp(line, headerend) != 0); } while(strcmp(line, headerend) != 0);
if (!b64data) { if(!b64data) {
return -1; return -1;
} }
if (libssh2_base64_decode(session, (char**) data, datalen, if(libssh2_base64_decode(session, (char **) data, datalen,
b64data, b64datalen)) { b64data, b64datalen)) {
ret = -1; ret = -1;
goto out; goto out;
} }
if (method) { if(method) {
/* Set up decryption */ /* Set up decryption */
int free_iv = 0, free_secret = 0, len_decrypted = 0, padding = 0; int free_iv = 0, free_secret = 0, len_decrypted = 0, padding = 0;
int blocksize = method->blocksize; int blocksize = method->blocksize;
@@ -211,42 +211,42 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
libssh2_md5_ctx fingerprint_ctx; libssh2_md5_ctx fingerprint_ctx;
/* Perform key derivation (PBKDF1/MD5) */ /* Perform key derivation (PBKDF1/MD5) */
if (!libssh2_md5_init(&fingerprint_ctx)) { if(!libssh2_md5_init(&fingerprint_ctx)) {
ret = -1; ret = -1;
goto out; goto out;
} }
libssh2_md5_update(fingerprint_ctx, passphrase, libssh2_md5_update(fingerprint_ctx, passphrase,
strlen((char*)passphrase)); strlen((char *)passphrase));
libssh2_md5_update(fingerprint_ctx, iv, 8); libssh2_md5_update(fingerprint_ctx, iv, 8);
libssh2_md5_final(fingerprint_ctx, secret); libssh2_md5_final(fingerprint_ctx, secret);
if (method->secret_len > MD5_DIGEST_LENGTH) { if(method->secret_len > MD5_DIGEST_LENGTH) {
if (!libssh2_md5_init(&fingerprint_ctx)) { if(!libssh2_md5_init(&fingerprint_ctx)) {
ret = -1; ret = -1;
goto out; goto out;
} }
libssh2_md5_update(fingerprint_ctx, secret, MD5_DIGEST_LENGTH); libssh2_md5_update(fingerprint_ctx, secret, MD5_DIGEST_LENGTH);
libssh2_md5_update(fingerprint_ctx, passphrase, libssh2_md5_update(fingerprint_ctx, passphrase,
strlen((char*)passphrase)); strlen((char *)passphrase));
libssh2_md5_update(fingerprint_ctx, iv, 8); libssh2_md5_update(fingerprint_ctx, iv, 8);
libssh2_md5_final(fingerprint_ctx, secret + MD5_DIGEST_LENGTH); libssh2_md5_final(fingerprint_ctx, secret + MD5_DIGEST_LENGTH);
} }
/* Initialize the decryption */ /* Initialize the decryption */
if (method->init(session, method, iv, &free_iv, secret, if(method->init(session, method, iv, &free_iv, secret,
&free_secret, 0, &abstract)) { &free_secret, 0, &abstract)) {
memset((char*)secret, 0, sizeof(secret)); memset((char *)secret, 0, sizeof(secret));
LIBSSH2_FREE(session, data); LIBSSH2_FREE(session, data);
ret = -1; ret = -1;
goto out; goto out;
} }
if (free_secret) { if(free_secret) {
memset((char*)secret, 0, sizeof(secret)); memset((char *)secret, 0, sizeof(secret));
} }
/* Do the actual decryption */ /* Do the actual decryption */
if ((*datalen % blocksize) != 0) { if((*datalen % blocksize) != 0) {
memset((char*)secret, 0, sizeof(secret)); memset((char *)secret, 0, sizeof(secret));
method->dtor(session, &abstract); method->dtor(session, &abstract);
memset(*data, 0, *datalen); memset(*data, 0, *datalen);
LIBSSH2_FREE(session, *data); LIBSSH2_FREE(session, *data);
@@ -254,11 +254,11 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
goto out; goto out;
} }
while (len_decrypted <= *datalen - blocksize) { while(len_decrypted <= *datalen - blocksize) {
if (method->crypt(session, *data + len_decrypted, blocksize, if(method->crypt(session, *data + len_decrypted, blocksize,
&abstract)) { &abstract)) {
ret = LIBSSH2_ERROR_DECRYPT; ret = LIBSSH2_ERROR_DECRYPT;
memset((char*)secret, 0, sizeof(secret)); memset((char *)secret, 0, sizeof(secret));
method->dtor(session, &abstract); method->dtor(session, &abstract);
memset(*data, 0, *datalen); memset(*data, 0, *datalen);
LIBSSH2_FREE(session, *data); LIBSSH2_FREE(session, *data);
@@ -270,17 +270,17 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
/* Account for padding */ /* Account for padding */
padding = (*data)[*datalen - 1]; padding = (*data)[*datalen - 1];
memset(&(*data)[*datalen-padding],0,padding); memset(&(*data)[*datalen-padding], 0, padding);
*datalen -= padding; *datalen -= padding;
/* Clean up */ /* Clean up */
memset((char*)secret, 0, sizeof(secret)); memset((char *)secret, 0, sizeof(secret));
method->dtor(session, &abstract); method->dtor(session, &abstract);
} }
ret = 0; ret = 0;
out: out:
if (b64data) { if(b64data) {
LIBSSH2_FREE(session, b64data); LIBSSH2_FREE(session, b64data);
} }
return ret; return ret;
@@ -302,22 +302,22 @@ _libssh2_pem_parse_memory(LIBSSH2_SESSION * session,
do { do {
*line = '\0'; *line = '\0';
if (readline_memory(line, LINE_SIZE, filedata, filedata_len, &off)) { if(readline_memory(line, LINE_SIZE, filedata, filedata_len, &off)) {
return -1; return -1;
} }
} }
while (strcmp(line, headerbegin) != 0); while(strcmp(line, headerbegin) != 0);
*line = '\0'; *line = '\0';
do { do {
if (*line) { if(*line) {
char *tmp; char *tmp;
size_t linelen; size_t linelen;
linelen = strlen(line); linelen = strlen(line);
tmp = LIBSSH2_REALLOC(session, b64data, b64datalen + linelen); tmp = LIBSSH2_REALLOC(session, b64data, b64datalen + linelen);
if (!tmp) { if(!tmp) {
ret = -1; ret = -1;
goto out; goto out;
} }
@@ -328,17 +328,17 @@ _libssh2_pem_parse_memory(LIBSSH2_SESSION * session,
*line = '\0'; *line = '\0';
if (readline_memory(line, LINE_SIZE, filedata, filedata_len, &off)) { if(readline_memory(line, LINE_SIZE, filedata, filedata_len, &off)) {
ret = -1; ret = -1;
goto out; goto out;
} }
} while (strcmp(line, headerend) != 0); } while(strcmp(line, headerend) != 0);
if (!b64data) { if(!b64data) {
return -1; return -1;
} }
if (libssh2_base64_decode(session, (char**) data, datalen, if(libssh2_base64_decode(session, (char **) data, datalen,
b64data, b64datalen)) { b64data, b64datalen)) {
ret = -1; ret = -1;
goto out; goto out;
@@ -346,7 +346,7 @@ _libssh2_pem_parse_memory(LIBSSH2_SESSION * session,
ret = 0; ret = 0;
out: out:
if (b64data) { if(b64data) {
LIBSSH2_FREE(session, b64data); LIBSSH2_FREE(session, b64data);
} }
return ret; return ret;
@@ -359,27 +359,28 @@ read_asn1_length(const unsigned char *data,
unsigned int lenlen; unsigned int lenlen;
int nextpos; int nextpos;
if (datalen < 1) { if(datalen < 1) {
return -1; return -1;
} }
*len = data[0]; *len = data[0];
if (*len >= 0x80) { if(*len >= 0x80) {
lenlen = *len & 0x7F; lenlen = *len & 0x7F;
*len = data[1]; *len = data[1];
if (1 + lenlen > datalen) { if(1 + lenlen > datalen) {
return -1; return -1;
} }
if (lenlen > 1) { if(lenlen > 1) {
*len <<= 8; *len <<= 8;
*len |= data[2]; *len |= data[2];
} }
} else { }
else {
lenlen = 0; lenlen = 0;
} }
nextpos = 1 + lenlen; nextpos = 1 + lenlen;
if (lenlen > 2 || 1 + lenlen + *len > datalen) { if(lenlen > 2 || 1 + lenlen + *len > datalen) {
return -1; return -1;
} }
@@ -392,11 +393,11 @@ _libssh2_pem_decode_sequence(unsigned char **data, unsigned int *datalen)
unsigned int len; unsigned int len;
int lenlen; int lenlen;
if (*datalen < 1) { if(*datalen < 1) {
return -1; return -1;
} }
if ((*data)[0] != '\x30') { if((*data)[0] != '\x30') {
return -1; return -1;
} }
@@ -404,7 +405,7 @@ _libssh2_pem_decode_sequence(unsigned char **data, unsigned int *datalen)
(*datalen)--; (*datalen)--;
lenlen = read_asn1_length(*data, *datalen, &len); lenlen = read_asn1_length(*data, *datalen, &len);
if (lenlen < 0 || lenlen + len != *datalen) { if(lenlen < 0 || lenlen + len != *datalen) {
return -1; return -1;
} }
@@ -421,11 +422,11 @@ _libssh2_pem_decode_integer(unsigned char **data, unsigned int *datalen,
unsigned int len; unsigned int len;
int lenlen; int lenlen;
if (*datalen < 1) { if(*datalen < 1) {
return -1; return -1;
} }
if ((*data)[0] != '\x02') { if((*data)[0] != '\x02') {
return -1; return -1;
} }
@@ -433,7 +434,7 @@ _libssh2_pem_decode_integer(unsigned char **data, unsigned int *datalen,
(*datalen)--; (*datalen)--;
lenlen = read_asn1_length(*data, *datalen, &len); lenlen = read_asn1_length(*data, *datalen, &len);
if (lenlen < 0 || lenlen + len > *datalen) { if(lenlen < 0 || lenlen + len > *datalen) {
return -1; return -1;
} }

210
src/publickey.c
View File

@@ -60,7 +60,7 @@ static const LIBSSH2_PUBLICKEY_CODE_LIST publickey_response_codes[] =
{LIBSSH2_PUBLICKEY_RESPONSE_STATUS, "status", sizeof("status") - 1}, {LIBSSH2_PUBLICKEY_RESPONSE_STATUS, "status", sizeof("status") - 1},
{LIBSSH2_PUBLICKEY_RESPONSE_VERSION, "version", sizeof("version") - 1}, {LIBSSH2_PUBLICKEY_RESPONSE_VERSION, "version", sizeof("version") - 1},
{LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY, "publickey", {LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY, "publickey",
sizeof("publickey") - 1} , sizeof("publickey") - 1},
{0, NULL, 0} {0, NULL, 0}
}; };
@@ -78,13 +78,13 @@ static const LIBSSH2_PUBLICKEY_CODE_LIST publickey_response_codes[] =
#define LIBSSH2_PUBLICKEY_STATUS_CODE_MAX 8 #define LIBSSH2_PUBLICKEY_STATUS_CODE_MAX 8
static const LIBSSH2_PUBLICKEY_CODE_LIST publickey_status_codes[] = { static const LIBSSH2_PUBLICKEY_CODE_LIST publickey_status_codes[] = {
{LIBSSH2_PUBLICKEY_SUCCESS, "success", sizeof("success") - 1} , {LIBSSH2_PUBLICKEY_SUCCESS, "success", sizeof("success") - 1},
{LIBSSH2_PUBLICKEY_ACCESS_DENIED, "access denied", {LIBSSH2_PUBLICKEY_ACCESS_DENIED, "access denied",
sizeof("access denied") - 1}, sizeof("access denied") - 1},
{LIBSSH2_PUBLICKEY_STORAGE_EXCEEDED, "storage exceeded", {LIBSSH2_PUBLICKEY_STORAGE_EXCEEDED, "storage exceeded",
sizeof("storage exceeded") - 1} , sizeof("storage exceeded") - 1},
{LIBSSH2_PUBLICKEY_VERSION_NOT_SUPPORTED, "version not supported", {LIBSSH2_PUBLICKEY_VERSION_NOT_SUPPORTED, "version not supported",
sizeof("version not supported") - 1} , sizeof("version not supported") - 1},
{LIBSSH2_PUBLICKEY_KEY_NOT_FOUND, "key not found", {LIBSSH2_PUBLICKEY_KEY_NOT_FOUND, "key not found",
sizeof("key not found") - 1}, sizeof("key not found") - 1},
{LIBSSH2_PUBLICKEY_KEY_NOT_SUPPORTED, "key not supported", {LIBSSH2_PUBLICKEY_KEY_NOT_SUPPORTED, "key not supported",
@@ -110,13 +110,14 @@ publickey_status_error(const LIBSSH2_PUBLICKEY *pkey,
const char *msg; const char *msg;
/* GENERAL_FAILURE got remapped between version 1 and 2 */ /* GENERAL_FAILURE got remapped between version 1 and 2 */
if (status == 6 && pkey && pkey->version == 1) { if(status == 6 && pkey && pkey->version == 1) {
status = 7; status = 7;
} }
if (status < 0 || status > LIBSSH2_PUBLICKEY_STATUS_CODE_MAX) { if(status < 0 || status > LIBSSH2_PUBLICKEY_STATUS_CODE_MAX) {
msg = "unknown"; msg = "unknown";
} else { }
else {
msg = publickey_status_codes[status].name; msg = publickey_status_codes[status].name;
} }
@@ -139,11 +140,12 @@ publickey_packet_receive(LIBSSH2_PUBLICKEY * pkey,
*data = NULL; /* default to nothing returned */ *data = NULL; /* default to nothing returned */
*data_len = 0; *data_len = 0;
if (pkey->receive_state == libssh2_NB_state_idle) { if(pkey->receive_state == libssh2_NB_state_idle) {
rc = _libssh2_channel_read(channel, 0, (char *) buffer, 4); rc = _libssh2_channel_read(channel, 0, (char *) buffer, 4);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return rc; return rc;
} else if (rc != 4) { }
else if(rc != 4) {
return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
"Invalid response from publickey subsystem"); "Invalid response from publickey subsystem");
} }
@@ -151,7 +153,7 @@ publickey_packet_receive(LIBSSH2_PUBLICKEY * pkey,
pkey->receive_packet_len = _libssh2_ntohu32(buffer); pkey->receive_packet_len = _libssh2_ntohu32(buffer);
pkey->receive_packet = pkey->receive_packet =
LIBSSH2_ALLOC(session, pkey->receive_packet_len); LIBSSH2_ALLOC(session, pkey->receive_packet_len);
if (!pkey->receive_packet) { if(!pkey->receive_packet) {
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate publickey response " "Unable to allocate publickey response "
"buffer"); "buffer");
@@ -160,12 +162,13 @@ publickey_packet_receive(LIBSSH2_PUBLICKEY * pkey,
pkey->receive_state = libssh2_NB_state_sent; pkey->receive_state = libssh2_NB_state_sent;
} }
if (pkey->receive_state == libssh2_NB_state_sent) { if(pkey->receive_state == libssh2_NB_state_sent) {
rc = _libssh2_channel_read(channel, 0, (char *) pkey->receive_packet, rc = _libssh2_channel_read(channel, 0, (char *) pkey->receive_packet,
pkey->receive_packet_len); pkey->receive_packet_len);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return rc; return rc;
} else if (rc != (int)pkey->receive_packet_len) { }
else if(rc != (int)pkey->receive_packet_len) {
LIBSSH2_FREE(session, pkey->receive_packet); LIBSSH2_FREE(session, pkey->receive_packet);
pkey->receive_packet = NULL; pkey->receive_packet = NULL;
pkey->receive_state = libssh2_NB_state_idle; pkey->receive_state = libssh2_NB_state_idle;
@@ -195,20 +198,20 @@ publickey_response_id(unsigned char **pdata, size_t data_len)
unsigned char *data = *pdata; unsigned char *data = *pdata;
const LIBSSH2_PUBLICKEY_CODE_LIST *codes = publickey_response_codes; const LIBSSH2_PUBLICKEY_CODE_LIST *codes = publickey_response_codes;
if (data_len < 4) { if(data_len < 4) {
/* Malformed response */ /* Malformed response */
return -1; return -1;
} }
response_len = _libssh2_ntohu32(data); response_len = _libssh2_ntohu32(data);
data += 4; data += 4;
data_len -= 4; data_len -= 4;
if (data_len < response_len) { if(data_len < response_len) {
/* Malformed response */ /* Malformed response */
return -1; return -1;
} }
while (codes->name) { while(codes->name) {
if ((unsigned long)codes->name_len == response_len && if((unsigned long)codes->name_len == response_len &&
strncmp(codes->name, (char *) data, response_len) == 0) { strncmp(codes->name, (char *) data, response_len) == 0) {
*pdata = data + response_len; *pdata = data + response_len;
return codes->code; return codes->code;
@@ -231,11 +234,12 @@ publickey_response_success(LIBSSH2_PUBLICKEY * pkey)
size_t data_len; size_t data_len;
int response; int response;
while (1) { while(1) {
int rc = publickey_packet_receive(pkey, &data, &data_len); int rc = publickey_packet_receive(pkey, &data, &data_len);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return rc; return rc;
} else if (rc) { }
else if(rc) {
return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT,
"Timeout waiting for response from " "Timeout waiting for response from "
"publickey subsystem"); "publickey subsystem");
@@ -244,7 +248,7 @@ publickey_response_success(LIBSSH2_PUBLICKEY * pkey)
s = data; s = data;
response = publickey_response_id(&s, data_len); response = publickey_response_id(&s, data_len);
switch (response) { switch(response) {
case LIBSSH2_PUBLICKEY_RESPONSE_STATUS: case LIBSSH2_PUBLICKEY_RESPONSE_STATUS:
/* Error, or processing complete */ /* Error, or processing complete */
{ {
@@ -252,7 +256,7 @@ publickey_response_success(LIBSSH2_PUBLICKEY * pkey)
LIBSSH2_FREE(session, data); LIBSSH2_FREE(session, data);
if (status == LIBSSH2_PUBLICKEY_SUCCESS) if(status == LIBSSH2_PUBLICKEY_SUCCESS)
return 0; return 0;
publickey_status_error(pkey, session, status); publickey_status_error(pkey, session, status);
@@ -260,7 +264,7 @@ publickey_response_success(LIBSSH2_PUBLICKEY * pkey)
} }
default: default:
LIBSSH2_FREE(session, data); LIBSSH2_FREE(session, data);
if (response < 0) { if(response < 0) {
return _libssh2_error(session, return _libssh2_error(session,
LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
"Invalid publickey subsystem response"); "Invalid publickey subsystem response");
@@ -289,7 +293,7 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
int response; int response;
int rc; int rc;
if (session->pkeyInit_state == libssh2_NB_state_idle) { if(session->pkeyInit_state == libssh2_NB_state_idle) {
session->pkeyInit_data = NULL; session->pkeyInit_data = NULL;
session->pkeyInit_pkey = NULL; session->pkeyInit_pkey = NULL;
session->pkeyInit_channel = NULL; session->pkeyInit_channel = NULL;
@@ -300,7 +304,7 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
session->pkeyInit_state = libssh2_NB_state_allocated; session->pkeyInit_state = libssh2_NB_state_allocated;
} }
if (session->pkeyInit_state == libssh2_NB_state_allocated) { if(session->pkeyInit_state == libssh2_NB_state_allocated) {
session->pkeyInit_channel = session->pkeyInit_channel =
_libssh2_channel_open(session, "session", _libssh2_channel_open(session, "session",
@@ -308,8 +312,8 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
LIBSSH2_CHANNEL_WINDOW_DEFAULT, LIBSSH2_CHANNEL_WINDOW_DEFAULT,
LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL,
0); 0);
if (!session->pkeyInit_channel) { if(!session->pkeyInit_channel) {
if (libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN) if(libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN)
/* The error state is already set, so leave it */ /* The error state is already set, so leave it */
return NULL; return NULL;
_libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE, _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
@@ -320,17 +324,18 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
session->pkeyInit_state = libssh2_NB_state_sent; session->pkeyInit_state = libssh2_NB_state_sent;
} }
if (session->pkeyInit_state == libssh2_NB_state_sent) { if(session->pkeyInit_state == libssh2_NB_state_sent) {
rc = _libssh2_channel_process_startup(session->pkeyInit_channel, rc = _libssh2_channel_process_startup(session->pkeyInit_channel,
"subsystem", "subsystem",
sizeof("subsystem") - 1, sizeof("subsystem") - 1,
"publickey", "publickey",
sizeof("publickey") - 1); sizeof("publickey") - 1);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block starting publickey subsystem"); "Would block starting publickey subsystem");
return NULL; return NULL;
} else if (rc) { }
else if(rc) {
_libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE, _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
"Unable to request publickey subsystem"); "Unable to request publickey subsystem");
goto err_exit; goto err_exit;
@@ -339,11 +344,11 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
session->pkeyInit_state = libssh2_NB_state_sent1; session->pkeyInit_state = libssh2_NB_state_sent1;
} }
if (session->pkeyInit_state == libssh2_NB_state_sent1) { if(session->pkeyInit_state == libssh2_NB_state_sent1) {
unsigned char *s; unsigned char *s;
rc = _libssh2_channel_extended_data(session->pkeyInit_channel, rc = _libssh2_channel_extended_data(session->pkeyInit_channel,
LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE); LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block starting publickey subsystem"); "Would block starting publickey subsystem");
return NULL; return NULL;
@@ -351,7 +356,7 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
session->pkeyInit_pkey = session->pkeyInit_pkey =
LIBSSH2_CALLOC(session, sizeof(LIBSSH2_PUBLICKEY)); LIBSSH2_CALLOC(session, sizeof(LIBSSH2_PUBLICKEY));
if (!session->pkeyInit_pkey) { if(!session->pkeyInit_pkey) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate a new publickey structure"); "Unable to allocate a new publickey structure");
goto err_exit; goto err_exit;
@@ -377,15 +382,16 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
session->pkeyInit_state = libssh2_NB_state_sent2; session->pkeyInit_state = libssh2_NB_state_sent2;
} }
if (session->pkeyInit_state == libssh2_NB_state_sent2) { if(session->pkeyInit_state == libssh2_NB_state_sent2) {
rc = _libssh2_channel_write(session->pkeyInit_channel, 0, rc = _libssh2_channel_write(session->pkeyInit_channel, 0,
session->pkeyInit_buffer, session->pkeyInit_buffer,
19 - session->pkeyInit_buffer_sent); 19 - session->pkeyInit_buffer_sent);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block sending publickey version packet"); "Would block sending publickey version packet");
return NULL; return NULL;
} else if (rc < 0) { }
else if(rc < 0) {
_libssh2_error(session, rc, _libssh2_error(session, rc,
"Unable to send publickey version packet"); "Unable to send publickey version packet");
goto err_exit; goto err_exit;
@@ -400,18 +406,19 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
session->pkeyInit_state = libssh2_NB_state_sent3; session->pkeyInit_state = libssh2_NB_state_sent3;
} }
if (session->pkeyInit_state == libssh2_NB_state_sent3) { if(session->pkeyInit_state == libssh2_NB_state_sent3) {
while (1) { while(1) {
unsigned char *s; unsigned char *s;
rc = publickey_packet_receive(session->pkeyInit_pkey, rc = publickey_packet_receive(session->pkeyInit_pkey,
&session->pkeyInit_data, &session->pkeyInit_data,
&session->pkeyInit_data_len); &session->pkeyInit_data_len);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block waiting for response from " "Would block waiting for response from "
"publickey subsystem"); "publickey subsystem");
return NULL; return NULL;
} else if (rc) { }
else if(rc) {
_libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, _libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT,
"Timeout waiting for response from " "Timeout waiting for response from "
"publickey subsystem"); "publickey subsystem");
@@ -419,14 +426,14 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
} }
s = session->pkeyInit_data; s = session->pkeyInit_data;
if ((response = if((response =
publickey_response_id(&s, session->pkeyInit_data_len)) < 0) { publickey_response_id(&s, session->pkeyInit_data_len)) < 0) {
_libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
"Invalid publickey subsystem response code"); "Invalid publickey subsystem response code");
goto err_exit; goto err_exit;
} }
switch (response) { switch(response) {
case LIBSSH2_PUBLICKEY_RESPONSE_STATUS: case LIBSSH2_PUBLICKEY_RESPONSE_STATUS:
/* Error */ /* Error */
{ {
@@ -443,7 +450,7 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
/* lang starts here */ /* lang starts here */
s += lang_len; s += lang_len;
if (s > if(s >
session->pkeyInit_data + session->pkeyInit_data_len) { session->pkeyInit_data + session->pkeyInit_data_len) {
_libssh2_error(session, _libssh2_error(session,
LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
@@ -459,7 +466,7 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
case LIBSSH2_PUBLICKEY_RESPONSE_VERSION: case LIBSSH2_PUBLICKEY_RESPONSE_VERSION:
/* What we want */ /* What we want */
session->pkeyInit_pkey->version = _libssh2_ntohu32(s); session->pkeyInit_pkey->version = _libssh2_ntohu32(s);
if (session->pkeyInit_pkey->version > if(session->pkeyInit_pkey->version >
LIBSSH2_PUBLICKEY_VERSION) { LIBSSH2_PUBLICKEY_VERSION) {
_libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY, _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
"Truncate remote publickey version from %lu", "Truncate remote publickey version from %lu",
@@ -489,19 +496,19 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
/* Never reached except by direct goto */ /* Never reached except by direct goto */
err_exit: err_exit:
session->pkeyInit_state = libssh2_NB_state_sent4; session->pkeyInit_state = libssh2_NB_state_sent4;
if (session->pkeyInit_channel) { if(session->pkeyInit_channel) {
rc = _libssh2_channel_close(session->pkeyInit_channel); rc = _libssh2_channel_close(session->pkeyInit_channel);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block closing channel"); "Would block closing channel");
return NULL; return NULL;
} }
} }
if (session->pkeyInit_pkey) { if(session->pkeyInit_pkey) {
LIBSSH2_FREE(session, session->pkeyInit_pkey); LIBSSH2_FREE(session, session->pkeyInit_pkey);
session->pkeyInit_pkey = NULL; session->pkeyInit_pkey = NULL;
} }
if (session->pkeyInit_data) { if(session->pkeyInit_data) {
LIBSSH2_FREE(session, session->pkeyInit_data); LIBSSH2_FREE(session, session->pkeyInit_data);
session->pkeyInit_data = NULL; session->pkeyInit_data = NULL;
} }
@@ -553,16 +560,16 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
channel = pkey->channel; channel = pkey->channel;
session = channel->session; session = channel->session;
if (pkey->add_state == libssh2_NB_state_idle) { if(pkey->add_state == libssh2_NB_state_idle) {
pkey->add_packet = NULL; pkey->add_packet = NULL;
_libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY, "Adding %s publickey", _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY, "Adding %s publickey",
name); name);
if (pkey->version == 1) { if(pkey->version == 1) {
for(i = 0; i < num_attrs; i++) { for(i = 0; i < num_attrs; i++) {
/* Search for a comment attribute */ /* Search for a comment attribute */
if (attrs[i].name_len == (sizeof("comment") - 1) && if(attrs[i].name_len == (sizeof("comment") - 1) &&
strncmp(attrs[i].name, "comment", strncmp(attrs[i].name, "comment",
sizeof("comment") - 1) == 0) { sizeof("comment") - 1) == 0) {
comment = (unsigned char *) attrs[i].value; comment = (unsigned char *) attrs[i].value;
@@ -571,7 +578,8 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
} }
} }
packet_len += 4 + comment_len; packet_len += 4 + comment_len;
} else { }
else {
packet_len += 5; /* overwrite(1) + attribute_count(4) */ packet_len += 5; /* overwrite(1) + attribute_count(4) */
for(i = 0; i < num_attrs; i++) { for(i = 0; i < num_attrs; i++) {
packet_len += 9 + attrs[i].name_len + attrs[i].value_len; packet_len += 9 + attrs[i].name_len + attrs[i].value_len;
@@ -580,7 +588,7 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
} }
pkey->add_packet = LIBSSH2_ALLOC(session, packet_len); pkey->add_packet = LIBSSH2_ALLOC(session, packet_len);
if (!pkey->add_packet) { if(!pkey->add_packet) {
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for " "Unable to allocate memory for "
"publickey \"add\" packet"); "publickey \"add\" packet");
@@ -593,10 +601,10 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
pkey->add_s += 4; pkey->add_s += 4;
memcpy(pkey->add_s, "add", sizeof("add") - 1); memcpy(pkey->add_s, "add", sizeof("add") - 1);
pkey->add_s += sizeof("add") - 1; pkey->add_s += sizeof("add") - 1;
if (pkey->version == 1) { if(pkey->version == 1) {
_libssh2_htonu32(pkey->add_s, comment_len); _libssh2_htonu32(pkey->add_s, comment_len);
pkey->add_s += 4; pkey->add_s += 4;
if (comment) { if(comment) {
memcpy(pkey->add_s, comment, comment_len); memcpy(pkey->add_s, comment, comment_len);
pkey->add_s += comment_len; pkey->add_s += comment_len;
} }
@@ -609,7 +617,8 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
pkey->add_s += 4; pkey->add_s += 4;
memcpy(pkey->add_s, blob, blob_len); memcpy(pkey->add_s, blob, blob_len);
pkey->add_s += blob_len; pkey->add_s += blob_len;
} else { }
else {
/* Version == 2 */ /* Version == 2 */
_libssh2_htonu32(pkey->add_s, name_len); _libssh2_htonu32(pkey->add_s, name_len);
@@ -644,12 +653,13 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
pkey->add_state = libssh2_NB_state_created; pkey->add_state = libssh2_NB_state_created;
} }
if (pkey->add_state == libssh2_NB_state_created) { if(pkey->add_state == libssh2_NB_state_created) {
rc = _libssh2_channel_write(channel, 0, pkey->add_packet, rc = _libssh2_channel_write(channel, 0, pkey->add_packet,
(pkey->add_s - pkey->add_packet)); (pkey->add_s - pkey->add_packet));
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return rc; return rc;
} else if ((pkey->add_s - pkey->add_packet) != rc) { }
else if((pkey->add_s - pkey->add_packet) != rc) {
LIBSSH2_FREE(session, pkey->add_packet); LIBSSH2_FREE(session, pkey->add_packet);
pkey->add_packet = NULL; pkey->add_packet = NULL;
return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
@@ -662,7 +672,7 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
} }
rc = publickey_response_success(pkey); rc = publickey_response_success(pkey);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return rc; return rc;
} }
@@ -693,11 +703,11 @@ libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY * pkey,
channel = pkey->channel; channel = pkey->channel;
session = channel->session; session = channel->session;
if (pkey->remove_state == libssh2_NB_state_idle) { if(pkey->remove_state == libssh2_NB_state_idle) {
pkey->remove_packet = NULL; pkey->remove_packet = NULL;
pkey->remove_packet = LIBSSH2_ALLOC(session, packet_len); pkey->remove_packet = LIBSSH2_ALLOC(session, packet_len);
if (!pkey->remove_packet) { if(!pkey->remove_packet) {
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for " "Unable to allocate memory for "
"publickey \"remove\" packet"); "publickey \"remove\" packet");
@@ -727,12 +737,13 @@ libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY * pkey,
pkey->remove_state = libssh2_NB_state_created; pkey->remove_state = libssh2_NB_state_created;
} }
if (pkey->remove_state == libssh2_NB_state_created) { if(pkey->remove_state == libssh2_NB_state_created) {
rc = _libssh2_channel_write(channel, 0, pkey->remove_packet, rc = _libssh2_channel_write(channel, 0, pkey->remove_packet,
(pkey->remove_s - pkey->remove_packet)); (pkey->remove_s - pkey->remove_packet));
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return rc; return rc;
} else if ((pkey->remove_s - pkey->remove_packet) != rc) { }
else if((pkey->remove_s - pkey->remove_packet) != rc) {
LIBSSH2_FREE(session, pkey->remove_packet); LIBSSH2_FREE(session, pkey->remove_packet);
pkey->remove_packet = NULL; pkey->remove_packet = NULL;
pkey->remove_state = libssh2_NB_state_idle; pkey->remove_state = libssh2_NB_state_idle;
@@ -746,7 +757,7 @@ libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY * pkey,
} }
rc = publickey_response_success(pkey); rc = publickey_response_success(pkey);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return rc; return rc;
} }
@@ -776,7 +787,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
channel = pkey->channel; channel = pkey->channel;
session = channel->session; session = channel->session;
if (pkey->listFetch_state == libssh2_NB_state_idle) { if(pkey->listFetch_state == libssh2_NB_state_idle) {
pkey->listFetch_data = NULL; pkey->listFetch_data = NULL;
pkey->listFetch_s = pkey->listFetch_buffer; pkey->listFetch_s = pkey->listFetch_buffer;
@@ -793,14 +804,15 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
pkey->listFetch_state = libssh2_NB_state_created; pkey->listFetch_state = libssh2_NB_state_created;
} }
if (pkey->listFetch_state == libssh2_NB_state_created) { if(pkey->listFetch_state == libssh2_NB_state_created) {
rc = _libssh2_channel_write(channel, 0, rc = _libssh2_channel_write(channel, 0,
pkey->listFetch_buffer, pkey->listFetch_buffer,
(pkey->listFetch_s - (pkey->listFetch_s -
pkey->listFetch_buffer)); pkey->listFetch_buffer));
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return rc; return rc;
} else if ((pkey->listFetch_s - pkey->listFetch_buffer) != rc) { }
else if((pkey->listFetch_s - pkey->listFetch_buffer) != rc) {
pkey->listFetch_state = libssh2_NB_state_idle; pkey->listFetch_state = libssh2_NB_state_idle;
return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
"Unable to send publickey list packet"); "Unable to send publickey list packet");
@@ -809,12 +821,13 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
pkey->listFetch_state = libssh2_NB_state_sent; pkey->listFetch_state = libssh2_NB_state_sent;
} }
while (1) { while(1) {
rc = publickey_packet_receive(pkey, &pkey->listFetch_data, rc = publickey_packet_receive(pkey, &pkey->listFetch_data,
&pkey->listFetch_data_len); &pkey->listFetch_data_len);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return rc; return rc;
} else if (rc) { }
else if(rc) {
_libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, _libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT,
"Timeout waiting for response from " "Timeout waiting for response from "
"publickey subsystem"); "publickey subsystem");
@@ -822,7 +835,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
} }
pkey->listFetch_s = pkey->listFetch_data; pkey->listFetch_s = pkey->listFetch_data;
if ((response = if((response =
publickey_response_id(&pkey->listFetch_s, publickey_response_id(&pkey->listFetch_s,
pkey->listFetch_data_len)) < 0) { pkey->listFetch_data_len)) < 0) {
_libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
@@ -830,7 +843,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
goto err_exit; goto err_exit;
} }
switch (response) { switch(response) {
case LIBSSH2_PUBLICKEY_RESPONSE_STATUS: case LIBSSH2_PUBLICKEY_RESPONSE_STATUS:
/* Error, or processing complete */ /* Error, or processing complete */
{ {
@@ -847,14 +860,14 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
/* lang starts at pkey->listFetch_s */ /* lang starts at pkey->listFetch_s */
pkey->listFetch_s += lang_len; pkey->listFetch_s += lang_len;
if (pkey->listFetch_s > if(pkey->listFetch_s >
pkey->listFetch_data + pkey->listFetch_data_len) { pkey->listFetch_data + pkey->listFetch_data_len) {
_libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
"Malformed publickey subsystem packet"); "Malformed publickey subsystem packet");
goto err_exit; goto err_exit;
} }
if (status == LIBSSH2_PUBLICKEY_SUCCESS) { if(status == LIBSSH2_PUBLICKEY_SUCCESS) {
LIBSSH2_FREE(session, pkey->listFetch_data); LIBSSH2_FREE(session, pkey->listFetch_data);
pkey->listFetch_data = NULL; pkey->listFetch_data = NULL;
*pkey_list = list; *pkey_list = list;
@@ -868,7 +881,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
} }
case LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY: case LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY:
/* What we want */ /* What we want */
if (keys >= max_keys) { if(keys >= max_keys) {
libssh2_publickey_list *newlist; libssh2_publickey_list *newlist;
/* Grow the key list if necessary */ /* Grow the key list if necessary */
max_keys += 8; max_keys += 8;
@@ -876,7 +889,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
LIBSSH2_REALLOC(session, list, LIBSSH2_REALLOC(session, list,
(max_keys + (max_keys +
1) * sizeof(libssh2_publickey_list)); 1) * sizeof(libssh2_publickey_list));
if (!newlist) { if(!newlist) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for " "Unable to allocate memory for "
"publickey list"); "publickey list");
@@ -884,17 +897,17 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
} }
list = newlist; list = newlist;
} }
if (pkey->version == 1) { if(pkey->version == 1) {
unsigned long comment_len; unsigned long comment_len;
comment_len = _libssh2_ntohu32(pkey->listFetch_s); comment_len = _libssh2_ntohu32(pkey->listFetch_s);
pkey->listFetch_s += 4; pkey->listFetch_s += 4;
if (comment_len) { if(comment_len) {
list[keys].num_attrs = 1; list[keys].num_attrs = 1;
list[keys].attrs = list[keys].attrs =
LIBSSH2_ALLOC(session, LIBSSH2_ALLOC(session,
sizeof(libssh2_publickey_attribute)); sizeof(libssh2_publickey_attribute));
if (!list[keys].attrs) { if(!list[keys].attrs) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for " "Unable to allocate memory for "
"publickey attributes"); "publickey attributes");
@@ -907,7 +920,8 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
list[keys].attrs[0].mandatory = 0; list[keys].attrs[0].mandatory = 0;
pkey->listFetch_s += comment_len; pkey->listFetch_s += comment_len;
} else { }
else {
list[keys].num_attrs = 0; list[keys].num_attrs = 0;
list[keys].attrs = NULL; list[keys].attrs = NULL;
} }
@@ -919,7 +933,8 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
pkey->listFetch_s += 4; pkey->listFetch_s += 4;
list[keys].blob = pkey->listFetch_s; list[keys].blob = pkey->listFetch_s;
pkey->listFetch_s += list[keys].blob_len; pkey->listFetch_s += list[keys].blob_len;
} else { }
else {
/* Version == 2 */ /* Version == 2 */
list[keys].name_len = _libssh2_ntohu32(pkey->listFetch_s); list[keys].name_len = _libssh2_ntohu32(pkey->listFetch_s);
pkey->listFetch_s += 4; pkey->listFetch_s += 4;
@@ -931,12 +946,12 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
pkey->listFetch_s += list[keys].blob_len; pkey->listFetch_s += list[keys].blob_len;
list[keys].num_attrs = _libssh2_ntohu32(pkey->listFetch_s); list[keys].num_attrs = _libssh2_ntohu32(pkey->listFetch_s);
pkey->listFetch_s += 4; pkey->listFetch_s += 4;
if (list[keys].num_attrs) { if(list[keys].num_attrs) {
list[keys].attrs = list[keys].attrs =
LIBSSH2_ALLOC(session, LIBSSH2_ALLOC(session,
list[keys].num_attrs * list[keys].num_attrs *
sizeof(libssh2_publickey_attribute)); sizeof(libssh2_publickey_attribute));
if (!list[keys].attrs) { if(!list[keys].attrs) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for " "Unable to allocate memory for "
"publickey attributes"); "publickey attributes");
@@ -957,7 +972,8 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
/* actually an ignored value */ /* actually an ignored value */
list[keys].attrs[i].mandatory = 0; list[keys].attrs[i].mandatory = 0;
} }
} else { }
else {
list[keys].attrs = NULL; list[keys].attrs = NULL;
} }
} }
@@ -979,11 +995,11 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
/* Only reached via explicit goto */ /* Only reached via explicit goto */
err_exit: err_exit:
if (pkey->listFetch_data) { if(pkey->listFetch_data) {
LIBSSH2_FREE(session, pkey->listFetch_data); LIBSSH2_FREE(session, pkey->listFetch_data);
pkey->listFetch_data = NULL; pkey->listFetch_data = NULL;
} }
if (list) { if(list) {
libssh2_publickey_list_free(pkey, list); libssh2_publickey_list_free(pkey, list);
} }
pkey->listFetch_state = libssh2_NB_state_idle; pkey->listFetch_state = libssh2_NB_state_idle;
@@ -1005,8 +1021,8 @@ libssh2_publickey_list_free(LIBSSH2_PUBLICKEY * pkey,
session = pkey->channel->session; session = pkey->channel->session;
while (p->packet) { while(p->packet) {
if (p->attrs) { if(p->attrs) {
LIBSSH2_FREE(session, p->attrs); LIBSSH2_FREE(session, p->attrs);
} }
LIBSSH2_FREE(session, p->packet); LIBSSH2_FREE(session, p->packet);
@@ -1033,25 +1049,25 @@ libssh2_publickey_shutdown(LIBSSH2_PUBLICKEY *pkey)
/* /*
* Make sure all memory used in the state variables are free * Make sure all memory used in the state variables are free
*/ */
if (pkey->receive_packet) { if(pkey->receive_packet) {
LIBSSH2_FREE(session, pkey->receive_packet); LIBSSH2_FREE(session, pkey->receive_packet);
pkey->receive_packet = NULL; pkey->receive_packet = NULL;
} }
if (pkey->add_packet) { if(pkey->add_packet) {
LIBSSH2_FREE(session, pkey->add_packet); LIBSSH2_FREE(session, pkey->add_packet);
pkey->add_packet = NULL; pkey->add_packet = NULL;
} }
if (pkey->remove_packet) { if(pkey->remove_packet) {
LIBSSH2_FREE(session, pkey->remove_packet); LIBSSH2_FREE(session, pkey->remove_packet);
pkey->remove_packet = NULL; pkey->remove_packet = NULL;
} }
if (pkey->listFetch_data) { if(pkey->listFetch_data) {
LIBSSH2_FREE(session, pkey->listFetch_data); LIBSSH2_FREE(session, pkey->listFetch_data);
pkey->listFetch_data = NULL; pkey->listFetch_data = NULL;
} }
rc = _libssh2_channel_free(pkey->channel); rc = _libssh2_channel_free(pkey->channel);
if (rc == LIBSSH2_ERROR_EAGAIN) if(rc == LIBSSH2_ERROR_EAGAIN)
return rc; return rc;
LIBSSH2_FREE(session, pkey); LIBSSH2_FREE(session, pkey);

223
src/scp.c
View File

@@ -141,9 +141,9 @@ shell_quotearg(const char *path, unsigned char *buf,
endp = &buf[bufsize]; endp = &buf[bufsize];
src = path; src = path;
dst = buf; dst = buf;
while (*src && dst < endp - 1) { while(*src && dst < endp - 1) {
switch (*src) { switch(*src) {
/* /*
* Special handling for apostrophe. * Special handling for apostrophe.
* An apostrophe is always written in quotation marks, e.g. * An apostrophe is always written in quotation marks, e.g.
@@ -151,16 +151,16 @@ shell_quotearg(const char *path, unsigned char *buf,
*/ */
case '\'': case '\'':
switch (state) { switch(state) {
case UQSTRING: /* Unquoted string */ case UQSTRING: /* Unquoted string */
if (dst+1 >= endp) if(dst + 1 >= endp)
return 0; return 0;
*dst++ = '"'; *dst++ = '"';
break; break;
case QSTRING: /* Continue quoted string */ case QSTRING: /* Continue quoted string */
break; break;
case SQSTRING: /* Close single quoted string */ case SQSTRING: /* Close single quoted string */
if (dst+2 >= endp) if(dst + 2 >= endp)
return 0; return 0;
*dst++ = '\''; *dst++ = '\'';
*dst++ = '"'; *dst++ = '"';
@@ -179,20 +179,20 @@ shell_quotearg(const char *path, unsigned char *buf,
*/ */
case '!': case '!':
switch (state) { switch(state) {
case UQSTRING: case UQSTRING:
if (dst+1 >= endp) if(dst + 1 >= endp)
return 0; return 0;
*dst++ = '\\'; *dst++ = '\\';
break; break;
case QSTRING: case QSTRING:
if (dst+2 >= endp) if(dst + 2 >= endp)
return 0; return 0;
*dst++ = '"'; /* Closing quotation mark */ *dst++ = '"'; /* Closing quotation mark */
*dst++ = '\\'; *dst++ = '\\';
break; break;
case SQSTRING: /* Close single quoted string */ case SQSTRING: /* Close single quoted string */
if (dst+2 >= endp) if(dst + 2 >= endp)
return 0; return 0;
*dst++ = '\''; *dst++ = '\'';
*dst++ = '\\'; *dst++ = '\\';
@@ -208,14 +208,14 @@ shell_quotearg(const char *path, unsigned char *buf,
*/ */
default: default:
switch (state) { switch(state) {
case UQSTRING: case UQSTRING:
if (dst+1 >= endp) if(dst + 1 >= endp)
return 0; return 0;
*dst++ = '\''; *dst++ = '\'';
break; break;
case QSTRING: case QSTRING:
if (dst+2 >= endp) if(dst + 2 >= endp)
return 0; return 0;
*dst++ = '"'; /* Closing quotation mark */ *dst++ = '"'; /* Closing quotation mark */
*dst++ = '\''; *dst++ = '\'';
@@ -229,21 +229,21 @@ shell_quotearg(const char *path, unsigned char *buf,
break; break;
} }
if (dst+1 >= endp) if(dst + 1 >= endp)
return 0; return 0;
*dst++ = *src++; *dst++ = *src++;
} }
switch (state) { switch(state) {
case UQSTRING: case UQSTRING:
break; break;
case QSTRING: /* Close quoted string */ case QSTRING: /* Close quoted string */
if (dst+1 >= endp) if(dst + 1 >= endp)
return 0; return 0;
*dst++ = '"'; *dst++ = '"';
break; break;
case SQSTRING: /* Close single quoted string */ case SQSTRING: /* Close single quoted string */
if (dst+1 >= endp) if(dst + 1 >= endp)
return 0; return 0;
*dst++ = '\''; *dst++ = '\'';
break; break;
@@ -251,7 +251,7 @@ shell_quotearg(const char *path, unsigned char *buf,
break; break;
} }
if (dst+1 >= endp) if(dst + 1 >= endp)
return 0; return 0;
*dst = '\0'; *dst = '\0';
@@ -275,7 +275,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
int tmp_err_code; int tmp_err_code;
const char *tmp_err_msg; const char *tmp_err_msg;
if (session->scpRecv_state == libssh2_NB_state_idle) { if(session->scpRecv_state == libssh2_NB_state_idle) {
session->scpRecv_mode = 0; session->scpRecv_mode = 0;
session->scpRecv_size = 0; session->scpRecv_size = 0;
session->scpRecv_mtime = 0; session->scpRecv_mtime = 0;
@@ -287,7 +287,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
session->scpRecv_command = session->scpRecv_command =
LIBSSH2_ALLOC(session, session->scpRecv_command_len); LIBSSH2_ALLOC(session, session->scpRecv_command_len);
if (!session->scpRecv_command) { if(!session->scpRecv_command) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate a command buffer for " "Unable to allocate a command buffer for "
"SCP session"); "SCP session");
@@ -312,7 +312,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
session->scpRecv_state = libssh2_NB_state_created; session->scpRecv_state = libssh2_NB_state_created;
} }
if (session->scpRecv_state == libssh2_NB_state_created) { if(session->scpRecv_state == libssh2_NB_state_created) {
/* Allocate a channel */ /* Allocate a channel */
session->scpRecv_channel = session->scpRecv_channel =
_libssh2_channel_open(session, "session", _libssh2_channel_open(session, "session",
@@ -320,8 +320,8 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
LIBSSH2_CHANNEL_WINDOW_DEFAULT, LIBSSH2_CHANNEL_WINDOW_DEFAULT,
LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL,
0); 0);
if (!session->scpRecv_channel) { if(!session->scpRecv_channel) {
if (libssh2_session_last_errno(session) != if(libssh2_session_last_errno(session) !=
LIBSSH2_ERROR_EAGAIN) { LIBSSH2_ERROR_EAGAIN) {
LIBSSH2_FREE(session, session->scpRecv_command); LIBSSH2_FREE(session, session->scpRecv_command);
session->scpRecv_command = NULL; session->scpRecv_command = NULL;
@@ -337,17 +337,18 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
session->scpRecv_state = libssh2_NB_state_sent; session->scpRecv_state = libssh2_NB_state_sent;
} }
if (session->scpRecv_state == libssh2_NB_state_sent) { if(session->scpRecv_state == libssh2_NB_state_sent) {
/* Request SCP for the desired file */ /* Request SCP for the desired file */
rc = _libssh2_channel_process_startup(session->scpRecv_channel, "exec", rc = _libssh2_channel_process_startup(session->scpRecv_channel, "exec",
sizeof("exec") - 1, sizeof("exec") - 1,
(char *) session->scpRecv_command, (char *) session->scpRecv_command,
session->scpRecv_command_len); session->scpRecv_command_len);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block requesting SCP startup"); "Would block requesting SCP startup");
return NULL; return NULL;
} else if (rc) { }
else if(rc) {
LIBSSH2_FREE(session, session->scpRecv_command); LIBSSH2_FREE(session, session->scpRecv_command);
session->scpRecv_command = NULL; session->scpRecv_command = NULL;
goto scp_recv_error; goto scp_recv_error;
@@ -362,14 +363,15 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
session->scpRecv_state = libssh2_NB_state_sent1; session->scpRecv_state = libssh2_NB_state_sent1;
} }
if (session->scpRecv_state == libssh2_NB_state_sent1) { if(session->scpRecv_state == libssh2_NB_state_sent1) {
rc = _libssh2_channel_write(session->scpRecv_channel, 0, rc = _libssh2_channel_write(session->scpRecv_channel, 0,
session->scpRecv_response, 1); session->scpRecv_response, 1);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block sending initial wakeup"); "Would block sending initial wakeup");
return NULL; return NULL;
} else if (rc != 1) { }
else if(rc != 1) {
goto scp_recv_error; goto scp_recv_error;
} }
@@ -379,23 +381,23 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
session->scpRecv_state = libssh2_NB_state_sent2; session->scpRecv_state = libssh2_NB_state_sent2;
} }
if ((session->scpRecv_state == libssh2_NB_state_sent2) if((session->scpRecv_state == libssh2_NB_state_sent2)
|| (session->scpRecv_state == libssh2_NB_state_sent3)) { || (session->scpRecv_state == libssh2_NB_state_sent3)) {
while (sb && (session->scpRecv_response_len < while(sb && (session->scpRecv_response_len <
LIBSSH2_SCP_RESPONSE_BUFLEN)) { LIBSSH2_SCP_RESPONSE_BUFLEN)) {
unsigned char *s, *p; unsigned char *s, *p;
if (session->scpRecv_state == libssh2_NB_state_sent2) { if(session->scpRecv_state == libssh2_NB_state_sent2) {
rc = _libssh2_channel_read(session->scpRecv_channel, 0, rc = _libssh2_channel_read(session->scpRecv_channel, 0,
(char *) session-> (char *) session->
scpRecv_response + scpRecv_response +
session->scpRecv_response_len, 1); session->scpRecv_response_len, 1);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block waiting for SCP response"); "Would block waiting for SCP response");
return NULL; return NULL;
} }
else if (rc < 0) { else if(rc < 0) {
/* error, give up */ /* error, give up */
_libssh2_error(session, rc, "Failed reading SCP response"); _libssh2_error(session, rc, "Failed reading SCP response");
goto scp_recv_error; goto scp_recv_error;
@@ -405,7 +407,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
session->scpRecv_response_len++; session->scpRecv_response_len++;
if (session->scpRecv_response[0] != 'T') { if(session->scpRecv_response[0] != 'T') {
size_t err_len; size_t err_len;
char *err_msg; char *err_msg;
@@ -419,7 +421,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
_libssh2_channel_packet_data_len(session-> _libssh2_channel_packet_data_len(session->
scpRecv_channel, 0); scpRecv_channel, 0);
err_msg = LIBSSH2_ALLOC(session, err_len + 1); err_msg = LIBSSH2_ALLOC(session, err_len + 1);
if (!err_msg) { if(!err_msg) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Failed to get memory "); "Failed to get memory ");
goto scp_recv_error; goto scp_recv_error;
@@ -431,7 +433,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
/* If it failed for any reason, we ignore it anyway. */ /* If it failed for any reason, we ignore it anyway. */
/* zero terminate the error */ /* zero terminate the error */
err_msg[err_len]=0; err_msg[err_len] = 0;
_libssh2_debug(session, LIBSSH2_TRACE_SCP, _libssh2_debug(session, LIBSSH2_TRACE_SCP,
"got %02x %s", session->scpRecv_response[0], "got %02x %s", session->scpRecv_response[0],
@@ -444,7 +446,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
goto scp_recv_error; goto scp_recv_error;
} }
if ((session->scpRecv_response_len > 1) && if((session->scpRecv_response_len > 1) &&
((session-> ((session->
scpRecv_response[session->scpRecv_response_len - 1] < scpRecv_response[session->scpRecv_response_len - 1] <
'0') '0')
@@ -465,11 +467,11 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
goto scp_recv_error; goto scp_recv_error;
} }
if ((session->scpRecv_response_len < 9) if((session->scpRecv_response_len < 9)
|| (session-> || (session->
scpRecv_response[session->scpRecv_response_len - 1] != scpRecv_response[session->scpRecv_response_len - 1] !=
'\n')) { '\n')) {
if (session->scpRecv_response_len == if(session->scpRecv_response_len ==
LIBSSH2_SCP_RESPONSE_BUFLEN) { LIBSSH2_SCP_RESPONSE_BUFLEN) {
/* You had your chance */ /* You had your chance */
_libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
@@ -483,7 +485,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
/* We're guaranteed not to go under response_len == 0 by the /* We're guaranteed not to go under response_len == 0 by the
logic above */ logic above */
while ((session-> while((session->
scpRecv_response[session->scpRecv_response_len - 1] == scpRecv_response[session->scpRecv_response_len - 1] ==
'\r') '\r')
|| (session-> || (session->
@@ -493,18 +495,18 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
session->scpRecv_response[session->scpRecv_response_len] = session->scpRecv_response[session->scpRecv_response_len] =
'\0'; '\0';
if (session->scpRecv_response_len < 8) { if(session->scpRecv_response_len < 8) {
/* EOL came too soon */ /* EOL came too soon */
_libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
"Invalid response from SCP server, " "Invalid response from SCP server, "
"too short" ); "too short");
goto scp_recv_error; goto scp_recv_error;
} }
s = session->scpRecv_response + 1; s = session->scpRecv_response + 1;
p = (unsigned char *) strchr((char *) s, ' '); p = (unsigned char *) strchr((char *) s, ' ');
if (!p || ((p - s) <= 0)) { if(!p || ((p - s) <= 0)) {
/* No spaces or space in the wrong spot */ /* No spaces or space in the wrong spot */
_libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
"Invalid response from SCP server, " "Invalid response from SCP server, "
@@ -517,7 +519,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
session->scpRecv_mtime = strtol((char *) s, NULL, 10); session->scpRecv_mtime = strtol((char *) s, NULL, 10);
s = (unsigned char *) strchr((char *) p, ' '); s = (unsigned char *) strchr((char *) p, ' ');
if (!s || ((s - p) <= 0)) { if(!s || ((s - p) <= 0)) {
/* No spaces or space in the wrong spot */ /* No spaces or space in the wrong spot */
_libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
"Invalid response from SCP server, malformed mtime.usec"); "Invalid response from SCP server, malformed mtime.usec");
@@ -527,7 +529,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
/* Ignore mtime.usec */ /* Ignore mtime.usec */
s++; s++;
p = (unsigned char *) strchr((char *) s, ' '); p = (unsigned char *) strchr((char *) s, ' ');
if (!p || ((p - s) <= 0)) { if(!p || ((p - s) <= 0)) {
/* No spaces or space in the wrong spot */ /* No spaces or space in the wrong spot */
_libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
"Invalid response from SCP server, too short or malformed"); "Invalid response from SCP server, too short or malformed");
@@ -544,14 +546,15 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
session->scpRecv_state = libssh2_NB_state_sent3; session->scpRecv_state = libssh2_NB_state_sent3;
} }
if (session->scpRecv_state == libssh2_NB_state_sent3) { if(session->scpRecv_state == libssh2_NB_state_sent3) {
rc = _libssh2_channel_write(session->scpRecv_channel, 0, rc = _libssh2_channel_write(session->scpRecv_channel, 0,
session->scpRecv_response, 1); session->scpRecv_response, 1);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block waiting to send SCP ACK"); "Would block waiting to send SCP ACK");
return NULL; return NULL;
} else if (rc != 1) { }
else if(rc != 1) {
goto scp_recv_error; goto scp_recv_error;
} }
@@ -568,28 +571,28 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
session->scpRecv_state = libssh2_NB_state_sent4; session->scpRecv_state = libssh2_NB_state_sent4;
} }
if (session->scpRecv_state == libssh2_NB_state_sent4) { if(session->scpRecv_state == libssh2_NB_state_sent4) {
session->scpRecv_response_len = 0; session->scpRecv_response_len = 0;
session->scpRecv_state = libssh2_NB_state_sent5; session->scpRecv_state = libssh2_NB_state_sent5;
} }
if ((session->scpRecv_state == libssh2_NB_state_sent5) if((session->scpRecv_state == libssh2_NB_state_sent5)
|| (session->scpRecv_state == libssh2_NB_state_sent6)) { || (session->scpRecv_state == libssh2_NB_state_sent6)) {
while (session->scpRecv_response_len < LIBSSH2_SCP_RESPONSE_BUFLEN) { while(session->scpRecv_response_len < LIBSSH2_SCP_RESPONSE_BUFLEN) {
char *s, *p, *e = NULL; char *s, *p, *e = NULL;
if (session->scpRecv_state == libssh2_NB_state_sent5) { if(session->scpRecv_state == libssh2_NB_state_sent5) {
rc = _libssh2_channel_read(session->scpRecv_channel, 0, rc = _libssh2_channel_read(session->scpRecv_channel, 0,
(char *) session-> (char *) session->
scpRecv_response + scpRecv_response +
session->scpRecv_response_len, 1); session->scpRecv_response_len, 1);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block waiting for SCP response"); "Would block waiting for SCP response");
return NULL; return NULL;
} }
else if (rc < 0) { else if(rc < 0) {
/* error, bail out*/ /* error, bail out*/
_libssh2_error(session, rc, "Failed reading SCP response"); _libssh2_error(session, rc, "Failed reading SCP response");
goto scp_recv_error; goto scp_recv_error;
@@ -599,13 +602,13 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
session->scpRecv_response_len++; session->scpRecv_response_len++;
if (session->scpRecv_response[0] != 'C') { if(session->scpRecv_response[0] != 'C') {
_libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
"Invalid response from SCP server"); "Invalid response from SCP server");
goto scp_recv_error; goto scp_recv_error;
} }
if ((session->scpRecv_response_len > 1) && if((session->scpRecv_response_len > 1) &&
(session-> (session->
scpRecv_response[session->scpRecv_response_len - 1] != scpRecv_response[session->scpRecv_response_len - 1] !=
'\r') '\r')
@@ -621,11 +624,11 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
goto scp_recv_error; goto scp_recv_error;
} }
if ((session->scpRecv_response_len < 7) if((session->scpRecv_response_len < 7)
|| (session-> || (session->
scpRecv_response[session->scpRecv_response_len - 1] != scpRecv_response[session->scpRecv_response_len - 1] !=
'\n')) { '\n')) {
if (session->scpRecv_response_len == if(session->scpRecv_response_len ==
LIBSSH2_SCP_RESPONSE_BUFLEN) { LIBSSH2_SCP_RESPONSE_BUFLEN) {
/* You had your chance */ /* You had your chance */
_libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
@@ -639,7 +642,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
/* We're guaranteed not to go under response_len == 0 by the /* We're guaranteed not to go under response_len == 0 by the
logic above */ logic above */
while ((session-> while((session->
scpRecv_response[session->scpRecv_response_len - 1] == scpRecv_response[session->scpRecv_response_len - 1] ==
'\r') '\r')
|| (session-> || (session->
@@ -650,7 +653,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
session->scpRecv_response[session->scpRecv_response_len] = session->scpRecv_response[session->scpRecv_response_len] =
'\0'; '\0';
if (session->scpRecv_response_len < 6) { if(session->scpRecv_response_len < 6) {
/* EOL came too soon */ /* EOL came too soon */
_libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
"Invalid response from SCP server, too short"); "Invalid response from SCP server, too short");
@@ -660,7 +663,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
s = (char *) session->scpRecv_response + 1; s = (char *) session->scpRecv_response + 1;
p = strchr(s, ' '); p = strchr(s, ' ');
if (!p || ((p - s) <= 0)) { if(!p || ((p - s) <= 0)) {
/* No spaces or space in the wrong spot */ /* No spaces or space in the wrong spot */
_libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
"Invalid response from SCP server, malformed mode"); "Invalid response from SCP server, malformed mode");
@@ -671,14 +674,14 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
/* Make sure we don't get fooled by leftover values */ /* Make sure we don't get fooled by leftover values */
session->scpRecv_mode = strtol(s, &e, 8); session->scpRecv_mode = strtol(s, &e, 8);
if (e && *e) { if(e && *e) {
_libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
"Invalid response from SCP server, invalid mode"); "Invalid response from SCP server, invalid mode");
goto scp_recv_error; goto scp_recv_error;
} }
s = strchr(p, ' '); s = strchr(p, ' ');
if (!s || ((s - p) <= 0)) { if(!s || ((s - p) <= 0)) {
/* No spaces or space in the wrong spot */ /* No spaces or space in the wrong spot */
_libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
"Invalid response from SCP server, too short or malformed"); "Invalid response from SCP server, too short or malformed");
@@ -688,7 +691,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
*s = '\0'; *s = '\0';
/* Make sure we don't get fooled by leftover values */ /* Make sure we don't get fooled by leftover values */
session->scpRecv_size = scpsize_strtol(p, &e, 10); session->scpRecv_size = scpsize_strtol(p, &e, 10);
if (e && *e) { if(e && *e) {
_libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
"Invalid response from SCP server, invalid size"); "Invalid response from SCP server, invalid size");
goto scp_recv_error; goto scp_recv_error;
@@ -700,14 +703,15 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
session->scpRecv_state = libssh2_NB_state_sent6; session->scpRecv_state = libssh2_NB_state_sent6;
} }
if (session->scpRecv_state == libssh2_NB_state_sent6) { if(session->scpRecv_state == libssh2_NB_state_sent6) {
rc = _libssh2_channel_write(session->scpRecv_channel, 0, rc = _libssh2_channel_write(session->scpRecv_channel, 0,
session->scpRecv_response, 1); session->scpRecv_response, 1);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block sending SCP ACK"); "Would block sending SCP ACK");
return NULL; return NULL;
} else if (rc != 1) { }
else if(rc != 1) {
goto scp_recv_error; goto scp_recv_error;
} }
_libssh2_debug(session, LIBSSH2_TRACE_SCP, _libssh2_debug(session, LIBSSH2_TRACE_SCP,
@@ -723,7 +727,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
session->scpRecv_state = libssh2_NB_state_sent7; session->scpRecv_state = libssh2_NB_state_sent7;
} }
if (sb) { if(sb) {
memset(sb, 0, sizeof(libssh2_struct_stat)); memset(sb, 0, sizeof(libssh2_struct_stat));
sb->st_mtime = session->scpRecv_mtime; sb->st_mtime = session->scpRecv_mtime;
@@ -747,7 +751,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
scp_recv_error: scp_recv_error:
tmp_err_code = session->err_code; tmp_err_code = session->err_code;
tmp_err_msg = session->err_msg; tmp_err_msg = session->err_msg;
while (libssh2_channel_free(session->scpRecv_channel) == while(libssh2_channel_free(session->scpRecv_channel) ==
LIBSSH2_ERROR_EAGAIN); LIBSSH2_ERROR_EAGAIN);
session->err_code = tmp_err_code; session->err_code = tmp_err_code;
session->err_msg = tmp_err_msg; session->err_msg = tmp_err_msg;
@@ -779,7 +783,7 @@ libssh2_scp_recv(LIBSSH2_SESSION *session, const char *path, struct stat * sb)
BLOCK_ADJUST_ERRNO(ptr, session, scp_recv(session, path, sb_ptr)); BLOCK_ADJUST_ERRNO(ptr, session, scp_recv(session, path, sb_ptr));
/* ...and populate the caller's with as much info as fits. */ /* ...and populate the caller's with as much info as fits. */
if (sb) { if(sb) {
memset(sb, 0, sizeof(struct stat)); memset(sb, 0, sizeof(struct stat));
sb->st_mtime = sb_intl.st_mtime; sb->st_mtime = sb_intl.st_mtime;
@@ -821,7 +825,7 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
int tmp_err_code; int tmp_err_code;
const char *tmp_err_msg; const char *tmp_err_msg;
if (session->scpSend_state == libssh2_NB_state_idle) { if(session->scpSend_state == libssh2_NB_state_idle) {
session->scpSend_command_len = session->scpSend_command_len =
_libssh2_shell_quotedsize(path) + sizeof("scp -t ") + _libssh2_shell_quotedsize(path) + sizeof("scp -t ") +
((mtime || atime)?1:0); ((mtime || atime)?1:0);
@@ -829,7 +833,7 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
session->scpSend_command = session->scpSend_command =
LIBSSH2_ALLOC(session, session->scpSend_command_len); LIBSSH2_ALLOC(session, session->scpSend_command_len);
if (!session->scpSend_command) { if(!session->scpSend_command) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate a command buffer for " "Unable to allocate a command buffer for "
"SCP session"); "SCP session");
@@ -855,13 +859,13 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
session->scpSend_state = libssh2_NB_state_created; session->scpSend_state = libssh2_NB_state_created;
} }
if (session->scpSend_state == libssh2_NB_state_created) { if(session->scpSend_state == libssh2_NB_state_created) {
session->scpSend_channel = session->scpSend_channel =
_libssh2_channel_open(session, "session", sizeof("session") - 1, _libssh2_channel_open(session, "session", sizeof("session") - 1,
LIBSSH2_CHANNEL_WINDOW_DEFAULT, LIBSSH2_CHANNEL_WINDOW_DEFAULT,
LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0); LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0);
if (!session->scpSend_channel) { if(!session->scpSend_channel) {
if (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) { if(libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
/* previous call set libssh2_session_last_error(), pass it /* previous call set libssh2_session_last_error(), pass it
through */ through */
LIBSSH2_FREE(session, session->scpSend_command); LIBSSH2_FREE(session, session->scpSend_command);
@@ -878,18 +882,18 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
session->scpSend_state = libssh2_NB_state_sent; session->scpSend_state = libssh2_NB_state_sent;
} }
if (session->scpSend_state == libssh2_NB_state_sent) { if(session->scpSend_state == libssh2_NB_state_sent) {
/* Request SCP for the desired file */ /* Request SCP for the desired file */
rc = _libssh2_channel_process_startup(session->scpSend_channel, "exec", rc = _libssh2_channel_process_startup(session->scpSend_channel, "exec",
sizeof("exec") - 1, sizeof("exec") - 1,
(char *) session->scpSend_command, (char *) session->scpSend_command,
session->scpSend_command_len); session->scpSend_command_len);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block requesting SCP startup"); "Would block requesting SCP startup");
return NULL; return NULL;
} }
else if (rc) { else if(rc) {
/* previous call set libssh2_session_last_error(), pass it /* previous call set libssh2_session_last_error(), pass it
through */ through */
LIBSSH2_FREE(session, session->scpSend_command); LIBSSH2_FREE(session, session->scpSend_command);
@@ -904,28 +908,28 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
session->scpSend_state = libssh2_NB_state_sent1; session->scpSend_state = libssh2_NB_state_sent1;
} }
if (session->scpSend_state == libssh2_NB_state_sent1) { if(session->scpSend_state == libssh2_NB_state_sent1) {
/* Wait for ACK */ /* Wait for ACK */
rc = _libssh2_channel_read(session->scpSend_channel, 0, rc = _libssh2_channel_read(session->scpSend_channel, 0,
(char *) session->scpSend_response, 1); (char *) session->scpSend_response, 1);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block waiting for response from remote"); "Would block waiting for response from remote");
return NULL; return NULL;
} }
else if (rc < 0) { else if(rc < 0) {
_libssh2_error(session, rc, "SCP failure"); _libssh2_error(session, rc, "SCP failure");
goto scp_send_error; goto scp_send_error;
} }
else if(!rc) else if(!rc)
/* remain in the same state */ /* remain in the same state */
goto scp_send_empty_channel; goto scp_send_empty_channel;
else if (session->scpSend_response[0] != 0) { else if(session->scpSend_response[0] != 0) {
_libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
"Invalid ACK response from remote"); "Invalid ACK response from remote");
goto scp_send_error; goto scp_send_error;
} }
if (mtime || atime) { if(mtime || atime) {
/* Send mtime and atime to be used for file */ /* Send mtime and atime to be used for file */
session->scpSend_response_len = session->scpSend_response_len =
snprintf((char *) session->scpSend_response, snprintf((char *) session->scpSend_response,
@@ -939,16 +943,17 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
} }
/* Send mtime and atime to be used for file */ /* Send mtime and atime to be used for file */
if (mtime || atime) { if(mtime || atime) {
if (session->scpSend_state == libssh2_NB_state_sent2) { if(session->scpSend_state == libssh2_NB_state_sent2) {
rc = _libssh2_channel_write(session->scpSend_channel, 0, rc = _libssh2_channel_write(session->scpSend_channel, 0,
session->scpSend_response, session->scpSend_response,
session->scpSend_response_len); session->scpSend_response_len);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block sending time data for SCP file"); "Would block sending time data for SCP file");
return NULL; return NULL;
} else if (rc != (int)session->scpSend_response_len) { }
else if(rc != (int)session->scpSend_response_len) {
_libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
"Unable to send time data for SCP file"); "Unable to send time data for SCP file");
goto scp_send_error; goto scp_send_error;
@@ -957,23 +962,23 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
session->scpSend_state = libssh2_NB_state_sent3; session->scpSend_state = libssh2_NB_state_sent3;
} }
if (session->scpSend_state == libssh2_NB_state_sent3) { if(session->scpSend_state == libssh2_NB_state_sent3) {
/* Wait for ACK */ /* Wait for ACK */
rc = _libssh2_channel_read(session->scpSend_channel, 0, rc = _libssh2_channel_read(session->scpSend_channel, 0,
(char *) session->scpSend_response, 1); (char *) session->scpSend_response, 1);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block waiting for response"); "Would block waiting for response");
return NULL; return NULL;
} }
else if (rc < 0) { else if(rc < 0) {
_libssh2_error(session, rc, "SCP failure"); _libssh2_error(session, rc, "SCP failure");
goto scp_send_error; goto scp_send_error;
} }
else if(!rc) else if(!rc)
/* remain in the same state */ /* remain in the same state */
goto scp_send_empty_channel; goto scp_send_empty_channel;
else if (session->scpSend_response[0] != 0) { else if(session->scpSend_response[0] != 0) {
_libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
"Invalid SCP ACK response"); "Invalid SCP ACK response");
goto scp_send_error; goto scp_send_error;
@@ -981,16 +986,17 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
session->scpSend_state = libssh2_NB_state_sent4; session->scpSend_state = libssh2_NB_state_sent4;
} }
} else { }
if (session->scpSend_state == libssh2_NB_state_sent2) { else {
if(session->scpSend_state == libssh2_NB_state_sent2) {
session->scpSend_state = libssh2_NB_state_sent4; session->scpSend_state = libssh2_NB_state_sent4;
} }
} }
if (session->scpSend_state == libssh2_NB_state_sent4) { if(session->scpSend_state == libssh2_NB_state_sent4) {
/* Send mode, size, and basename */ /* Send mode, size, and basename */
const char *base = strrchr(path, '/'); const char *base = strrchr(path, '/');
if (base) if(base)
base++; base++;
else else
base = path; base = path;
@@ -1006,15 +1012,16 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
session->scpSend_state = libssh2_NB_state_sent5; session->scpSend_state = libssh2_NB_state_sent5;
} }
if (session->scpSend_state == libssh2_NB_state_sent5) { if(session->scpSend_state == libssh2_NB_state_sent5) {
rc = _libssh2_channel_write(session->scpSend_channel, 0, rc = _libssh2_channel_write(session->scpSend_channel, 0,
session->scpSend_response, session->scpSend_response,
session->scpSend_response_len); session->scpSend_response_len);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block send core file data for SCP file"); "Would block send core file data for SCP file");
return NULL; return NULL;
} else if (rc != (int)session->scpSend_response_len) { }
else if(rc != (int)session->scpSend_response_len) {
_libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
"Unable to send core file data for SCP file"); "Unable to send core file data for SCP file");
goto scp_send_error; goto scp_send_error;
@@ -1023,31 +1030,31 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
session->scpSend_state = libssh2_NB_state_sent6; session->scpSend_state = libssh2_NB_state_sent6;
} }
if (session->scpSend_state == libssh2_NB_state_sent6) { if(session->scpSend_state == libssh2_NB_state_sent6) {
/* Wait for ACK */ /* Wait for ACK */
rc = _libssh2_channel_read(session->scpSend_channel, 0, rc = _libssh2_channel_read(session->scpSend_channel, 0,
(char *) session->scpSend_response, 1); (char *) session->scpSend_response, 1);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block waiting for response"); "Would block waiting for response");
return NULL; return NULL;
} }
else if (rc < 0) { else if(rc < 0) {
_libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL, _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
"Invalid ACK response from remote"); "Invalid ACK response from remote");
goto scp_send_error; goto scp_send_error;
} }
else if (rc == 0) else if(rc == 0)
goto scp_send_empty_channel; goto scp_send_empty_channel;
else if (session->scpSend_response[0] != 0) { else if(session->scpSend_response[0] != 0) {
size_t err_len; size_t err_len;
char *err_msg; char *err_msg;
err_len = err_len =
_libssh2_channel_packet_data_len(session->scpSend_channel, 0); _libssh2_channel_packet_data_len(session->scpSend_channel, 0);
err_msg = LIBSSH2_ALLOC(session, err_len + 1); err_msg = LIBSSH2_ALLOC(session, err_len + 1);
if (!err_msg) { if(!err_msg) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"failed to get memory"); "failed to get memory");
goto scp_send_error; goto scp_send_error;
@@ -1056,8 +1063,8 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
/* Read the remote error message */ /* Read the remote error message */
rc = _libssh2_channel_read(session->scpSend_channel, 0, rc = _libssh2_channel_read(session->scpSend_channel, 0,
err_msg, err_len); err_msg, err_len);
if (rc > 0) { if(rc > 0) {
err_msg[err_len]=0; err_msg[err_len] = 0;
_libssh2_debug(session, LIBSSH2_TRACE_SCP, _libssh2_debug(session, LIBSSH2_TRACE_SCP,
"got %02x %s", session->scpSend_response[0], "got %02x %s", session->scpSend_response[0],
err_msg); err_msg);
@@ -1085,8 +1092,8 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
scp_send_error: scp_send_error:
tmp_err_code = session->err_code; tmp_err_code = session->err_code;
tmp_err_msg = session->err_msg; tmp_err_msg = session->err_msg;
while (libssh2_channel_free(session->scpSend_channel) == while(libssh2_channel_free(session->scpSend_channel) ==
LIBSSH2_ERROR_EAGAIN); LIBSSH2_ERROR_EAGAIN);
session->err_code = tmp_err_code; session->err_code = tmp_err_code;
session->err_msg = tmp_err_msg; session->err_msg = tmp_err_msg;
session->scpSend_channel = NULL; session->scpSend_channel = NULL;

396
src/session.c
View File

File diff suppressed because it is too large Load Diff

8
src/session.h
View File

@@ -51,9 +51,9 @@
function. function.
*/ */
#define BLOCK_ADJUST(rc,sess,x) \ #define BLOCK_ADJUST(rc, sess, x) \
do { \ do { \
time_t entry_time = time (NULL); \ time_t entry_time = time(NULL); \
do { \ do { \
rc = x; \ rc = x; \
/* the order of the check below is important to properly deal with \ /* the order of the check below is important to properly deal with \
@@ -70,9 +70,9 @@
* immediately. If the API is blocking and we get a NULL we check the errno * immediately. If the API is blocking and we get a NULL we check the errno
* and *only* if that is EAGAIN we loop and wait for socket action. * and *only* if that is EAGAIN we loop and wait for socket action.
*/ */
#define BLOCK_ADJUST_ERRNO(ptr,sess,x) \ #define BLOCK_ADJUST_ERRNO(ptr, sess, x) \
do { \ do { \
time_t entry_time = time (NULL); \ time_t entry_time = time(NULL); \
int rc; \ int rc; \
do { \ do { \
ptr = x; \ ptr = x; \

503
src/sftp.c
View File

File diff suppressed because it is too large Load Diff

144
src/transport.c
View File

@@ -65,16 +65,16 @@ debugdump(LIBSSH2_SESSION * session,
unsigned int width = 0x10; unsigned int width = 0x10;
char buffer[256]; /* Must be enough for width*4 + about 30 or so */ char buffer[256]; /* Must be enough for width*4 + about 30 or so */
size_t used; size_t used;
static const char* hex_chars = "0123456789ABCDEF"; static const char *hex_chars = "0123456789ABCDEF";
if (!(session->showmask & LIBSSH2_TRACE_TRANS)) { if(!(session->showmask & LIBSSH2_TRACE_TRANS)) {
/* not asked for, bail out */ /* not asked for, bail out */
return; return;
} }
used = snprintf(buffer, sizeof(buffer), "=> %s (%d bytes)\n", used = snprintf(buffer, sizeof(buffer), "=> %s (%d bytes)\n",
desc, (int) size); desc, (int) size);
if (session->tracehandler) if(session->tracehandler)
(session->tracehandler)(session, session->tracehandler_context, (session->tracehandler)(session, session->tracehandler_context,
buffer, used); buffer, used);
else else
@@ -86,9 +86,9 @@ debugdump(LIBSSH2_SESSION * session,
/* hex not disabled, show it */ /* hex not disabled, show it */
for(c = 0; c < width; c++) { for(c = 0; c < width; c++) {
if (i + c < size) { if(i + c < size) {
buffer[used++] = hex_chars[(ptr[i+c] >> 4) & 0xF]; buffer[used++] = hex_chars[(ptr[i + c] >> 4) & 0xF];
buffer[used++] = hex_chars[ptr[i+c] & 0xF]; buffer[used++] = hex_chars[ptr[i + c] & 0xF];
} }
else { else {
buffer[used++] = ' '; buffer[used++] = ' ';
@@ -96,7 +96,7 @@ debugdump(LIBSSH2_SESSION * session,
} }
buffer[used++] = ' '; buffer[used++] = ' ';
if ((width/2) - 1 == c) if((width/2) - 1 == c)
buffer[used++] = ' '; buffer[used++] = ' ';
} }
@@ -110,7 +110,7 @@ debugdump(LIBSSH2_SESSION * session,
buffer[used++] = '\n'; buffer[used++] = '\n';
buffer[used] = 0; buffer[used] = 0;
if (session->tracehandler) if(session->tracehandler)
(session->tracehandler)(session, session->tracehandler_context, (session->tracehandler)(session, session->tracehandler_context,
buffer, used); buffer, used);
else else
@@ -138,8 +138,8 @@ decrypt(LIBSSH2_SESSION * session, unsigned char *source,
we risk losing those extra bytes */ we risk losing those extra bytes */
assert((len % blocksize) == 0); assert((len % blocksize) == 0);
while (len >= blocksize) { while(len >= blocksize) {
if (session->remote.crypt->crypt(session, source, blocksize, if(session->remote.crypt->crypt(session, source, blocksize,
&session->remote.crypt_abstract)) { &session->remote.crypt_abstract)) {
LIBSSH2_FREE(session, p->payload); LIBSSH2_FREE(session, p->payload);
return LIBSSH2_ERROR_DECRYPT; return LIBSSH2_ERROR_DECRYPT;
@@ -169,11 +169,11 @@ fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ )
int rc; int rc;
int compressed; int compressed;
if (session->fullpacket_state == libssh2_NB_state_idle) { if(session->fullpacket_state == libssh2_NB_state_idle) {
session->fullpacket_macstate = LIBSSH2_MAC_CONFIRMED; session->fullpacket_macstate = LIBSSH2_MAC_CONFIRMED;
session->fullpacket_payload_len = p->packet_length - 1; session->fullpacket_payload_len = p->packet_length - 1;
if (encrypted) { if(encrypted) {
/* Calculate MAC hash */ /* Calculate MAC hash */
session->remote.mac->hash(session, macbuf, /* store hash here */ session->remote.mac->hash(session, macbuf, /* store hash here */
@@ -188,7 +188,7 @@ fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ )
* buffer. Note that 'payload_len' here is the packet_length * buffer. Note that 'payload_len' here is the packet_length
* field which includes the padding but not the MAC. * field which includes the padding but not the MAC.
*/ */
if (memcmp(macbuf, p->payload + session->fullpacket_payload_len, if(memcmp(macbuf, p->payload + session->fullpacket_payload_len,
session->remote.mac->mac_len)) { session->remote.mac->mac_len)) {
session->fullpacket_macstate = LIBSSH2_MAC_INVALID; session->fullpacket_macstate = LIBSSH2_MAC_INVALID;
} }
@@ -206,7 +206,7 @@ fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ )
((session->state & LIBSSH2_STATE_AUTHENTICATED) || ((session->state & LIBSSH2_STATE_AUTHENTICATED) ||
session->local.comp->use_in_auth); session->local.comp->use_in_auth);
if (compressed && session->remote.comp_abstract) { if(compressed && session->remote.comp_abstract) {
/* /*
* The buffer for the decompression (remote.comp_abstract) is * The buffer for the decompression (remote.comp_abstract) is
* initialised in time when it is needed so as long it is NULL we * initialised in time when it is needed so as long it is NULL we
@@ -237,13 +237,13 @@ fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ )
session->fullpacket_state = libssh2_NB_state_created; session->fullpacket_state = libssh2_NB_state_created;
} }
if (session->fullpacket_state == libssh2_NB_state_created) { if(session->fullpacket_state == libssh2_NB_state_created) {
rc = _libssh2_packet_add(session, p->payload, rc = _libssh2_packet_add(session, p->payload,
session->fullpacket_payload_len, session->fullpacket_payload_len,
session->fullpacket_macstate); session->fullpacket_macstate);
if (rc == LIBSSH2_ERROR_EAGAIN) if(rc == LIBSSH2_ERROR_EAGAIN)
return rc; return rc;
if (rc) { if(rc) {
session->fullpacket_state = libssh2_NB_state_idle; session->fullpacket_state = libssh2_NB_state_idle;
return rc; return rc;
} }
@@ -298,7 +298,7 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
* of packet_read, then don't redirect, as that would be an infinite loop! * of packet_read, then don't redirect, as that would be an infinite loop!
*/ */
if (session->state & LIBSSH2_STATE_EXCHANGING_KEYS && if(session->state & LIBSSH2_STATE_EXCHANGING_KEYS &&
!(session->state & LIBSSH2_STATE_KEX_ACTIVE)) { !(session->state & LIBSSH2_STATE_KEX_ACTIVE)) {
/* Whoever wants a packet won't get anything until the key re-exchange /* Whoever wants a packet won't get anything until the key re-exchange
@@ -307,7 +307,7 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
_libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Redirecting into the" _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Redirecting into the"
" key re-exchange from _libssh2_transport_read"); " key re-exchange from _libssh2_transport_read");
rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state); rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state);
if (rc) if(rc)
return rc; return rc;
} }
@@ -316,20 +316,21 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
* I know this is very ugly and not a really good use of "goto", but * I know this is very ugly and not a really good use of "goto", but
* this case statement would be even uglier to do it any other way * this case statement would be even uglier to do it any other way
*/ */
if (session->readPack_state == libssh2_NB_state_jump1) { if(session->readPack_state == libssh2_NB_state_jump1) {
session->readPack_state = libssh2_NB_state_idle; session->readPack_state = libssh2_NB_state_idle;
encrypted = session->readPack_encrypted; encrypted = session->readPack_encrypted;
goto libssh2_transport_read_point1; goto libssh2_transport_read_point1;
} }
do { do {
if (session->socket_state == LIBSSH2_SOCKET_DISCONNECTED) { if(session->socket_state == LIBSSH2_SOCKET_DISCONNECTED) {
return LIBSSH2_ERROR_NONE; return LIBSSH2_ERROR_NONE;
} }
if (session->state & LIBSSH2_STATE_NEWKEYS) { if(session->state & LIBSSH2_STATE_NEWKEYS) {
blocksize = session->remote.crypt->blocksize; blocksize = session->remote.crypt->blocksize;
} else { }
else {
encrypted = 0; /* not encrypted */ encrypted = 0; /* not encrypted */
blocksize = 5; /* not strictly true, but we can use 5 here to blocksize = 5; /* not strictly true, but we can use 5 here to
make the checks below work fine still */ make the checks below work fine still */
@@ -348,18 +349,19 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
/* if remainbuf turns negative we have a bad internal error */ /* if remainbuf turns negative we have a bad internal error */
assert(remainbuf >= 0); assert(remainbuf >= 0);
if (remainbuf < blocksize) { if(remainbuf < blocksize) {
/* If we have less than a blocksize left, it is too /* If we have less than a blocksize left, it is too
little data to deal with, read more */ little data to deal with, read more */
ssize_t nread; ssize_t nread;
/* move any remainder to the start of the buffer so /* move any remainder to the start of the buffer so
that we can do a full refill */ that we can do a full refill */
if (remainbuf) { if(remainbuf) {
memmove(p->buf, &p->buf[p->readidx], remainbuf); memmove(p->buf, &p->buf[p->readidx], remainbuf);
p->readidx = 0; p->readidx = 0;
p->writeidx = remainbuf; p->writeidx = remainbuf;
} else { }
else {
/* nothing to move, just zero the indexes */ /* nothing to move, just zero the indexes */
p->readidx = p->writeidx = 0; p->readidx = p->writeidx = 0;
} }
@@ -369,10 +371,10 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
LIBSSH2_RECV(session, &p->buf[remainbuf], LIBSSH2_RECV(session, &p->buf[remainbuf],
PACKETBUFSIZE - remainbuf, PACKETBUFSIZE - remainbuf,
LIBSSH2_SOCKET_RECV_FLAGS(session)); LIBSSH2_SOCKET_RECV_FLAGS(session));
if (nread <= 0) { if(nread <= 0) {
/* check if this is due to EAGAIN and return the special /* check if this is due to EAGAIN and return the special
return code if so, error out normally otherwise */ return code if so, error out normally otherwise */
if ((nread < 0) && (nread == -EAGAIN)) { if((nread < 0) && (nread == -EAGAIN)) {
session->socket_block_directions |= session->socket_block_directions |=
LIBSSH2_SESSION_BLOCK_INBOUND; LIBSSH2_SESSION_BLOCK_INBOUND;
return LIBSSH2_ERROR_EAGAIN; return LIBSSH2_ERROR_EAGAIN;
@@ -398,12 +400,12 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
/* how much data to deal with from the buffer */ /* how much data to deal with from the buffer */
numbytes = remainbuf; numbytes = remainbuf;
if (!p->total_num) { if(!p->total_num) {
/* No payload package area allocated yet. To know the /* No payload package area allocated yet. To know the
size of this payload, we need to decrypt the first size of this payload, we need to decrypt the first
blocksize data. */ blocksize data. */
if (numbytes < blocksize) { if(numbytes < blocksize) {
/* we can't act on anything less than blocksize, but this /* we can't act on anything less than blocksize, but this
check is only done for the initial block since once we have check is only done for the initial block since once we have
got the start of a block we can in fact deal with fractions got the start of a block we can in fact deal with fractions
@@ -413,15 +415,16 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
return LIBSSH2_ERROR_EAGAIN; return LIBSSH2_ERROR_EAGAIN;
} }
if (encrypted) { if(encrypted) {
rc = decrypt(session, &p->buf[p->readidx], block, blocksize); rc = decrypt(session, &p->buf[p->readidx], block, blocksize);
if (rc != LIBSSH2_ERROR_NONE) { if(rc != LIBSSH2_ERROR_NONE) {
return rc; return rc;
} }
/* save the first 5 bytes of the decrypted package, to be /* save the first 5 bytes of the decrypted package, to be
used in the hash calculation later down. */ used in the hash calculation later down. */
memcpy(p->init, block, 5); memcpy(p->init, block, 5);
} else { }
else {
/* the data is plain, just copy it verbatim to /* the data is plain, just copy it verbatim to
the working block buffer */ the working block buffer */
memcpy(block, &p->buf[p->readidx], blocksize); memcpy(block, &p->buf[p->readidx], blocksize);
@@ -434,7 +437,7 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
* and we can extract packet and padding length from it * and we can extract packet and padding length from it
*/ */
p->packet_length = _libssh2_ntohu32(block); p->packet_length = _libssh2_ntohu32(block);
if (p->packet_length < 1) if(p->packet_length < 1)
return LIBSSH2_ERROR_DECRYPT; return LIBSSH2_ERROR_DECRYPT;
p->padding_length = block[4]; p->padding_length = block[4];
@@ -453,21 +456,21 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
* or less (including length, padding length, payload, * or less (including length, padding length, payload,
* padding, and MAC.)." * padding, and MAC.)."
*/ */
if (total_num > LIBSSH2_PACKET_MAXPAYLOAD) { if(total_num > LIBSSH2_PACKET_MAXPAYLOAD) {
return LIBSSH2_ERROR_OUT_OF_BOUNDARY; return LIBSSH2_ERROR_OUT_OF_BOUNDARY;
} }
/* Get a packet handle put data into. We get one to /* Get a packet handle put data into. We get one to
hold all data, including padding and MAC. */ hold all data, including padding and MAC. */
p->payload = LIBSSH2_ALLOC(session, total_num); p->payload = LIBSSH2_ALLOC(session, total_num);
if (!p->payload) { if(!p->payload) {
return LIBSSH2_ERROR_ALLOC; return LIBSSH2_ERROR_ALLOC;
} }
p->total_num = total_num; p->total_num = total_num;
/* init write pointer to start of payload buffer */ /* init write pointer to start of payload buffer */
p->wptr = p->payload; p->wptr = p->payload;
if (blocksize > 5) { if(blocksize > 5) {
/* copy the data from index 5 to the end of /* copy the data from index 5 to the end of
the blocksize from the temporary buffer to the blocksize from the temporary buffer to
the start of the decrypted buffer */ the start of the decrypted buffer */
@@ -487,13 +490,13 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
package */ package */
remainpack = p->total_num - p->data_num; remainpack = p->total_num - p->data_num;
if (numbytes > remainpack) { if(numbytes > remainpack) {
/* if we have more data in the buffer than what is going into this /* if we have more data in the buffer than what is going into this
particular packet, we limit this round to this packet only */ particular packet, we limit this round to this packet only */
numbytes = remainpack; numbytes = remainpack;
} }
if (encrypted) { if(encrypted) {
/* At the end of the incoming stream, there is a MAC, /* At the end of the incoming stream, there is a MAC,
and we don't want to decrypt that since we need it and we don't want to decrypt that since we need it
"raw". We MUST however decrypt the padding data "raw". We MUST however decrypt the padding data
@@ -503,13 +506,14 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
/* if what we have plus numbytes is bigger than the /* if what we have plus numbytes is bigger than the
total minus the skip margin, we should lower the total minus the skip margin, we should lower the
amount to decrypt even more */ amount to decrypt even more */
if ((p->data_num + numbytes) > (p->total_num - skip)) { if((p->data_num + numbytes) > (p->total_num - skip)) {
numdecrypt = (p->total_num - skip) - p->data_num; numdecrypt = (p->total_num - skip) - p->data_num;
} else { }
else {
int frac; int frac;
numdecrypt = numbytes; numdecrypt = numbytes;
frac = numdecrypt % blocksize; frac = numdecrypt % blocksize;
if (frac) { if(frac) {
/* not an aligned amount of blocks, /* not an aligned amount of blocks,
align it */ align it */
numdecrypt -= frac; numdecrypt -= frac;
@@ -518,16 +522,17 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
numbytes = 0; numbytes = 0;
} }
} }
} else { }
else {
/* unencrypted data should not be decrypted at all */ /* unencrypted data should not be decrypted at all */
numdecrypt = 0; numdecrypt = 0;
} }
/* if there are bytes to decrypt, do that */ /* if there are bytes to decrypt, do that */
if (numdecrypt > 0) { if(numdecrypt > 0) {
/* now decrypt the lot */ /* now decrypt the lot */
rc = decrypt(session, &p->buf[p->readidx], p->wptr, numdecrypt); rc = decrypt(session, &p->buf[p->readidx], p->wptr, numdecrypt);
if (rc != LIBSSH2_ERROR_NONE) { if(rc != LIBSSH2_ERROR_NONE) {
p->total_num = 0; /* no packet buffer available */ p->total_num = 0; /* no packet buffer available */
return rc; return rc;
} }
@@ -545,7 +550,7 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
/* if there are bytes to copy that aren't decrypted, simply /* if there are bytes to copy that aren't decrypted, simply
copy them as-is to the target buffer */ copy them as-is to the target buffer */
if (numbytes > 0) { if(numbytes > 0) {
memcpy(p->wptr, &p->buf[p->readidx], numbytes); memcpy(p->wptr, &p->buf[p->readidx], numbytes);
/* advance the read pointer */ /* advance the read pointer */
@@ -560,14 +565,13 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
current packet */ current packet */
remainpack = p->total_num - p->data_num; remainpack = p->total_num - p->data_num;
if (!remainpack) { if(!remainpack) {
/* we have a full packet */ /* we have a full packet */
libssh2_transport_read_point1: libssh2_transport_read_point1:
rc = fullpacket(session, encrypted); rc = fullpacket(session, encrypted);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
if (session->packAdd_state != libssh2_NB_state_idle) if(session->packAdd_state != libssh2_NB_state_idle) {
{
/* fullpacket only returns LIBSSH2_ERROR_EAGAIN if /* fullpacket only returns LIBSSH2_ERROR_EAGAIN if
* libssh2_packet_add returns LIBSSH2_ERROR_EAGAIN. If that * libssh2_packet_add returns LIBSSH2_ERROR_EAGAIN. If that
* returns LIBSSH2_ERROR_EAGAIN but the packAdd_state is idle, * returns LIBSSH2_ERROR_EAGAIN but the packAdd_state is idle,
@@ -587,7 +591,7 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
return rc; return rc;
} }
} while (1); /* loop */ } while(1); /* loop */
return LIBSSH2_ERROR_SOCKET_RECV; /* we never reach this point */ return LIBSSH2_ERROR_SOCKET_RECV; /* we never reach this point */
} }
@@ -600,13 +604,13 @@ send_existing(LIBSSH2_SESSION *session, const unsigned char *data,
ssize_t length; ssize_t length;
struct transportpacket *p = &session->packet; struct transportpacket *p = &session->packet;
if (!p->olen) { if(!p->olen) {
*ret = 0; *ret = 0;
return LIBSSH2_ERROR_NONE; return LIBSSH2_ERROR_NONE;
} }
/* send as much as possible of the existing packet */ /* send as much as possible of the existing packet */
if ((data != p->odata) || (data_len != p->olen)) { if((data != p->odata) || (data_len != p->olen)) {
/* When we are about to complete the sending of a packet, it is vital /* When we are about to complete the sending of a packet, it is vital
that the caller doesn't try to send a new/different packet since that the caller doesn't try to send a new/different packet since
we don't add this one up until the previous one has been sent. To we don't add this one up until the previous one has been sent. To
@@ -622,7 +626,7 @@ send_existing(LIBSSH2_SESSION *session, const unsigned char *data,
rc = LIBSSH2_SEND(session, &p->outbuf[p->osent], length, rc = LIBSSH2_SEND(session, &p->outbuf[p->osent], length,
LIBSSH2_SOCKET_SEND_FLAGS(session)); LIBSSH2_SOCKET_SEND_FLAGS(session));
if (rc < 0) if(rc < 0)
_libssh2_debug(session, LIBSSH2_TRACE_SOCKET, _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
"Error sending %d bytes: %d", length, -rc); "Error sending %d bytes: %d", length, -rc);
else { else {
@@ -633,7 +637,7 @@ send_existing(LIBSSH2_SESSION *session, const unsigned char *data,
&p->outbuf[p->osent], rc); &p->outbuf[p->osent], rc);
} }
if (rc == length) { if(rc == length) {
/* the remainder of the package was sent */ /* the remainder of the package was sent */
p->ototal_num = 0; p->ototal_num = 0;
p->olen = 0; p->olen = 0;
@@ -643,9 +647,9 @@ send_existing(LIBSSH2_SESSION *session, const unsigned char *data,
return LIBSSH2_ERROR_NONE; return LIBSSH2_ERROR_NONE;
} }
else if (rc < 0) { else if(rc < 0) {
/* nothing was sent */ /* nothing was sent */
if (rc != -EAGAIN) if(rc != -EAGAIN)
/* send failure! */ /* send failure! */
return LIBSSH2_ERROR_SOCKET_SEND; return LIBSSH2_ERROR_SOCKET_SEND;
@@ -705,14 +709,14 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
* *
* See the similar block in _libssh2_transport_read for more details. * See the similar block in _libssh2_transport_read for more details.
*/ */
if (session->state & LIBSSH2_STATE_EXCHANGING_KEYS && if(session->state & LIBSSH2_STATE_EXCHANGING_KEYS &&
!(session->state & LIBSSH2_STATE_KEX_ACTIVE)) { !(session->state & LIBSSH2_STATE_KEX_ACTIVE)) {
/* Don't write any new packets if we're still in the middle of a key /* Don't write any new packets if we're still in the middle of a key
* exchange. */ * exchange. */
_libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Redirecting into the" _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Redirecting into the"
" key re-exchange from _libssh2_transport_send"); " key re-exchange from _libssh2_transport_send");
rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state); rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state);
if (rc) if(rc)
return rc; return rc;
} }
@@ -723,12 +727,12 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
/* FIRST, check if we have a pending write to complete. send_existing /* FIRST, check if we have a pending write to complete. send_existing
only sanity-check data and data_len and not data2 and data2_len!! */ only sanity-check data and data_len and not data2 and data2_len!! */
rc = send_existing(session, data, data_len, &ret); rc = send_existing(session, data, data_len, &ret);
if (rc) if(rc)
return rc; return rc;
session->socket_block_directions &= ~LIBSSH2_SESSION_BLOCK_OUTBOUND; session->socket_block_directions &= ~LIBSSH2_SESSION_BLOCK_OUTBOUND;
if (ret) if(ret)
/* set by send_existing if data was sent */ /* set by send_existing if data was sent */
return rc; return rc;
@@ -740,7 +744,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
((session->state & LIBSSH2_STATE_AUTHENTICATED) || ((session->state & LIBSSH2_STATE_AUTHENTICATED) ||
session->local.comp->use_in_auth); session->local.comp->use_in_auth);
if (encrypted && compressed) { if(encrypted && compressed) {
/* the idea here is that these function must fail if the output gets /* the idea here is that these function must fail if the output gets
larger than what fits in the assigned buffer so thus they don't larger than what fits in the assigned buffer so thus they don't
check the input size as we don't know how much it compresses */ check the input size as we don't know how much it compresses */
@@ -761,7 +765,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
dest2_len -= dest_len; dest2_len -= dest_len;
rc = session->local.comp->comp(session, rc = session->local.comp->comp(session,
&p->outbuf[5+dest_len], &dest2_len, &p->outbuf[5 + dest_len], &dest2_len,
data2, data2_len, data2, data2_len,
&session->local.comp_abstract); &session->local.comp_abstract);
} }
@@ -781,7 +785,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
/* copy the payload data */ /* copy the payload data */
memcpy(&p->outbuf[5], data, data_len); memcpy(&p->outbuf[5], data, data_len);
if(data2 && data2_len) if(data2 && data2_len)
memcpy(&p->outbuf[5+data_len], data2, data2_len); memcpy(&p->outbuf[5 + data_len], data2, data2_len);
data_len += data2_len; /* use the combined length */ data_len += data2_len; /* use the combined length */
} }
@@ -805,7 +809,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
/* if the padding becomes too small we add another blocksize worth /* if the padding becomes too small we add another blocksize worth
of it (taken from the original libssh2 where it didn't have any of it (taken from the original libssh2 where it didn't have any
real explanation) */ real explanation) */
if (padding_length < 4) { if(padding_length < 4) {
padding_length += blocksize; padding_length += blocksize;
} }
#ifdef RANDOM_PADDING #ifdef RANDOM_PADDING
@@ -834,7 +838,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
/* fill the padding area with random junk */ /* fill the padding area with random junk */
_libssh2_random(p->outbuf + 5 + data_len, padding_length); _libssh2_random(p->outbuf + 5 + data_len, padding_length);
if (encrypted) { if(encrypted) {
size_t i; size_t i;
/* Calculate MAC hash. Put the output at index packet_length, /* Calculate MAC hash. Put the output at index packet_length,
@@ -850,7 +854,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
The MAC field is not encrypted. */ The MAC field is not encrypted. */
for(i = 0; i < packet_length; i += session->local.crypt->blocksize) { for(i = 0; i < packet_length; i += session->local.crypt->blocksize) {
unsigned char *ptr = &p->outbuf[i]; unsigned char *ptr = &p->outbuf[i];
if (session->local.crypt->crypt(session, ptr, if(session->local.crypt->crypt(session, ptr,
session->local.crypt->blocksize, session->local.crypt->blocksize,
&session->local.crypt_abstract)) &session->local.crypt_abstract))
return LIBSSH2_ERROR_ENCRYPT; /* encryption failure */ return LIBSSH2_ERROR_ENCRYPT; /* encryption failure */
@@ -861,7 +865,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
ret = LIBSSH2_SEND(session, p->outbuf, total_length, ret = LIBSSH2_SEND(session, p->outbuf, total_length,
LIBSSH2_SOCKET_SEND_FLAGS(session)); LIBSSH2_SOCKET_SEND_FLAGS(session));
if (ret < 0) if(ret < 0)
_libssh2_debug(session, LIBSSH2_TRACE_SOCKET, _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
"Error sending %d bytes: %d", total_length, -ret); "Error sending %d bytes: %d", total_length, -ret);
else { else {
@@ -870,8 +874,8 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
debugdump(session, "libssh2_transport_write send()", p->outbuf, ret); debugdump(session, "libssh2_transport_write send()", p->outbuf, ret);
} }
if (ret != total_length) { if(ret != total_length) {
if (ret >= 0 || ret == -EAGAIN) { if(ret >= 0 || ret == -EAGAIN) {
/* the whole packet could not be sent, save the rest */ /* the whole packet could not be sent, save the rest */
session->socket_block_directions |= LIBSSH2_SESSION_BLOCK_OUTBOUND; session->socket_block_directions |= LIBSSH2_SESSION_BLOCK_OUTBOUND;
p->odata = orgdata; p->odata = orgdata;

290
src/userauth.c
View File

@@ -71,7 +71,7 @@ static char *userauth_list(LIBSSH2_SESSION *session, const char *username,
unsigned char *s; unsigned char *s;
int rc; int rc;
if (session->userauth_list_state == libssh2_NB_state_idle) { if(session->userauth_list_state == libssh2_NB_state_idle) {
/* Zero the whole thing out */ /* Zero the whole thing out */
memset(&session->userauth_list_packet_requirev_state, 0, memset(&session->userauth_list_packet_requirev_state, 0,
sizeof(session->userauth_list_packet_requirev_state)); sizeof(session->userauth_list_packet_requirev_state));
@@ -80,7 +80,7 @@ static char *userauth_list(LIBSSH2_SESSION *session, const char *username,
s = session->userauth_list_data = s = session->userauth_list_data =
LIBSSH2_ALLOC(session, session->userauth_list_data_len); LIBSSH2_ALLOC(session, session->userauth_list_data_len);
if (!session->userauth_list_data) { if(!session->userauth_list_data) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for userauth_list"); "Unable to allocate memory for userauth_list");
return NULL; return NULL;
@@ -94,11 +94,11 @@ static char *userauth_list(LIBSSH2_SESSION *session, const char *username,
session->userauth_list_state = libssh2_NB_state_created; session->userauth_list_state = libssh2_NB_state_created;
} }
if (session->userauth_list_state == libssh2_NB_state_created) { if(session->userauth_list_state == libssh2_NB_state_created) {
rc = _libssh2_transport_send(session, session->userauth_list_data, rc = _libssh2_transport_send(session, session->userauth_list_data,
session->userauth_list_data_len, session->userauth_list_data_len,
(unsigned char *)"none", 4); (unsigned char *)"none", 4);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block requesting userauth list"); "Would block requesting userauth list");
return NULL; return NULL;
@@ -107,7 +107,7 @@ static char *userauth_list(LIBSSH2_SESSION *session, const char *username,
LIBSSH2_FREE(session, session->userauth_list_data); LIBSSH2_FREE(session, session->userauth_list_data);
session->userauth_list_data = NULL; session->userauth_list_data = NULL;
if (rc) { if(rc) {
_libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
"Unable to send userauth-none request"); "Unable to send userauth-none request");
session->userauth_list_state = libssh2_NB_state_idle; session->userauth_list_state = libssh2_NB_state_idle;
@@ -117,23 +117,24 @@ static char *userauth_list(LIBSSH2_SESSION *session, const char *username,
session->userauth_list_state = libssh2_NB_state_sent; session->userauth_list_state = libssh2_NB_state_sent;
} }
if (session->userauth_list_state == libssh2_NB_state_sent) { if(session->userauth_list_state == libssh2_NB_state_sent) {
rc = _libssh2_packet_requirev(session, reply_codes, rc = _libssh2_packet_requirev(session, reply_codes,
&session->userauth_list_data, &session->userauth_list_data,
&session->userauth_list_data_len, 0, &session->userauth_list_data_len, 0,
NULL, 0, NULL, 0,
&session->userauth_list_packet_requirev_state); &session->userauth_list_packet_requirev_state);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
_libssh2_error(session, LIBSSH2_ERROR_EAGAIN, _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block requesting userauth list"); "Would block requesting userauth list");
return NULL; return NULL;
} else if (rc) { }
else if(rc) {
_libssh2_error(session, rc, "Failed getting response"); _libssh2_error(session, rc, "Failed getting response");
session->userauth_list_state = libssh2_NB_state_idle; session->userauth_list_state = libssh2_NB_state_idle;
return NULL; return NULL;
} }
if (session->userauth_list_data[0] == SSH_MSG_USERAUTH_SUCCESS) { if(session->userauth_list_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
/* Wow, who'dve thought... */ /* Wow, who'dve thought... */
_libssh2_error(session, LIBSSH2_ERROR_NONE, "No error"); _libssh2_error(session, LIBSSH2_ERROR_NONE, "No error");
LIBSSH2_FREE(session, session->userauth_list_data); LIBSSH2_FREE(session, session->userauth_list_data);
@@ -205,7 +206,7 @@ userauth_password(LIBSSH2_SESSION *session,
}; };
int rc; int rc;
if (session->userauth_pswd_state == libssh2_NB_state_idle) { if(session->userauth_pswd_state == libssh2_NB_state_idle) {
/* Zero the whole thing out */ /* Zero the whole thing out */
memset(&session->userauth_pswd_packet_requirev_state, 0, memset(&session->userauth_pswd_packet_requirev_state, 0,
sizeof(session->userauth_pswd_packet_requirev_state)); sizeof(session->userauth_pswd_packet_requirev_state));
@@ -223,7 +224,7 @@ userauth_password(LIBSSH2_SESSION *session,
struct */ struct */
s = session->userauth_pswd_data = s = session->userauth_pswd_data =
LIBSSH2_ALLOC(session, session->userauth_pswd_data_len); LIBSSH2_ALLOC(session, session->userauth_pswd_data_len);
if (!session->userauth_pswd_data) { if(!session->userauth_pswd_data) {
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for " "Unable to allocate memory for "
"userauth-password request"); "userauth-password request");
@@ -243,11 +244,11 @@ userauth_password(LIBSSH2_SESSION *session,
session->userauth_pswd_state = libssh2_NB_state_created; session->userauth_pswd_state = libssh2_NB_state_created;
} }
if (session->userauth_pswd_state == libssh2_NB_state_created) { if(session->userauth_pswd_state == libssh2_NB_state_created) {
rc = _libssh2_transport_send(session, session->userauth_pswd_data, rc = _libssh2_transport_send(session, session->userauth_pswd_data,
session->userauth_pswd_data_len, session->userauth_pswd_data_len,
password, password_len); password, password_len);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block writing password request"); "Would block writing password request");
} }
@@ -256,7 +257,7 @@ userauth_password(LIBSSH2_SESSION *session,
LIBSSH2_FREE(session, session->userauth_pswd_data); LIBSSH2_FREE(session, session->userauth_pswd_data);
session->userauth_pswd_data = NULL; session->userauth_pswd_data = NULL;
if (rc) { if(rc) {
session->userauth_pswd_state = libssh2_NB_state_idle; session->userauth_pswd_state = libssh2_NB_state_idle;
return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
"Unable to send userauth-password request"); "Unable to send userauth-password request");
@@ -267,10 +268,10 @@ userauth_password(LIBSSH2_SESSION *session,
password_response: password_response:
if ((session->userauth_pswd_state == libssh2_NB_state_sent) if((session->userauth_pswd_state == libssh2_NB_state_sent)
|| (session->userauth_pswd_state == libssh2_NB_state_sent1) || (session->userauth_pswd_state == libssh2_NB_state_sent1)
|| (session->userauth_pswd_state == libssh2_NB_state_sent2)) { || (session->userauth_pswd_state == libssh2_NB_state_sent2)) {
if (session->userauth_pswd_state == libssh2_NB_state_sent) { if(session->userauth_pswd_state == libssh2_NB_state_sent) {
rc = _libssh2_packet_requirev(session, reply_codes, rc = _libssh2_packet_requirev(session, reply_codes,
&session->userauth_pswd_data, &session->userauth_pswd_data,
&session->userauth_pswd_data_len, &session->userauth_pswd_data_len,
@@ -278,15 +279,15 @@ userauth_password(LIBSSH2_SESSION *session,
&session-> &session->
userauth_pswd_packet_requirev_state); userauth_pswd_packet_requirev_state);
if (rc) { if(rc) {
if (rc != LIBSSH2_ERROR_EAGAIN) if(rc != LIBSSH2_ERROR_EAGAIN)
session->userauth_pswd_state = libssh2_NB_state_idle; session->userauth_pswd_state = libssh2_NB_state_idle;
return _libssh2_error(session, rc, return _libssh2_error(session, rc,
"Waiting for password response"); "Waiting for password response");
} }
if (session->userauth_pswd_data[0] == SSH_MSG_USERAUTH_SUCCESS) { if(session->userauth_pswd_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
_libssh2_debug(session, LIBSSH2_TRACE_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Password authentication successful"); "Password authentication successful");
LIBSSH2_FREE(session, session->userauth_pswd_data); LIBSSH2_FREE(session, session->userauth_pswd_data);
@@ -294,7 +295,8 @@ userauth_password(LIBSSH2_SESSION *session,
session->state |= LIBSSH2_STATE_AUTHENTICATED; session->state |= LIBSSH2_STATE_AUTHENTICATED;
session->userauth_pswd_state = libssh2_NB_state_idle; session->userauth_pswd_state = libssh2_NB_state_idle;
return 0; return 0;
} else if (session->userauth_pswd_data[0] == SSH_MSG_USERAUTH_FAILURE) { }
else if(session->userauth_pswd_data[0] == SSH_MSG_USERAUTH_FAILURE) {
_libssh2_debug(session, LIBSSH2_TRACE_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Password authentication failed"); "Password authentication failed");
LIBSSH2_FREE(session, session->userauth_pswd_data); LIBSSH2_FREE(session, session->userauth_pswd_data);
@@ -312,27 +314,27 @@ userauth_password(LIBSSH2_SESSION *session,
session->userauth_pswd_state = libssh2_NB_state_sent1; session->userauth_pswd_state = libssh2_NB_state_sent1;
} }
if ((session->userauth_pswd_data[0] == if((session->userauth_pswd_data[0] ==
SSH_MSG_USERAUTH_PASSWD_CHANGEREQ) SSH_MSG_USERAUTH_PASSWD_CHANGEREQ)
|| (session->userauth_pswd_data0 == || (session->userauth_pswd_data0 ==
SSH_MSG_USERAUTH_PASSWD_CHANGEREQ)) { SSH_MSG_USERAUTH_PASSWD_CHANGEREQ)) {
session->userauth_pswd_data0 = SSH_MSG_USERAUTH_PASSWD_CHANGEREQ; session->userauth_pswd_data0 = SSH_MSG_USERAUTH_PASSWD_CHANGEREQ;
if ((session->userauth_pswd_state == libssh2_NB_state_sent1) || if((session->userauth_pswd_state == libssh2_NB_state_sent1) ||
(session->userauth_pswd_state == libssh2_NB_state_sent2)) { (session->userauth_pswd_state == libssh2_NB_state_sent2)) {
if (session->userauth_pswd_state == libssh2_NB_state_sent1) { if(session->userauth_pswd_state == libssh2_NB_state_sent1) {
_libssh2_debug(session, LIBSSH2_TRACE_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Password change required"); "Password change required");
LIBSSH2_FREE(session, session->userauth_pswd_data); LIBSSH2_FREE(session, session->userauth_pswd_data);
session->userauth_pswd_data = NULL; session->userauth_pswd_data = NULL;
} }
if (passwd_change_cb) { if(passwd_change_cb) {
if (session->userauth_pswd_state == libssh2_NB_state_sent1) { if(session->userauth_pswd_state == libssh2_NB_state_sent1) {
passwd_change_cb(session, passwd_change_cb(session,
&session->userauth_pswd_newpw, &session->userauth_pswd_newpw,
&session->userauth_pswd_newpw_len, &session->userauth_pswd_newpw_len,
&session->abstract); &session->abstract);
if (!session->userauth_pswd_newpw) { if(!session->userauth_pswd_newpw) {
return _libssh2_error(session, return _libssh2_error(session,
LIBSSH2_ERROR_PASSWORD_EXPIRED, LIBSSH2_ERROR_PASSWORD_EXPIRED,
"Password expired, and " "Password expired, and "
@@ -346,7 +348,7 @@ userauth_password(LIBSSH2_SESSION *session,
s = session->userauth_pswd_data = s = session->userauth_pswd_data =
LIBSSH2_ALLOC(session, LIBSSH2_ALLOC(session,
session->userauth_pswd_data_len); session->userauth_pswd_data_len);
if (!session->userauth_pswd_data) { if(!session->userauth_pswd_data) {
LIBSSH2_FREE(session, LIBSSH2_FREE(session,
session->userauth_pswd_newpw); session->userauth_pswd_newpw);
session->userauth_pswd_newpw = NULL; session->userauth_pswd_newpw = NULL;
@@ -371,14 +373,14 @@ userauth_password(LIBSSH2_SESSION *session,
session->userauth_pswd_state = libssh2_NB_state_sent2; session->userauth_pswd_state = libssh2_NB_state_sent2;
} }
if (session->userauth_pswd_state == libssh2_NB_state_sent2) { if(session->userauth_pswd_state == libssh2_NB_state_sent2) {
rc = _libssh2_transport_send(session, rc = _libssh2_transport_send(session,
session->userauth_pswd_data, session->userauth_pswd_data,
session->userauth_pswd_data_len, session->userauth_pswd_data_len,
(unsigned char *) (unsigned char *)
session->userauth_pswd_newpw, session->userauth_pswd_newpw,
session->userauth_pswd_newpw_len); session->userauth_pswd_newpw_len);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block waiting"); "Would block waiting");
} }
@@ -389,7 +391,7 @@ userauth_password(LIBSSH2_SESSION *session,
LIBSSH2_FREE(session, session->userauth_pswd_newpw); LIBSSH2_FREE(session, session->userauth_pswd_newpw);
session->userauth_pswd_newpw = NULL; session->userauth_pswd_newpw = NULL;
if (rc) { if(rc) {
return _libssh2_error(session, return _libssh2_error(session,
LIBSSH2_ERROR_SOCKET_SEND, LIBSSH2_ERROR_SOCKET_SEND,
"Unable to send userauth " "Unable to send userauth "
@@ -404,7 +406,8 @@ userauth_password(LIBSSH2_SESSION *session,
goto password_response; goto password_response;
} }
} }
} else { }
else {
session->userauth_pswd_state = libssh2_NB_state_idle; session->userauth_pswd_state = libssh2_NB_state_idle;
return _libssh2_error(session, LIBSSH2_ERROR_PASSWORD_EXPIRED, return _libssh2_error(session, LIBSSH2_ERROR_PASSWORD_EXPIRED,
"Password Expired, and no callback " "Password Expired, and no callback "
@@ -454,13 +457,13 @@ memory_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
size_t pubkey_len = pubkeyfiledata_len; size_t pubkey_len = pubkeyfiledata_len;
unsigned int tmp_len; unsigned int tmp_len;
if (pubkeyfiledata_len <= 1) { if(pubkeyfiledata_len <= 1) {
return _libssh2_error(session, LIBSSH2_ERROR_FILE, return _libssh2_error(session, LIBSSH2_ERROR_FILE,
"Invalid data in public key file"); "Invalid data in public key file");
} }
pubkey = LIBSSH2_ALLOC(session, pubkeyfiledata_len); pubkey = LIBSSH2_ALLOC(session, pubkeyfiledata_len);
if (!pubkey) { if(!pubkey) {
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for public key data"); "Unable to allocate memory for public key data");
} }
@@ -470,16 +473,17 @@ memory_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
/* /*
* Remove trailing whitespace * Remove trailing whitespace
*/ */
while (pubkey_len && isspace(pubkey[pubkey_len - 1])) while(pubkey_len && isspace(pubkey[pubkey_len - 1]))
pubkey_len--; pubkey_len--;
if (!pubkey_len) { if(!pubkey_len) {
LIBSSH2_FREE(session, pubkey); LIBSSH2_FREE(session, pubkey);
return _libssh2_error(session, LIBSSH2_ERROR_FILE, return _libssh2_error(session, LIBSSH2_ERROR_FILE,
"Missing public key data"); "Missing public key data");
} }
if ((sp1 = memchr(pubkey, ' ', pubkey_len)) == NULL) { sp1 = memchr(pubkey, ' ', pubkey_len);
if(sp1 == NULL) {
LIBSSH2_FREE(session, pubkey); LIBSSH2_FREE(session, pubkey);
return _libssh2_error(session, LIBSSH2_ERROR_FILE, return _libssh2_error(session, LIBSSH2_ERROR_FILE,
"Invalid public key data"); "Invalid public key data");
@@ -487,12 +491,13 @@ memory_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
sp1++; sp1++;
if ((sp2 = memchr(sp1, ' ', pubkey_len - (sp1 - pubkey - 1))) == NULL) { sp2 = memchr(sp1, ' ', pubkey_len - (sp1 - pubkey - 1));
if(sp2 == NULL) {
/* Assume that the id string is missing, but that it's okay */ /* Assume that the id string is missing, but that it's okay */
sp2 = pubkey + pubkey_len; sp2 = pubkey + pubkey_len;
} }
if (libssh2_base64_decode(session, (char **) &tmp, &tmp_len, if(libssh2_base64_decode(session, (char **) &tmp, &tmp_len,
(char *) sp1, sp2 - sp1)) { (char *) sp1, sp2 - sp1)) {
LIBSSH2_FREE(session, pubkey); LIBSSH2_FREE(session, pubkey);
return _libssh2_error(session, LIBSSH2_ERROR_FILE, return _libssh2_error(session, LIBSSH2_ERROR_FILE,
@@ -539,28 +544,28 @@ file_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
pubkeyfile); pubkeyfile);
/* Read Public Key */ /* Read Public Key */
fd = fopen(pubkeyfile, "r"); fd = fopen(pubkeyfile, "r");
if (!fd) { if(!fd) {
return _libssh2_error(session, LIBSSH2_ERROR_FILE, return _libssh2_error(session, LIBSSH2_ERROR_FILE,
"Unable to open public key file"); "Unable to open public key file");
} }
while (!feof(fd) && 1 == fread(&c, 1, 1, fd) && c != '\r' && c != '\n') { while(!feof(fd) && 1 == fread(&c, 1, 1, fd) && c != '\r' && c != '\n') {
pubkey_len++; pubkey_len++;
} }
rewind(fd); rewind(fd);
if (pubkey_len <= 1) { if(pubkey_len <= 1) {
fclose(fd); fclose(fd);
return _libssh2_error(session, LIBSSH2_ERROR_FILE, return _libssh2_error(session, LIBSSH2_ERROR_FILE,
"Invalid data in public key file"); "Invalid data in public key file");
} }
pubkey = LIBSSH2_ALLOC(session, pubkey_len); pubkey = LIBSSH2_ALLOC(session, pubkey_len);
if (!pubkey) { if(!pubkey) {
fclose(fd); fclose(fd);
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for public key data"); "Unable to allocate memory for public key data");
} }
if (fread(pubkey, 1, pubkey_len, fd) != pubkey_len) { if(fread(pubkey, 1, pubkey_len, fd) != pubkey_len) {
LIBSSH2_FREE(session, pubkey); LIBSSH2_FREE(session, pubkey);
fclose(fd); fclose(fd);
return _libssh2_error(session, LIBSSH2_ERROR_FILE, return _libssh2_error(session, LIBSSH2_ERROR_FILE,
@@ -570,17 +575,18 @@ file_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
/* /*
* Remove trailing whitespace * Remove trailing whitespace
*/ */
while (pubkey_len && isspace(pubkey[pubkey_len - 1])) { while(pubkey_len && isspace(pubkey[pubkey_len - 1])) {
pubkey_len--; pubkey_len--;
} }
if (!pubkey_len) { if(!pubkey_len) {
LIBSSH2_FREE(session, pubkey); LIBSSH2_FREE(session, pubkey);
return _libssh2_error(session, LIBSSH2_ERROR_FILE, return _libssh2_error(session, LIBSSH2_ERROR_FILE,
"Missing public key data"); "Missing public key data");
} }
if ((sp1 = memchr(pubkey, ' ', pubkey_len)) == NULL) { sp1 = memchr(pubkey, ' ', pubkey_len);
if(sp1 == NULL) {
LIBSSH2_FREE(session, pubkey); LIBSSH2_FREE(session, pubkey);
return _libssh2_error(session, LIBSSH2_ERROR_FILE, return _libssh2_error(session, LIBSSH2_ERROR_FILE,
"Invalid public key data"); "Invalid public key data");
@@ -589,12 +595,13 @@ file_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
sp1++; sp1++;
sp_len = sp1 > pubkey ? (sp1 - pubkey) - 1 : 0; sp_len = sp1 > pubkey ? (sp1 - pubkey) - 1 : 0;
if ((sp2 = memchr(sp1, ' ', pubkey_len - sp_len)) == NULL) { sp2 = memchr(sp1, ' ', pubkey_len - sp_len);
if(sp2 == NULL) {
/* Assume that the id string is missing, but that it's okay */ /* Assume that the id string is missing, but that it's okay */
sp2 = pubkey + pubkey_len; sp2 = pubkey + pubkey_len;
} }
if (libssh2_base64_decode(session, (char **) &tmp, &tmp_len, if(libssh2_base64_decode(session, (char **) &tmp, &tmp_len,
(char *) sp1, sp2 - sp1)) { (char *) sp1, sp2 - sp1)) {
LIBSSH2_FREE(session, pubkey); LIBSSH2_FREE(session, pubkey);
return _libssh2_error(session, LIBSSH2_ERROR_FILE, return _libssh2_error(session, LIBSSH2_ERROR_FILE,
@@ -626,8 +633,8 @@ memory_read_privatekey(LIBSSH2_SESSION * session,
*hostkey_method = NULL; *hostkey_method = NULL;
*hostkey_abstract = NULL; *hostkey_abstract = NULL;
while (*hostkey_methods_avail && (*hostkey_methods_avail)->name) { while(*hostkey_methods_avail && (*hostkey_methods_avail)->name) {
if ((*hostkey_methods_avail)->initPEMFromMemory if((*hostkey_methods_avail)->initPEMFromMemory
&& strncmp((*hostkey_methods_avail)->name, (const char *) method, && strncmp((*hostkey_methods_avail)->name, (const char *) method,
method_len) == 0) { method_len) == 0) {
*hostkey_method = *hostkey_methods_avail; *hostkey_method = *hostkey_methods_avail;
@@ -635,12 +642,12 @@ memory_read_privatekey(LIBSSH2_SESSION * session,
} }
hostkey_methods_avail++; hostkey_methods_avail++;
} }
if (!*hostkey_method) { if(!*hostkey_method) {
return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NONE, return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NONE,
"No handler for specified private key"); "No handler for specified private key");
} }
if ((*hostkey_method)-> if((*hostkey_method)->
initPEMFromMemory(session, privkeyfiledata, privkeyfiledata_len, initPEMFromMemory(session, privkeyfiledata, privkeyfiledata_len,
(unsigned char *) passphrase, (unsigned char *) passphrase,
hostkey_abstract)) { hostkey_abstract)) {
@@ -668,8 +675,8 @@ file_read_privatekey(LIBSSH2_SESSION * session,
privkeyfile); privkeyfile);
*hostkey_method = NULL; *hostkey_method = NULL;
*hostkey_abstract = NULL; *hostkey_abstract = NULL;
while (*hostkey_methods_avail && (*hostkey_methods_avail)->name) { while(*hostkey_methods_avail && (*hostkey_methods_avail)->name) {
if ((*hostkey_methods_avail)->initPEM if((*hostkey_methods_avail)->initPEM
&& strncmp((*hostkey_methods_avail)->name, (const char *) method, && strncmp((*hostkey_methods_avail)->name, (const char *) method,
method_len) == 0) { method_len) == 0) {
*hostkey_method = *hostkey_methods_avail; *hostkey_method = *hostkey_methods_avail;
@@ -677,12 +684,12 @@ file_read_privatekey(LIBSSH2_SESSION * session,
} }
hostkey_methods_avail++; hostkey_methods_avail++;
} }
if (!*hostkey_method) { if(!*hostkey_method) {
return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NONE, return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NONE,
"No handler for specified private key"); "No handler for specified private key");
} }
if ((*hostkey_method)-> if((*hostkey_method)->
initPEM(session, privkeyfile, (unsigned char *) passphrase, initPEM(session, privkeyfile, (unsigned char *) passphrase,
hostkey_abstract)) { hostkey_abstract)) {
return _libssh2_error(session, LIBSSH2_ERROR_FILE, return _libssh2_error(session, LIBSSH2_ERROR_FILE,
@@ -720,15 +727,15 @@ sign_frommemory(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
datavec.iov_base = (void *)data; datavec.iov_base = (void *)data;
datavec.iov_len = data_len; datavec.iov_len = data_len;
if (privkeyobj->signv(session, sig, sig_len, 1, &datavec, if(privkeyobj->signv(session, sig, sig_len, 1, &datavec,
&hostkey_abstract)) { &hostkey_abstract)) {
if (privkeyobj->dtor) { if(privkeyobj->dtor) {
privkeyobj->dtor(session, abstract); privkeyobj->dtor(session, abstract);
} }
return -1; return -1;
} }
if (privkeyobj->dtor) { if(privkeyobj->dtor) {
privkeyobj->dtor(session, &hostkey_abstract); privkeyobj->dtor(session, &hostkey_abstract);
} }
return 0; return 0;
@@ -756,15 +763,15 @@ sign_fromfile(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
datavec.iov_base = (void *)data; datavec.iov_base = (void *)data;
datavec.iov_len = data_len; datavec.iov_len = data_len;
if (privkeyobj->signv(session, sig, sig_len, 1, &datavec, if(privkeyobj->signv(session, sig, sig_len, 1, &datavec,
&hostkey_abstract)) { &hostkey_abstract)) {
if (privkeyobj->dtor) { if(privkeyobj->dtor) {
privkeyobj->dtor(session, &hostkey_abstract); privkeyobj->dtor(session, &hostkey_abstract);
} }
return -1; return -1;
} }
if (privkeyobj->dtor) { if(privkeyobj->dtor) {
privkeyobj->dtor(session, &hostkey_abstract); privkeyobj->dtor(session, &hostkey_abstract);
} }
return 0; return 0;
@@ -791,7 +798,7 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
"RSA is not supported by crypto backend"); "RSA is not supported by crypto backend");
#endif #endif
if (session->userauth_host_state == libssh2_NB_state_idle) { if(session->userauth_host_state == libssh2_NB_state_idle) {
const LIBSSH2_HOSTKEY_METHOD *privkeyobj; const LIBSSH2_HOSTKEY_METHOD *privkeyobj;
unsigned char *pubkeydata, *sig = NULL; unsigned char *pubkeydata, *sig = NULL;
size_t pubkeydata_len = 0; size_t pubkeydata_len = 0;
@@ -804,7 +811,7 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
memset(&session->userauth_host_packet_requirev_state, 0, memset(&session->userauth_host_packet_requirev_state, 0,
sizeof(session->userauth_host_packet_requirev_state)); sizeof(session->userauth_host_packet_requirev_state));
if (publickey) { if(publickey) {
rc = file_read_publickey(session, &session->userauth_host_method, rc = file_read_publickey(session, &session->userauth_host_method,
&session->userauth_host_method_len, &session->userauth_host_method_len,
&pubkeydata, &pubkeydata_len, publickey); &pubkeydata, &pubkeydata_len, publickey);
@@ -819,7 +826,7 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
&session->userauth_host_method_len, &session->userauth_host_method_len,
&pubkeydata, &pubkeydata_len, &pubkeydata, &pubkeydata_len,
privatekey, passphrase); privatekey, passphrase);
if (rc) if(rc)
/* libssh2_pub_priv_keyfile calls _libssh2_error() */ /* libssh2_pub_priv_keyfile calls _libssh2_error() */
return rc; return rc;
} }
@@ -844,7 +851,7 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
session->userauth_host_packet_len + 4 + session->userauth_host_packet_len + 4 +
(4 + session->userauth_host_method_len) + (4 + session->userauth_host_method_len) +
(4 + pubkeydata_len)); (4 + pubkeydata_len));
if (!session->userauth_host_packet) { if(!session->userauth_host_packet) {
LIBSSH2_FREE(session, session->userauth_host_method); LIBSSH2_FREE(session, session->userauth_host_method);
session->userauth_host_method = NULL; session->userauth_host_method = NULL;
LIBSSH2_FREE(session, pubkeydata); LIBSSH2_FREE(session, pubkeydata);
@@ -888,31 +895,31 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
datavec[2].iov_base = (void *)session->userauth_host_packet; datavec[2].iov_base = (void *)session->userauth_host_packet;
datavec[2].iov_len = session->userauth_host_packet_len; datavec[2].iov_len = session->userauth_host_packet_len;
if (privkeyobj && privkeyobj->signv && if(privkeyobj && privkeyobj->signv &&
privkeyobj->signv(session, &sig, &sig_len, 3, privkeyobj->signv(session, &sig, &sig_len, 3,
datavec, &abstract)) { datavec, &abstract)) {
LIBSSH2_FREE(session, session->userauth_host_method); LIBSSH2_FREE(session, session->userauth_host_method);
session->userauth_host_method = NULL; session->userauth_host_method = NULL;
LIBSSH2_FREE(session, session->userauth_host_packet); LIBSSH2_FREE(session, session->userauth_host_packet);
session->userauth_host_packet = NULL; session->userauth_host_packet = NULL;
if (privkeyobj->dtor) { if(privkeyobj->dtor) {
privkeyobj->dtor(session, &abstract); privkeyobj->dtor(session, &abstract);
} }
return -1; return -1;
} }
if (privkeyobj && privkeyobj->dtor) { if(privkeyobj && privkeyobj->dtor) {
privkeyobj->dtor(session, &abstract); privkeyobj->dtor(session, &abstract);
} }
if (sig_len > pubkeydata_len) { if(sig_len > pubkeydata_len) {
unsigned char *newpacket; unsigned char *newpacket;
/* Should *NEVER* happen, but...well.. better safe than sorry */ /* Should *NEVER* happen, but...well.. better safe than sorry */
newpacket = LIBSSH2_REALLOC(session, session->userauth_host_packet, newpacket = LIBSSH2_REALLOC(session, session->userauth_host_packet,
session->userauth_host_packet_len + 4 + session->userauth_host_packet_len + 4 +
(4 + session->userauth_host_method_len) (4 + session->userauth_host_method_len)
+ (4 + sig_len)); /* PK sigblob */ + (4 + sig_len)); /* PK sigblob */
if (!newpacket) { if(!newpacket) {
LIBSSH2_FREE(session, sig); LIBSSH2_FREE(session, sig);
LIBSSH2_FREE(session, session->userauth_host_packet); LIBSSH2_FREE(session, session->userauth_host_packet);
session->userauth_host_packet = NULL; session->userauth_host_packet = NULL;
@@ -946,15 +953,15 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
session->userauth_host_state = libssh2_NB_state_created; session->userauth_host_state = libssh2_NB_state_created;
} }
if (session->userauth_host_state == libssh2_NB_state_created) { if(session->userauth_host_state == libssh2_NB_state_created) {
rc = _libssh2_transport_send(session, session->userauth_host_packet, rc = _libssh2_transport_send(session, session->userauth_host_packet,
session->userauth_host_s - session->userauth_host_s -
session->userauth_host_packet, session->userauth_host_packet,
NULL, 0); NULL, 0);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block"); return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
} }
else if (rc) { else if(rc) {
LIBSSH2_FREE(session, session->userauth_host_packet); LIBSSH2_FREE(session, session->userauth_host_packet);
session->userauth_host_packet = NULL; session->userauth_host_packet = NULL;
session->userauth_host_state = libssh2_NB_state_idle; session->userauth_host_state = libssh2_NB_state_idle;
@@ -967,7 +974,7 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
session->userauth_host_state = libssh2_NB_state_sent; session->userauth_host_state = libssh2_NB_state_sent;
} }
if (session->userauth_host_state == libssh2_NB_state_sent) { if(session->userauth_host_state == libssh2_NB_state_sent) {
static const unsigned char reply_codes[3] = static const unsigned char reply_codes[3] =
{ SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, 0 }; { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, 0 };
size_t data_len; size_t data_len;
@@ -976,17 +983,17 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
&data_len, 0, NULL, 0, &data_len, 0, NULL, 0,
&session-> &session->
userauth_host_packet_requirev_state); userauth_host_packet_requirev_state);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block"); return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
} }
session->userauth_host_state = libssh2_NB_state_idle; session->userauth_host_state = libssh2_NB_state_idle;
if (rc) { if(rc) {
return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED, return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
"Auth failed"); "Auth failed");
} }
if (session->userauth_host_data[0] == SSH_MSG_USERAUTH_SUCCESS) { if(session->userauth_host_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
_libssh2_debug(session, LIBSSH2_TRACE_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Hostbased authentication successful"); "Hostbased authentication successful");
/* We are us and we've proved it. */ /* We are us and we've proved it. */
@@ -1047,13 +1054,13 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
int rc; int rc;
unsigned char *s; unsigned char *s;
if (session->userauth_pblc_state == libssh2_NB_state_idle) { if(session->userauth_pblc_state == libssh2_NB_state_idle) {
/* /*
* The call to _libssh2_ntohu32 later relies on pubkeydata having at * The call to _libssh2_ntohu32 later relies on pubkeydata having at
* least 4 valid bytes containing the length of the method name. * least 4 valid bytes containing the length of the method name.
*/ */
if (pubkeydata_len < 4) if(pubkeydata_len < 4)
return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED, return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
"Invalid public key, too short"); "Invalid public key, too short");
@@ -1067,7 +1074,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
* allocation/free. * allocation/free.
* For other uses, we allocate and populate it here. * For other uses, we allocate and populate it here.
*/ */
if (!session->userauth_pblc_method) { if(!session->userauth_pblc_method) {
session->userauth_pblc_method_len = _libssh2_ntohu32(pubkeydata); session->userauth_pblc_method_len = _libssh2_ntohu32(pubkeydata);
if(session->userauth_pblc_method_len > pubkeydata_len) if(session->userauth_pblc_method_len > pubkeydata_len)
@@ -1080,7 +1087,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
session->userauth_pblc_method = session->userauth_pblc_method =
LIBSSH2_ALLOC(session, session->userauth_pblc_method_len); LIBSSH2_ALLOC(session, session->userauth_pblc_method_len);
if (!session->userauth_pblc_method) { if(!session->userauth_pblc_method) {
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for public key " "Unable to allocate memory for public key "
"data"); "data");
@@ -1093,7 +1100,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
* file must match length embedded in the key. * file must match length embedded in the key.
* TODO: The data should match too but we don't check that. Should we? * TODO: The data should match too but we don't check that. Should we?
*/ */
else if (session->userauth_pblc_method_len != else if(session->userauth_pblc_method_len !=
_libssh2_ntohu32(pubkeydata)) _libssh2_ntohu32(pubkeydata))
return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED, return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
"Invalid public key"); "Invalid public key");
@@ -1122,7 +1129,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
session->userauth_pblc_packet_len + 4 + session->userauth_pblc_packet_len + 4 +
(4 + session->userauth_pblc_method_len) (4 + session->userauth_pblc_method_len)
+ (4 + pubkeydata_len)); + (4 + pubkeydata_len));
if (!session->userauth_pblc_packet) { if(!session->userauth_pblc_packet) {
LIBSSH2_FREE(session, session->userauth_pblc_method); LIBSSH2_FREE(session, session->userauth_pblc_method);
session->userauth_pblc_method = NULL; session->userauth_pblc_method = NULL;
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
@@ -1148,13 +1155,13 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
session->userauth_pblc_state = libssh2_NB_state_created; session->userauth_pblc_state = libssh2_NB_state_created;
} }
if (session->userauth_pblc_state == libssh2_NB_state_created) { if(session->userauth_pblc_state == libssh2_NB_state_created) {
rc = _libssh2_transport_send(session, session->userauth_pblc_packet, rc = _libssh2_transport_send(session, session->userauth_pblc_packet,
session->userauth_pblc_packet_len, session->userauth_pblc_packet_len,
NULL, 0); NULL, 0);
if (rc == LIBSSH2_ERROR_EAGAIN) if(rc == LIBSSH2_ERROR_EAGAIN)
return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block"); return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
else if (rc) { else if(rc) {
LIBSSH2_FREE(session, session->userauth_pblc_packet); LIBSSH2_FREE(session, session->userauth_pblc_packet);
session->userauth_pblc_packet = NULL; session->userauth_pblc_packet = NULL;
LIBSSH2_FREE(session, session->userauth_pblc_method); LIBSSH2_FREE(session, session->userauth_pblc_method);
@@ -1167,17 +1174,17 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
session->userauth_pblc_state = libssh2_NB_state_sent; session->userauth_pblc_state = libssh2_NB_state_sent;
} }
if (session->userauth_pblc_state == libssh2_NB_state_sent) { if(session->userauth_pblc_state == libssh2_NB_state_sent) {
rc = _libssh2_packet_requirev(session, reply_codes, rc = _libssh2_packet_requirev(session, reply_codes,
&session->userauth_pblc_data, &session->userauth_pblc_data,
&session->userauth_pblc_data_len, 0, &session->userauth_pblc_data_len, 0,
NULL, 0, NULL, 0,
&session-> &session->
userauth_pblc_packet_requirev_state); userauth_pblc_packet_requirev_state);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block"); return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
} }
else if (rc) { else if(rc) {
LIBSSH2_FREE(session, session->userauth_pblc_packet); LIBSSH2_FREE(session, session->userauth_pblc_packet);
session->userauth_pblc_packet = NULL; session->userauth_pblc_packet = NULL;
LIBSSH2_FREE(session, session->userauth_pblc_method); LIBSSH2_FREE(session, session->userauth_pblc_method);
@@ -1187,7 +1194,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
"Waiting for USERAUTH response"); "Waiting for USERAUTH response");
} }
if (session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) { if(session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
_libssh2_debug(session, LIBSSH2_TRACE_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Pubkey authentication prematurely successful"); "Pubkey authentication prematurely successful");
/* /*
@@ -1205,7 +1212,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
return 0; return 0;
} }
if (session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_FAILURE) { if(session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_FAILURE) {
/* This public key is not allowed for this user on this server */ /* This public key is not allowed for this user on this server */
LIBSSH2_FREE(session, session->userauth_pblc_data); LIBSSH2_FREE(session, session->userauth_pblc_data);
session->userauth_pblc_data = NULL; session->userauth_pblc_data = NULL;
@@ -1226,14 +1233,14 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
session->userauth_pblc_state = libssh2_NB_state_sent1; session->userauth_pblc_state = libssh2_NB_state_sent1;
} }
if (session->userauth_pblc_state == libssh2_NB_state_sent1) { if(session->userauth_pblc_state == libssh2_NB_state_sent1) {
unsigned char *buf; unsigned char *buf;
unsigned char *sig; unsigned char *sig;
size_t sig_len; size_t sig_len;
s = buf = LIBSSH2_ALLOC(session, 4 + session->session_id_len s = buf = LIBSSH2_ALLOC(session, 4 + session->session_id_len
+ session->userauth_pblc_packet_len); + session->userauth_pblc_packet_len);
if (!buf) { if(!buf) {
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for " "Unable to allocate memory for "
"userauth-publickey signed data"); "userauth-publickey signed data");
@@ -1242,15 +1249,16 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
_libssh2_store_str(&s, (const char *)session->session_id, _libssh2_store_str(&s, (const char *)session->session_id,
session->session_id_len); session->session_id_len);
memcpy (s, session->userauth_pblc_packet, memcpy(s, session->userauth_pblc_packet,
session->userauth_pblc_packet_len); session->userauth_pblc_packet_len);
s += session->userauth_pblc_packet_len; s += session->userauth_pblc_packet_len;
rc = sign_callback(session, &sig, &sig_len, buf, s - buf, abstract); rc = sign_callback(session, &sig, &sig_len, buf, s - buf, abstract);
LIBSSH2_FREE(session, buf); LIBSSH2_FREE(session, buf);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block"); return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
} else if (rc) { }
else if(rc) {
LIBSSH2_FREE(session, session->userauth_pblc_method); LIBSSH2_FREE(session, session->userauth_pblc_method);
session->userauth_pblc_method = NULL; session->userauth_pblc_method = NULL;
LIBSSH2_FREE(session, session->userauth_pblc_packet); LIBSSH2_FREE(session, session->userauth_pblc_packet);
@@ -1264,7 +1272,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
* If this function was restarted, pubkeydata_len might still be 0 * If this function was restarted, pubkeydata_len might still be 0
* which will cause an unnecessary but harmless realloc here. * which will cause an unnecessary but harmless realloc here.
*/ */
if (sig_len > pubkeydata_len) { if(sig_len > pubkeydata_len) {
unsigned char *newpacket; unsigned char *newpacket;
/* Should *NEVER* happen, but...well.. better safe than sorry */ /* Should *NEVER* happen, but...well.. better safe than sorry */
newpacket = LIBSSH2_REALLOC(session, newpacket = LIBSSH2_REALLOC(session,
@@ -1272,7 +1280,7 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
session->userauth_pblc_packet_len + 4 + session->userauth_pblc_packet_len + 4 +
(4 + session->userauth_pblc_method_len) (4 + session->userauth_pblc_method_len)
+ (4 + sig_len)); /* PK sigblob */ + (4 + sig_len)); /* PK sigblob */
if (!newpacket) { if(!newpacket) {
LIBSSH2_FREE(session, sig); LIBSSH2_FREE(session, sig);
LIBSSH2_FREE(session, session->userauth_pblc_packet); LIBSSH2_FREE(session, session->userauth_pblc_packet);
session->userauth_pblc_packet = NULL; session->userauth_pblc_packet = NULL;
@@ -1307,14 +1315,15 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
session->userauth_pblc_state = libssh2_NB_state_sent2; session->userauth_pblc_state = libssh2_NB_state_sent2;
} }
if (session->userauth_pblc_state == libssh2_NB_state_sent2) { if(session->userauth_pblc_state == libssh2_NB_state_sent2) {
rc = _libssh2_transport_send(session, session->userauth_pblc_packet, rc = _libssh2_transport_send(session, session->userauth_pblc_packet,
session->userauth_pblc_s - session->userauth_pblc_s -
session->userauth_pblc_packet, session->userauth_pblc_packet,
NULL, 0); NULL, 0);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block"); return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
} else if (rc) { }
else if(rc) {
LIBSSH2_FREE(session, session->userauth_pblc_packet); LIBSSH2_FREE(session, session->userauth_pblc_packet);
session->userauth_pblc_packet = NULL; session->userauth_pblc_packet = NULL;
session->userauth_pblc_state = libssh2_NB_state_idle; session->userauth_pblc_state = libssh2_NB_state_idle;
@@ -1334,16 +1343,17 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
&session->userauth_pblc_data, &session->userauth_pblc_data,
&session->userauth_pblc_data_len, 0, NULL, 0, &session->userauth_pblc_data_len, 0, NULL, 0,
&session->userauth_pblc_packet_requirev_state); &session->userauth_pblc_packet_requirev_state);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block requesting userauth list"); "Would block requesting userauth list");
} else if (rc) { }
else if(rc) {
session->userauth_pblc_state = libssh2_NB_state_idle; session->userauth_pblc_state = libssh2_NB_state_idle;
return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED, return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
"Waiting for publickey USERAUTH response"); "Waiting for publickey USERAUTH response");
} }
if (session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) { if(session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
_libssh2_debug(session, LIBSSH2_TRACE_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Publickey authentication successful"); "Publickey authentication successful");
/* We are us and we've proved it. */ /* We are us and we've proved it. */
@@ -1391,8 +1401,8 @@ userauth_publickey_frommemory(LIBSSH2_SESSION *session,
privkey_file.filename = privatekeydata; privkey_file.filename = privatekeydata;
privkey_file.passphrase = passphrase; privkey_file.passphrase = passphrase;
if (session->userauth_pblc_state == libssh2_NB_state_idle) { if(session->userauth_pblc_state == libssh2_NB_state_idle) {
if (publickeydata_len && publickeydata) { if(publickeydata_len && publickeydata) {
rc = memory_read_publickey(session, &session->userauth_pblc_method, rc = memory_read_publickey(session, &session->userauth_pblc_method,
&session->userauth_pblc_method_len, &session->userauth_pblc_method_len,
&pubkeydata, &pubkeydata_len, &pubkeydata, &pubkeydata_len,
@@ -1400,9 +1410,9 @@ userauth_publickey_frommemory(LIBSSH2_SESSION *session,
if(rc) if(rc)
return rc; return rc;
} }
else if (privatekeydata_len && privatekeydata) { else if(privatekeydata_len && privatekeydata) {
/* Compute public key from private key. */ /* Compute public key from private key. */
if (_libssh2_pub_priv_keyfilememory(session, if(_libssh2_pub_priv_keyfilememory(session,
&session->userauth_pblc_method, &session->userauth_pblc_method,
&session->userauth_pblc_method_len, &session->userauth_pblc_method_len,
&pubkeydata, &pubkeydata_len, &pubkeydata, &pubkeydata_len,
@@ -1453,12 +1463,12 @@ userauth_publickey_fromfile(LIBSSH2_SESSION *session,
privkey_file.filename = privatekey; privkey_file.filename = privatekey;
privkey_file.passphrase = passphrase; privkey_file.passphrase = passphrase;
if (session->userauth_pblc_state == libssh2_NB_state_idle) { if(session->userauth_pblc_state == libssh2_NB_state_idle) {
if (publickey) { if(publickey) {
rc = file_read_publickey(session, &session->userauth_pblc_method, rc = file_read_publickey(session, &session->userauth_pblc_method,
&session->userauth_pblc_method_len, &session->userauth_pblc_method_len,
&pubkeydata, &pubkeydata_len,publickey); &pubkeydata, &pubkeydata_len, publickey);
if (rc) if(rc)
return rc; return rc;
} }
else { else {
@@ -1470,7 +1480,7 @@ userauth_publickey_fromfile(LIBSSH2_SESSION *session,
privatekey, passphrase); privatekey, passphrase);
/* _libssh2_pub_priv_keyfile calls _libssh2_error() */ /* _libssh2_pub_priv_keyfile calls _libssh2_error() */
if (rc) if(rc)
return rc; return rc;
} }
} }
@@ -1502,7 +1512,7 @@ libssh2_userauth_publickey_frommemory(LIBSSH2_SESSION *session,
if(NULL == passphrase) if(NULL == passphrase)
/* if given a NULL pointer, make it point to a zero-length /* if given a NULL pointer, make it point to a zero-length
string to save us from having to check this all over */ string to save us from having to check this all over */
passphrase=""; passphrase = "";
BLOCK_ADJUST(rc, session, BLOCK_ADJUST(rc, session,
userauth_publickey_frommemory(session, user, user_len, userauth_publickey_frommemory(session, user, user_len,
@@ -1530,7 +1540,7 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
if(NULL == passphrase) if(NULL == passphrase)
/* if given a NULL pointer, make it point to a zero-length /* if given a NULL pointer, make it point to a zero-length
string to save us from having to check this all over */ string to save us from having to check this all over */
passphrase=""; passphrase = "";
BLOCK_ADJUST(rc, session, BLOCK_ADJUST(rc, session,
userauth_publickey_fromfile(session, user, user_len, userauth_publickey_fromfile(session, user, user_len,
@@ -1585,7 +1595,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
unsigned int language_tag_len; unsigned int language_tag_len;
unsigned int i; unsigned int i;
if (session->userauth_kybd_state == libssh2_NB_state_idle) { if(session->userauth_kybd_state == libssh2_NB_state_idle) {
session->userauth_kybd_auth_name = NULL; session->userauth_kybd_auth_name = NULL;
session->userauth_kybd_auth_instruction = NULL; session->userauth_kybd_auth_instruction = NULL;
session->userauth_kybd_num_prompts = 0; session->userauth_kybd_num_prompts = 0;
@@ -1610,7 +1620,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
session->userauth_kybd_data = s = session->userauth_kybd_data = s =
LIBSSH2_ALLOC(session, session->userauth_kybd_packet_len); LIBSSH2_ALLOC(session, session->userauth_kybd_packet_len);
if (!s) { if(!s) {
return _libssh2_error(session, LIBSSH2_ERROR_ALLOC, return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for " "Unable to allocate memory for "
"keyboard-interactive authentication"); "keyboard-interactive authentication");
@@ -1639,13 +1649,14 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
session->userauth_kybd_state = libssh2_NB_state_created; session->userauth_kybd_state = libssh2_NB_state_created;
} }
if (session->userauth_kybd_state == libssh2_NB_state_created) { if(session->userauth_kybd_state == libssh2_NB_state_created) {
rc = _libssh2_transport_send(session, session->userauth_kybd_data, rc = _libssh2_transport_send(session, session->userauth_kybd_data,
session->userauth_kybd_packet_len, session->userauth_kybd_packet_len,
NULL, 0); NULL, 0);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block"); return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
} else if (rc) { }
else if(rc) {
LIBSSH2_FREE(session, session->userauth_kybd_data); LIBSSH2_FREE(session, session->userauth_kybd_data);
session->userauth_kybd_data = NULL; session->userauth_kybd_data = NULL;
session->userauth_kybd_state = libssh2_NB_state_idle; session->userauth_kybd_state = libssh2_NB_state_idle;
@@ -1659,24 +1670,25 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
} }
for(;;) { for(;;) {
if (session->userauth_kybd_state == libssh2_NB_state_sent) { if(session->userauth_kybd_state == libssh2_NB_state_sent) {
rc = _libssh2_packet_requirev(session, reply_codes, rc = _libssh2_packet_requirev(session, reply_codes,
&session->userauth_kybd_data, &session->userauth_kybd_data,
&session->userauth_kybd_data_len, &session->userauth_kybd_data_len,
0, NULL, 0, 0, NULL, 0,
&session-> &session->
userauth_kybd_packet_requirev_state); userauth_kybd_packet_requirev_state);
if (rc == LIBSSH2_ERROR_EAGAIN) { if(rc == LIBSSH2_ERROR_EAGAIN) {
return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block"); "Would block");
} else if (rc) { }
else if(rc) {
session->userauth_kybd_state = libssh2_NB_state_idle; session->userauth_kybd_state = libssh2_NB_state_idle;
return _libssh2_error(session, return _libssh2_error(session,
LIBSSH2_ERROR_AUTHENTICATION_FAILED, LIBSSH2_ERROR_AUTHENTICATION_FAILED,
"Waiting for keyboard USERAUTH response"); "Waiting for keyboard USERAUTH response");
} }
if (session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_SUCCESS) { if(session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
_libssh2_debug(session, LIBSSH2_TRACE_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Keyboard-interactive authentication successful"); "Keyboard-interactive authentication successful");
LIBSSH2_FREE(session, session->userauth_kybd_data); LIBSSH2_FREE(session, session->userauth_kybd_data);
@@ -1686,7 +1698,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
return 0; return 0;
} }
if (session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_FAILURE) { if(session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_FAILURE) {
_libssh2_debug(session, LIBSSH2_TRACE_AUTH, _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
"Keyboard-interactive authentication failed"); "Keyboard-interactive authentication failed");
LIBSSH2_FREE(session, session->userauth_kybd_data); LIBSSH2_FREE(session, session->userauth_kybd_data);
@@ -1708,7 +1720,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
session->userauth_kybd_auth_name = session->userauth_kybd_auth_name =
LIBSSH2_ALLOC(session, LIBSSH2_ALLOC(session,
session->userauth_kybd_auth_name_len); session->userauth_kybd_auth_name_len);
if (!session->userauth_kybd_auth_name) { if(!session->userauth_kybd_auth_name) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for " "Unable to allocate memory for "
"keyboard-interactive 'name' " "keyboard-interactive 'name' "
@@ -1727,7 +1739,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
session->userauth_kybd_auth_instruction = session->userauth_kybd_auth_instruction =
LIBSSH2_ALLOC(session, LIBSSH2_ALLOC(session,
session->userauth_kybd_auth_instruction_len); session->userauth_kybd_auth_instruction_len);
if (!session->userauth_kybd_auth_instruction) { if(!session->userauth_kybd_auth_instruction) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for " "Unable to allocate memory for "
"keyboard-interactive 'instruction' " "keyboard-interactive 'instruction' "
@@ -1755,7 +1767,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
LIBSSH2_CALLOC(session, LIBSSH2_CALLOC(session,
sizeof(LIBSSH2_USERAUTH_KBDINT_PROMPT) * sizeof(LIBSSH2_USERAUTH_KBDINT_PROMPT) *
session->userauth_kybd_num_prompts); session->userauth_kybd_num_prompts);
if (!session->userauth_kybd_prompts) { if(!session->userauth_kybd_prompts) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for " "Unable to allocate memory for "
"keyboard-interactive prompts array"); "keyboard-interactive prompts array");
@@ -1766,7 +1778,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
LIBSSH2_CALLOC(session, LIBSSH2_CALLOC(session,
sizeof(LIBSSH2_USERAUTH_KBDINT_RESPONSE) * sizeof(LIBSSH2_USERAUTH_KBDINT_RESPONSE) *
session->userauth_kybd_num_prompts); session->userauth_kybd_num_prompts);
if (!session->userauth_kybd_responses) { if(!session->userauth_kybd_responses) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for " "Unable to allocate memory for "
"keyboard-interactive responses array"); "keyboard-interactive responses array");
@@ -1781,7 +1793,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
session->userauth_kybd_prompts[i].text = session->userauth_kybd_prompts[i].text =
LIBSSH2_CALLOC(session, LIBSSH2_CALLOC(session,
session->userauth_kybd_prompts[i].length); session->userauth_kybd_prompts[i].length);
if (!session->userauth_kybd_prompts[i].text) { if(!session->userauth_kybd_prompts[i].text) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for " "Unable to allocate memory for "
"keyboard-interactive prompt message"); "keyboard-interactive prompt message");
@@ -1826,7 +1838,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
session->userauth_kybd_data = s = session->userauth_kybd_data = s =
LIBSSH2_ALLOC(session, session->userauth_kybd_packet_len); LIBSSH2_ALLOC(session, session->userauth_kybd_packet_len);
if (!s) { if(!s) {
_libssh2_error(session, LIBSSH2_ERROR_ALLOC, _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
"Unable to allocate memory for keyboard-" "Unable to allocate memory for keyboard-"
"interactive response packet"); "interactive response packet");
@@ -1846,14 +1858,14 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
session->userauth_kybd_state = libssh2_NB_state_sent1; session->userauth_kybd_state = libssh2_NB_state_sent1;
} }
if (session->userauth_kybd_state == libssh2_NB_state_sent1) { if(session->userauth_kybd_state == libssh2_NB_state_sent1) {
rc = _libssh2_transport_send(session, session->userauth_kybd_data, rc = _libssh2_transport_send(session, session->userauth_kybd_data,
session->userauth_kybd_packet_len, session->userauth_kybd_packet_len,
NULL, 0); NULL, 0);
if (rc == LIBSSH2_ERROR_EAGAIN) if(rc == LIBSSH2_ERROR_EAGAIN)
return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
"Would block"); "Would block");
if (rc) { if(rc) {
_libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
"Unable to send userauth-keyboard-interactive" "Unable to send userauth-keyboard-interactive"
" request"); " request");
@@ -1872,14 +1884,14 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
LIBSSH2_FREE(session, session->userauth_kybd_data); LIBSSH2_FREE(session, session->userauth_kybd_data);
session->userauth_kybd_data = NULL; session->userauth_kybd_data = NULL;
if (session->userauth_kybd_prompts) { if(session->userauth_kybd_prompts) {
for(i = 0; i < session->userauth_kybd_num_prompts; i++) { for(i = 0; i < session->userauth_kybd_num_prompts; i++) {
LIBSSH2_FREE(session, session->userauth_kybd_prompts[i].text); LIBSSH2_FREE(session, session->userauth_kybd_prompts[i].text);
session->userauth_kybd_prompts[i].text = NULL; session->userauth_kybd_prompts[i].text = NULL;
} }
} }
if (session->userauth_kybd_responses) { if(session->userauth_kybd_responses) {
for(i = 0; i < session->userauth_kybd_num_prompts; i++) { for(i = 0; i < session->userauth_kybd_num_prompts; i++) {
LIBSSH2_FREE(session, LIBSSH2_FREE(session,
session->userauth_kybd_responses[i].text); session->userauth_kybd_responses[i].text);
@@ -1904,7 +1916,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
session->userauth_kybd_auth_instruction = NULL; session->userauth_kybd_auth_instruction = NULL;
} }
if (session->userauth_kybd_auth_failure) { if(session->userauth_kybd_auth_failure) {
session->userauth_kybd_state = libssh2_NB_state_idle; session->userauth_kybd_state = libssh2_NB_state_idle;
return -1; return -1;
} }

394
src/wincng.c
View File

File diff suppressed because it is too large Load Diff