nhyatt/putty-source
1
0
Fork 0
mirror of https://git.tartarus.org/simon/putty.git synced 2025-01-09 17:38:00 +00:00
Code Issues Projects Releases Wiki Activity

Adopt C99 <stdint.h> integer types.

Browse Source 
The annoying int64.h is completely retired, since C99 guarantees a
64-bit integer type that you can actually treat like an ordinary
integer. Also, I've replaced the local typedefs uint32 and word32
(scattered through different parts of the crypto code) with the
standard uint32_t.
This commit is contained in:
Simon Tatham 2018-10-26 23:08:58 +01:00
parent 5cb56389bd
commit a647f2ba11
29 changed files with 432 additions and 721 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Recipe
View File

@ -267,7 +267,7 @@ WINSSH = SSH winnoise wincapi winpgntc wingss winshare winnps winnpc
UXSSH = SSH uxnoise uxagentc uxgss uxshare
# SFTP implementation (pscp, psftp).
SFTP = sftp sftpcommon int64 logging cmdline
SFTP = sftp sftpcommon logging cmdline
# Miscellaneous objects appearing in all the utilities, or all the
# network ones, or the Unix or Windows subsets of those in turn.
@ -283,7 +283,7 @@ UXMISC = MISCNET UXMISCCOMMON uxproxy
# SSH server.
SSHSERVER = SSHCOMMON sshserver settings be_none logging ssh2kex-server
+ ssh2userauth-server sshrsag sshprime ssh2connection-server
+ sesschan sftpcommon int64 sftpserver proxy cproxy ssh1login-server
+ sesschan sftpcommon sftpserver proxy cproxy ssh1login-server
+ ssh1connection-server scpserver
# import.c and dependencies, for PuTTYgen-like utilities that have to

12
defs.h
View File

@ -12,6 +12,15 @@
#define PUTTY_DEFS_H
#include <stddef.h>
#include <stdint.h>
#if defined _MSC_VER && _MSC_VER < 1800
/* Work around lack of inttypes.h in older MSVC */
#define PRIu64 "I64u"
#define SCNu64 "I64u"
#else
#include <inttypes.h>
#endif
#ifndef FALSE
#define FALSE 0
@ -32,9 +41,6 @@ typedef struct strbuf strbuf;
struct RSAKey;
#include <stdint.h>
typedef uint32_t uint32;
typedef struct BinarySink BinarySink;
typedef struct BinarySource BinarySource;

175
int64.c
View File

@ -1,175 +0,0 @@
/*
* Handling of the int64 and uint64 types. Done in 32-bit integers,
* for (pre-C99) portability. Hopefully once C99 becomes widespread
* we can kiss this lot goodbye...
*/
#include <assert.h>
#include <string.h>
#include "int64.h"
uint64 uint64_div10(uint64 x, int *remainder)
{
uint64 y;
unsigned int rem, r2;
y.hi = x.hi / 10;
y.lo = x.lo / 10;
rem = x.lo % 10;
/*
* Now we have to add in the remainder left over from x.hi.
*/
r2 = x.hi % 10;
y.lo += r2 * 429496729;
rem += r2 * 6;
y.lo += rem / 10;
rem %= 10;
if (remainder)
*remainder = rem;
return y;
}
void uint64_decimal(uint64 x, char *buffer)
{
char buf[20];
int start = 20;
int d;
do {
x = uint64_div10(x, &d);
assert(start > 0);
buf[--start] = d + '0';
} while (x.hi || x.lo);
memcpy(buffer, buf + start, sizeof(buf) - start);
buffer[sizeof(buf) - start] = '\0';
}
uint64 uint64_make(unsigned long hi, unsigned long lo)
{
uint64 y;
y.hi = hi & 0xFFFFFFFFU;
y.lo = lo & 0xFFFFFFFFU;
return y;
}
uint64 uint64_add(uint64 x, uint64 y)
{
x.lo = (x.lo + y.lo) & 0xFFFFFFFFU;
x.hi += y.hi + (x.lo < y.lo ? 1 : 0);
return x;
}
uint64 uint64_add32(uint64 x, unsigned long y)
{
uint64 yy;
yy.hi = 0;
yy.lo = y;
return uint64_add(x, yy);
}
int uint64_compare(uint64 x, uint64 y)
{
if (x.hi != y.hi)
return x.hi < y.hi ? -1 : +1;
if (x.lo != y.lo)
return x.lo < y.lo ? -1 : +1;
return 0;
}
uint64 uint64_subtract(uint64 x, uint64 y)
{
x.lo = (x.lo - y.lo) & 0xFFFFFFFFU;
x.hi = (x.hi - y.hi - (x.lo > (y.lo ^ 0xFFFFFFFFU) ? 1 : 0)) & 0xFFFFFFFFU;
return x;
}
double uint64_to_double(uint64 x)
{
return (4294967296.0 * x.hi) + (double)x.lo;
}
uint64 uint64_shift_right(uint64 x, int shift)
{
if (shift < 32) {
x.lo >>= shift;
x.lo |= (x.hi << (32-shift)) & 0xFFFFFFFFU;
x.hi >>= shift;
} else {
x.lo = x.hi >> (shift-32);
x.hi = 0;
}
return x;
}
uint64 uint64_shift_left(uint64 x, int shift)
{
if (shift < 32) {
x.hi = (x.hi << shift) & 0xFFFFFFFFU;
x.hi |= (x.lo >> (32-shift));
x.lo = (x.lo << shift) & 0xFFFFFFFFU;
} else {
x.hi = (x.lo << (shift-32)) & 0xFFFFFFFFU;
x.lo = 0;
}
return x;
}
uint64 uint64_from_decimal(const char *str)
{
uint64 ret;
ret.hi = ret.lo = 0;
while (*str >= '0' && *str <= '9') {
ret = uint64_add(uint64_shift_left(ret, 3),
uint64_shift_left(ret, 1));
ret = uint64_add32(ret, *str - '0');
str++;
}
return ret;
}
#ifdef TESTMODE
#include <stdio.h>
int main(void)
{
uint64 x, y, z;
char buf[80];
x = uint64_make(0x3456789AUL, 0xDEF01234UL);
printf("%08lx.%08lx\n", x.hi, x.lo);
uint64_decimal(x, buf);
printf("%s\n", buf);
y = uint64_add32(x, 0xFFFFFFFFU);
printf("%08lx.%08lx\n", y.hi, y.lo);
uint64_decimal(y, buf);
printf("%s\n", buf);
z = uint64_subtract(y, x);
printf("%08lx.%08lx\n", z.hi, z.lo);
uint64_decimal(z, buf);
printf("%s\n", buf);
z = uint64_subtract(x, y);
printf("%08lx.%08lx\n", z.hi, z.lo);
uint64_decimal(z, buf);
printf("%s\n", buf);
y = uint64_shift_right(x, 4);
printf("%08lx.%08lx\n", y.hi, y.lo);
y = uint64_shift_right(x, 36);
printf("%08lx.%08lx\n", y.hi, y.lo);
y = uint64_shift_left(x, 4);
printf("%08lx.%08lx\n", x.hi, x.lo);
y = uint64_shift_left(x, 36);
printf("%08lx.%08lx\n", x.hi, x.lo);
return 0;
}
#endif

29
int64.h
View File

@ -1,29 +0,0 @@
/*
* Header for int64.c.
*/
#ifndef PUTTY_INT64_H
#define PUTTY_INT64_H
#include "defs.h"
typedef struct {
unsigned long hi, lo;
} uint64;
uint64 uint64_div10(uint64 x, int *remainder);
void uint64_decimal(uint64 x, char *buffer);
uint64 uint64_make(unsigned long hi, unsigned long lo);
uint64 uint64_add(uint64 x, uint64 y);
uint64 uint64_add32(uint64 x, unsigned long y);
int uint64_compare(uint64 x, uint64 y);
uint64 uint64_subtract(uint64 x, uint64 y);
double uint64_to_double(uint64 x);
uint64 uint64_shift_right(uint64 x, int shift);
uint64 uint64_shift_left(uint64 x, int shift);
uint64 uint64_from_decimal(const char *str);
void BinarySink_put_uint64(BinarySink *, uint64);
uint64 BinarySource_get_uint64(BinarySource *);
#endif

21
marshal.c
View File

@ -4,7 +4,6 @@
#include "marshal.h"
#include "misc.h"
#include "int64.h"
void BinarySink_put_data(BinarySink *bs, const void *data, size_t len)
{
@ -47,10 +46,11 @@ void BinarySink_put_uint32(BinarySink *bs, unsigned long val)
bs->write(bs, data, sizeof(data));
}
void BinarySink_put_uint64(BinarySink *bs, uint64 val)
void BinarySink_put_uint64(BinarySink *bs, uint64_t val)
{
BinarySink_put_uint32(bs, val.hi);
BinarySink_put_uint32(bs, val.lo);
unsigned char data[8];
PUT_64BIT_MSB_FIRST(data, val);
bs->write(bs, data, sizeof(data));
}
void BinarySink_put_string(BinarySink *bs, const void *data, size_t len)
@ -167,20 +167,15 @@ unsigned long BinarySource_get_uint32(BinarySource *src)
return GET_32BIT_MSB_FIRST(ucp);
}
uint64 BinarySource_get_uint64(BinarySource *src)
uint64_t BinarySource_get_uint64(BinarySource *src)
{
const unsigned char *ucp;
uint64 toret;
if (!avail(8)) {
toret.hi = toret.lo = 0;
return toret;
}
if (!avail(8))
return 0;
ucp = consume(8);
toret.hi = GET_32BIT_MSB_FIRST(ucp);
toret.lo = GET_32BIT_MSB_FIRST(ucp + 4);
return toret;
return GET_64BIT_MSB_FIRST(ucp);
}
ptrlen BinarySource_get_string(BinarySource *src)

5
marshal.h
View File

@ -76,8 +76,7 @@ struct BinarySink {
* first parameter of any of these put_* macros.
*/
/* Basic big-endian integer types. uint64 is the structure type
* defined in int64.h, not the C99 built-in type. */
/* Basic big-endian integer types. */
#define put_byte(bs, val) \
BinarySink_put_byte(BinarySink_UPCAST(bs), val)
#define put_uint16(bs, val) \
@ -146,6 +145,7 @@ void BinarySink_put_byte(BinarySink *, unsigned char);
void BinarySink_put_bool(BinarySink *, int);
void BinarySink_put_uint16(BinarySink *, unsigned long);
void BinarySink_put_uint32(BinarySink *, unsigned long);
void BinarySink_put_uint64(BinarySink *, uint64_t);
void BinarySink_put_string(BinarySink *, const void *data, size_t len);
void BinarySink_put_stringpl(BinarySink *, ptrlen);
void BinarySink_put_stringz(BinarySink *, const char *str);
@ -277,6 +277,7 @@ unsigned char BinarySource_get_byte(BinarySource *);
int BinarySource_get_bool(BinarySource *);
unsigned BinarySource_get_uint16(BinarySource *);
unsigned long BinarySource_get_uint32(BinarySource *);
uint64_t BinarySource_get_uint64(BinarySource *);
ptrlen BinarySource_get_string(BinarySource *);
const char *BinarySource_get_asciz(BinarySource *);
ptrlen BinarySource_get_pstring(BinarySource *);

56
misc.h
View File

@ -166,11 +166,31 @@ void debug_memdump(const void *buf, int len, int L);
#define max(x,y) ( (x) > (y) ? (x) : (y) )
#endif
#define GET_64BIT_LSB_FIRST(cp) \
(((uint64_t)(unsigned char)(cp)[0]) | \
((uint64_t)(unsigned char)(cp)[1] << 8) | \
((uint64_t)(unsigned char)(cp)[2] << 16) | \
((uint64_t)(unsigned char)(cp)[3] << 24) | \
((uint64_t)(unsigned char)(cp)[4] << 32) | \
((uint64_t)(unsigned char)(cp)[5] << 40) | \
((uint64_t)(unsigned char)(cp)[6] << 48) | \
((uint64_t)(unsigned char)(cp)[7] << 56))
#define PUT_64BIT_LSB_FIRST(cp, value) ( \
(cp)[0] = (unsigned char)(value), \
(cp)[1] = (unsigned char)((value) >> 8), \
(cp)[2] = (unsigned char)((value) >> 16), \
(cp)[3] = (unsigned char)((value) >> 24), \
(cp)[4] = (unsigned char)((value) >> 32), \
(cp)[5] = (unsigned char)((value) >> 40), \
(cp)[6] = (unsigned char)((value) >> 48), \
(cp)[7] = (unsigned char)((value) >> 56) )
#define GET_32BIT_LSB_FIRST(cp) \
(((unsigned long)(unsigned char)(cp)[0]) | \
((unsigned long)(unsigned char)(cp)[1] << 8) | \
((unsigned long)(unsigned char)(cp)[2] << 16) | \
((unsigned long)(unsigned char)(cp)[3] << 24))
(((uint32_t)(unsigned char)(cp)[0]) | \
((uint32_t)(unsigned char)(cp)[1] << 8) | \
((uint32_t)(unsigned char)(cp)[2] << 16) | \
((uint32_t)(unsigned char)(cp)[3] << 24))
#define PUT_32BIT_LSB_FIRST(cp, value) ( \
(cp)[0] = (unsigned char)(value), \
@ -187,10 +207,10 @@ void debug_memdump(const void *buf, int len, int L);
(cp)[1] = (unsigned char)((value) >> 8) )
#define GET_32BIT_MSB_FIRST(cp) \
(((unsigned long)(unsigned char)(cp)[0] << 24) | \
((unsigned long)(unsigned char)(cp)[1] << 16) | \
((unsigned long)(unsigned char)(cp)[2] << 8) | \
((unsigned long)(unsigned char)(cp)[3]))
(((uint32_t)(unsigned char)(cp)[0] << 24) | \
((uint32_t)(unsigned char)(cp)[1] << 16) | \
((uint32_t)(unsigned char)(cp)[2] << 8) | \
((uint32_t)(unsigned char)(cp)[3]))
#define GET_32BIT(cp) GET_32BIT_MSB_FIRST(cp)
@ -202,6 +222,26 @@ void debug_memdump(const void *buf, int len, int L);
#define PUT_32BIT(cp, value) PUT_32BIT_MSB_FIRST(cp, value)
#define GET_64BIT_MSB_FIRST(cp) \
(((uint64_t)(unsigned char)(cp)[0] << 56) | \
((uint64_t)(unsigned char)(cp)[1] << 48) | \
((uint64_t)(unsigned char)(cp)[2] << 40) | \
((uint64_t)(unsigned char)(cp)[3] << 32) | \
((uint64_t)(unsigned char)(cp)[4] << 24) | \
((uint64_t)(unsigned char)(cp)[5] << 16) | \
((uint64_t)(unsigned char)(cp)[6] << 8) | \
((uint64_t)(unsigned char)(cp)[7]))
#define PUT_64BIT_MSB_FIRST(cp, value) ( \
(cp)[0] = (unsigned char)((value) >> 56), \
(cp)[1] = (unsigned char)((value) >> 48), \
(cp)[2] = (unsigned char)((value) >> 40), \
(cp)[3] = (unsigned char)((value) >> 32), \
(cp)[4] = (unsigned char)((value) >> 24), \
(cp)[5] = (unsigned char)((value) >> 16), \
(cp)[6] = (unsigned char)((value) >> 8), \
(cp)[7] = (unsigned char)(value) )
#define GET_16BIT_MSB_FIRST(cp) \
(((unsigned long)(unsigned char)(cp)[0] << 8) | \
((unsigned long)(unsigned char)(cp)[1]))

2
pgssapi.h
View File

@ -24,7 +24,7 @@ typedef gss_OID const_gss_OID; /* for our prototypes below */
******************************************************************************/
/* GSSAPI Type Definitions */
typedef uint32 OM_uint32;
typedef uint32_t OM_uint32;
typedef struct gss_OID_desc_struct {
OM_uint32 length;

115
pscp.c
View File

@ -25,7 +25,6 @@
#include "ssh.h"
#include "sftp.h"
#include "storage.h"
#include "int64.h"
static int list = 0;
static int verbose = 0;
@ -506,7 +505,7 @@ static void do_cmd(char *host, char *user, char *cmd)
/*
* Update statistic information about current file.
*/
static void print_stats(const char *name, uint64 size, uint64 done,
static void print_stats(const char *name, uint64_t size, uint64_t done,
time_t start, time_t now)
{
float ratebs;
@ -515,42 +514,34 @@ static void print_stats(const char *name, uint64 size, uint64 done,
int pct;
int len;
int elap;
double donedbl;
double sizedbl;
elap = (unsigned long) difftime(now, start);
if (now > start)
ratebs = (float) (uint64_to_double(done) / elap);
ratebs = (float)done / elap;
else
ratebs = (float) uint64_to_double(done);
ratebs = (float)done;
if (ratebs < 1.0)
eta = (unsigned long) (uint64_to_double(uint64_subtract(size, done)));
else {
eta = (unsigned long)
((uint64_to_double(uint64_subtract(size, done)) / ratebs));
}
eta = size - done;
else
eta = (unsigned long)((size - done) / ratebs);
etastr = dupprintf("%02ld:%02ld:%02ld",
eta / 3600, (eta % 3600) / 60, eta % 60);
donedbl = uint64_to_double(done);
sizedbl = uint64_to_double(size);
pct = (int) (100 * (donedbl * 1.0 / sizedbl));
pct = (int) (100.0 * done / size);
{
char donekb[40];
/* divide by 1024 to provide kB */
uint64_decimal(uint64_shift_right(done, 10), donekb);
len = printf("\r%-25.25s | %s kB | %5.1f kB/s | ETA: %8s | %3d%%",
name,
donekb, ratebs / 1024.0, etastr, pct);
len = printf("\r%-25.25s | %"PRIu64" kB | %5.1f kB/s | "
"ETA: %8s | %3d%%", name, done >> 10,
ratebs / 1024.0, etastr, pct);
if (len < prev_stats_len)
printf("%*s", prev_stats_len - len, "");
prev_stats_len = len;
if (uint64_compare(done, size) == 0)
if (done == size)
abandon_stats();
fflush(stdout);
@ -743,7 +734,7 @@ static unsigned long scp_sftp_mtime, scp_sftp_atime;
static int scp_has_times;
static struct fxp_handle *scp_sftp_filehandle;
static struct fxp_xfer *scp_sftp_xfer;
static uint64 scp_sftp_fileoffset;
static uint64_t scp_sftp_fileoffset;
int scp_source_setup(const char *target, int shouldbedir)
{
@ -811,7 +802,7 @@ int scp_send_filetimes(unsigned long mtime, unsigned long atime)
}
}
int scp_send_filename(const char *name, uint64 size, int permissions)
int scp_send_filename(const char *name, uint64_t size, int permissions)
{
if (using_sftp) {
char *fullname;
@ -841,18 +832,16 @@ int scp_send_filename(const char *name, uint64 size, int permissions)
errs++;
return 1;
}
scp_sftp_fileoffset = uint64_make(0, 0);
scp_sftp_fileoffset = 0;
scp_sftp_xfer = xfer_upload_init(scp_sftp_filehandle,
scp_sftp_fileoffset);
sfree(fullname);
return 0;
} else {
char *buf;
char sizestr[40];
uint64_decimal(size, sizestr);
if (permissions < 0)
permissions = 0644;
buf = dupprintf("C%04o %s ", (int)(permissions & 07777), sizestr);
buf = dupprintf("C%04o %"PRIu64" ", (int)(permissions & 07777), size);
backend_send(backend, buf, strlen(buf));
sfree(buf);
backend_send(backend, name, strlen(name));
@ -885,7 +874,7 @@ int scp_send_filedata(char *data, int len)
xfer_upload_data(scp_sftp_xfer, data, len);
scp_sftp_fileoffset = uint64_add32(scp_sftp_fileoffset, len);
scp_sftp_fileoffset += len;
return 0;
} else {
int bufsize = backend_send(backend, data, len);
@ -1143,7 +1132,7 @@ struct scp_sink_action {
char *buf; /* will need freeing after use */
char *name; /* filename or dirname (not ENDDIR) */
long permissions; /* access permissions (not ENDDIR) */
uint64 size; /* file size (not ENDDIR) */
uint64_t size; /* file size (not ENDDIR) */
int settime; /* 1 if atime and mtime are filled */
unsigned long atime, mtime; /* access times for the file */
};
@ -1369,7 +1358,7 @@ int scp_get_sink_action(struct scp_sink_action *act)
act->action = SCP_SINK_DIR;
act->buf = dupstr(stripslashes(fname, 0));
act->name = act->buf;
act->size = uint64_make(0,0); /* duhh, it's a directory */
act->size = 0; /* duhh, it's a directory */
act->permissions = 07777 & attrs.permissions;
if (scp_sftp_preserve &&
(attrs.flags & SSH_FILEXFER_ATTR_ACMODTIME)) {
@ -1391,7 +1380,7 @@ int scp_get_sink_action(struct scp_sink_action *act)
if (attrs.flags & SSH_FILEXFER_ATTR_SIZE) {
act->size = attrs.size;
} else
act->size = uint64_make(ULONG_MAX,ULONG_MAX); /* no idea */
act->size = UINT64_MAX; /* no idea */
act->permissions = 07777 & attrs.permissions;
if (scp_sftp_preserve &&
(attrs.flags & SSH_FILEXFER_ATTR_ACMODTIME)) {
@ -1476,12 +1465,9 @@ int scp_get_sink_action(struct scp_sink_action *act)
* SCP_SINK_DIR.
*/
{
char sizestr[40];
if (sscanf(act->buf, "%lo %39s %n", &act->permissions,
sizestr, &i) != 2)
if (sscanf(act->buf, "%lo %"SCNu64" %n", &act->permissions,
&act->size, &i) != 2)
bump("Protocol error: Illegal file descriptor format");
act->size = uint64_from_decimal(sizestr);
act->name = act->buf + i;
return 0;
}
@ -1504,7 +1490,7 @@ int scp_accept_filexfer(void)
errs++;
return 1;
}
scp_sftp_fileoffset = uint64_make(0, 0);
scp_sftp_fileoffset = 0;
scp_sftp_xfer = xfer_download_init(scp_sftp_filehandle,
scp_sftp_fileoffset);
sfree(scp_sftp_currentname);
@ -1552,7 +1538,7 @@ int scp_recv_filedata(char *data, int len)
} else
actuallen = 0;
scp_sftp_fileoffset = uint64_add32(scp_sftp_fileoffset, actuallen);
scp_sftp_fileoffset += actuallen;
return actuallen;
} else {
@ -1625,14 +1611,14 @@ static void run_err(const char *fmt, ...)
*/
static void source(const char *src)
{
uint64 size;
uint64_t size;
unsigned long mtime, atime;
long permissions;
const char *last;
RFile *f;
int attr;
uint64 i;
uint64 stat_bytes;
uint64_t i;
uint64_t stat_bytes;
time_t stat_starttime, stat_lasttime;
attr = file_type(src);
@ -1688,28 +1674,24 @@ static void source(const char *src)
}
if (verbose) {
char sizestr[40];
uint64_decimal(size, sizestr);
tell_user(stderr, "Sending file %s, size=%s", last, sizestr);
tell_user(stderr, "Sending file %s, size=%"PRIu64, last, size);
}
if (scp_send_filename(last, size, permissions)) {
close_rfile(f);
return;
}
stat_bytes = uint64_make(0,0);
stat_bytes = 0;
stat_starttime = time(NULL);
stat_lasttime = 0;
#define PSCP_SEND_BLOCK 4096
for (i = uint64_make(0,0);
uint64_compare(i,size) < 0;
i = uint64_add32(i,PSCP_SEND_BLOCK)) {
for (i = 0; i < size; i += PSCP_SEND_BLOCK) {
char transbuf[PSCP_SEND_BLOCK];
int j, k = PSCP_SEND_BLOCK;
if (uint64_compare(uint64_add32(i, k),size) > 0) /* i + k > size */
k = (uint64_subtract(size, i)).lo; /* k = size - i; */
if (i + k > size)
k = size - i;
if ((j = read_from_file(f, transbuf, k)) != k) {
bump("%s: Read error", src);
}
@ -1717,9 +1699,8 @@ static void source(const char *src)
bump("%s: Network error occurred", src);
if (statistics) {
stat_bytes = uint64_add32(stat_bytes, k);
if (time(NULL) != stat_lasttime ||
(uint64_compare(uint64_add32(i, k), size) == 0)) {
stat_bytes += k;
if (time(NULL) != stat_lasttime || i + k == size) {
stat_lasttime = time(NULL);
print_stats(last, size, stat_bytes,
stat_starttime, stat_lasttime);
@ -1786,9 +1767,9 @@ static void sink(const char *targ, const char *src)
int exists;
int attr;
WFile *f;
uint64 received;
uint64_t received;
int wrerror = 0;
uint64 stat_bytes;
uint64_t stat_bytes;
time_t stat_starttime, stat_lasttime;
char *stat_name;
@ -1926,24 +1907,24 @@ static void sink(const char *targ, const char *src)
return;
}
stat_bytes = uint64_make(0, 0);
stat_bytes = 0;
stat_starttime = time(NULL);
stat_lasttime = 0;
stat_name = stripslashes(destfname, 1);
received = uint64_make(0, 0);
while (uint64_compare(received,act.size) < 0) {
received = 0;
while (received < act.size) {
char transbuf[32768];
uint64 blksize;
uint64_t blksize;
int read;
blksize = uint64_make(0, 32768);
if (uint64_compare(blksize,uint64_subtract(act.size,received)) > 0)
blksize = uint64_subtract(act.size,received);
read = scp_recv_filedata(transbuf, (int)blksize.lo);
blksize = 32768;
if (blksize > act.size - received)
blksize = act.size - received;
read = scp_recv_filedata(transbuf, (int)blksize);
if (read <= 0)
bump("Lost connection");
if (wrerror) {
received = uint64_add32(received, read);
received += read;
continue;
}
if (write_to_file(f, transbuf, read) != (int)read) {
@ -1953,19 +1934,19 @@ static void sink(const char *targ, const char *src)
printf("\r%-25.25s | %50s\n",
stat_name,
"Write error.. waiting for end of file");
received = uint64_add32(received, read);
received += read;
continue;
}
if (statistics) {
stat_bytes = uint64_add32(stat_bytes,read);
stat_bytes += read;
if (time(NULL) > stat_lasttime ||
uint64_compare(uint64_add32(received, read), act.size) == 0) {
received + read == act.size) {
stat_lasttime = time(NULL);
print_stats(stat_name, act.size, stat_bytes,
stat_starttime, stat_lasttime);
}
}
received = uint64_add32(received, read);
received += read;
}
if (act.settime) {
set_file_times(f, act.mtime, act.atime);

21
psftp.c
View File

@ -14,7 +14,6 @@
#include "storage.h"
#include "ssh.h"
#include "sftp.h"
#include "int64.h"
const char *const appname = "PSFTP";
@ -234,7 +233,7 @@ int sftp_get_file(char *fname, char *outfname, int recurse, int restart)
struct sftp_packet *pktin;
struct sftp_request *req;
struct fxp_xfer *xfer;
uint64 offset;
uint64_t offset;
WFile *file;
int ret, shown_err = FALSE;
struct fxp_attrs attrs;
@ -434,8 +433,7 @@ int sftp_get_file(char *fname, char *outfname, int recurse, int restart)
}
if (restart) {
char decbuf[30];
if (seek_file(file, uint64_make(0,0) , FROM_END) == -1) {
if (seek_file(file, 0, FROM_END) == -1) {
close_wfile(file);
printf("reget: cannot restart %s - file too large\n",
outfname);
@ -447,10 +445,9 @@ int sftp_get_file(char *fname, char *outfname, int recurse, int restart)
}
offset = get_file_posn(file);
uint64_decimal(offset, decbuf);
printf("reget: restarting at file position %s\n", decbuf);
printf("reget: restarting at file position %"PRIu64"\n", offset);
} else {
offset = uint64_make(0, 0);
offset = 0;
}
printf("remote:%s => local:%s\n", fname, outfname);
@ -519,7 +516,7 @@ int sftp_put_file(char *fname, char *outfname, int recurse, int restart)
struct fxp_xfer *xfer;
struct sftp_packet *pktin;
struct sftp_request *req;
uint64 offset;
uint64_t offset;
RFile *file;
int err = 0, eof;
struct fxp_attrs attrs;
@ -672,7 +669,6 @@ int sftp_put_file(char *fname, char *outfname, int recurse, int restart)
}
if (restart) {
char decbuf[30];
struct fxp_attrs attrs;
int ret;
@ -691,13 +687,12 @@ int sftp_put_file(char *fname, char *outfname, int recurse, int restart)
goto cleanup;
}
offset = attrs.size;
uint64_decimal(offset, decbuf);
printf("reput: restarting at file position %s\n", decbuf);
printf("reput: restarting at file position %"PRIu64"\n", offset);
if (seek_file((WFile *)file, offset, FROM_START) != 0)
seek_file((WFile *)file, uint64_make(0,0), FROM_END); /* *shrug* */
seek_file((WFile *)file, 0, FROM_END); /* *shrug* */
} else {
offset = uint64_make(0, 0);
offset = 0;
}
printf("local:%s => remote:%s\n", fname, outfname);

10
psftp.h
View File

@ -3,8 +3,6 @@
* platform-specific SFTP module.
*/
#include "int64.h"
#ifndef PUTTY_PSFTP_H
#define PUTTY_PSFTP_H
@ -93,10 +91,10 @@ typedef struct RFile RFile;
typedef struct WFile WFile;
/* Output params size, perms, mtime and atime can all be NULL if
* desired. perms will be -1 if the OS does not support POSIX permissions. */
RFile *open_existing_file(const char *name, uint64 *size,
RFile *open_existing_file(const char *name, uint64_t *size,
unsigned long *mtime, unsigned long *atime,
long *perms);
WFile *open_existing_wfile(const char *name, uint64 *size);
WFile *open_existing_wfile(const char *name, uint64_t *size);
/* Returns <0 on error, 0 on eof, or number of bytes read, as usual */
int read_from_file(RFile *f, void *buffer, int length);
/* Closes and frees the RFile */
@ -109,9 +107,9 @@ void set_file_times(WFile *f, unsigned long mtime, unsigned long atime);
void close_wfile(WFile *f);
/* Seek offset bytes through file */
enum { FROM_START, FROM_CURRENT, FROM_END };
int seek_file(WFile *f, uint64 offset, int whence);
int seek_file(WFile *f, uint64_t offset, int whence);
/* Get file position */
uint64 get_file_posn(WFile *f);
uint64_t get_file_posn(WFile *f);
/*
* Determine the type of a file: nonexistent, file, directory or
* weird. `weird' covers anything else - named pipes, Unix sockets,

57
scpserver.c
View File

@ -381,7 +381,7 @@ struct ScpSource {
strbuf *pending_commands[3];
int n_pending_commands;
uint64 file_offset, file_size;
uint64_t file_offset, file_size;
ScpReplyReceiver reply;
@ -535,7 +535,7 @@ static void scp_source_send_E(ScpSource *scp)
static void scp_source_send_CD(
ScpSource *scp, char cmdchar,
struct fxp_attrs attrs, uint64 size, ptrlen name)
struct fxp_attrs attrs, uint64_t size, ptrlen name)
{
strbuf *cmd;
@ -547,18 +547,15 @@ static void scp_source_send_CD(
strbuf_catf(cmd, "T%lu 0 %lu 0\012", attrs.mtime, attrs.atime);
}
char sizebuf[32];
uint64_decimal(size, sizebuf);
const char *slash;
while ((slash = memchr(name.ptr, '/', name.len)) != NULL)
name = make_ptrlen(
slash+1, name.len - (slash+1 - (const char *)name.ptr));
scp->pending_commands[scp->n_pending_commands++] = cmd = strbuf_new();
strbuf_catf(cmd, "%c%04o %s %.*s\012", cmdchar,
strbuf_catf(cmd, "%c%04o %"PRIu64" %.*s\012", cmdchar,
(unsigned)(attrs.permissions & 07777),
sizebuf, PTRLEN_PRINTF(name));
size, PTRLEN_PRINTF(name));
if (cmdchar == 'C') {
/* We'll also wait for an ack before sending the file data,
@ -626,8 +623,7 @@ static void scp_source_process_stack(ScpSource *scp)
/*
* Mostly, we start by waiting for an ack byte from the receiver.
*/
if (scp->head && scp->head->type == SCP_READFILE &&
uint64_compare(scp->file_offset, uint64_make(0, 0)) != 0) {
if (scp->head && scp->head->type == SCP_READFILE && scp->file_offset) {
/*
* Exception: if we're already in the middle of transferring a
* file, we'll be called back here because the channel backlog
@ -717,14 +713,12 @@ static void scp_source_process_stack(ScpSource *scp)
* Transfer file data if our backlog hasn't filled up.
*/
int backlog;
uint64 remaining =
uint64_subtract(scp->file_size, scp->file_offset);
uint64 limit = uint64_make(0, 4096);
if (uint64_compare(remaining, limit) < 0)
limit = remaining;
if (limit.lo > 0) {
uint64_t limit = scp->file_size - scp->file_offset;
if (limit > 4096)
limit = 4096;
if (limit > 0) {
sftpsrv_read(scp->sf, &scp->reply.srb, scp->head->handle,
scp->file_offset, limit.lo);
scp->file_offset, limit);
if (scp->reply.err) {
scp_source_abort(
scp, "%.*s: unable to read: %s",
@ -734,8 +728,7 @@ static void scp_source_process_stack(ScpSource *scp)
backlog = sshfwd_write(
scp->sc, scp->reply.data.ptr, scp->reply.data.len);
scp->file_offset = uint64_add(
scp->file_offset, uint64_make(0, scp->reply.data.len));
scp->file_offset += scp->reply.data.len;
if (backlog < SCP_MAX_BACKLOG)
scp_requeue(scp);
@ -819,8 +812,7 @@ static void scp_source_process_stack(ScpSource *scp)
assert(scp->recursive || node->wildcard);
if (!node->wildcard)
scp_source_send_CD(scp, 'D', node->attrs,
uint64_make(0, 0), node->pathname);
scp_source_send_CD(scp, 'D', node->attrs, 0, node->pathname);
sftpsrv_opendir(scp->sf, &scp->reply.srb, node->pathname);
if (scp->reply.err) {
scp_source_err(
@ -855,7 +847,7 @@ static void scp_source_process_stack(ScpSource *scp)
scp_requeue(scp);
return;
}
scp->file_offset = uint64_make(0, 0);
scp->file_offset = 0;
scp->file_size = scp->reply.attrs.size;
scp_source_send_CD(scp, 'C', node->attrs,
scp->file_size, node->pathname);
@ -943,7 +935,7 @@ struct ScpSink {
SshChannel *sc;
ScpSinkStackEntry *head;
uint64 file_offset, file_size;
uint64_t file_offset, file_size;
unsigned long atime, mtime;
int got_file_times;
@ -1135,7 +1127,7 @@ static void scp_sink_coroutine(ScpSink *scp)
if (*p != ' ')
goto parse_error;
p++;
scp->file_size = uint64_from_decimal(q);
scp->file_size = strtoull(q, NULL, 10);
ptrlen leafname = make_ptrlen(
p, scp->command->len - (p - scp->command->s));
@ -1185,11 +1177,11 @@ static void scp_sink_coroutine(ScpSink *scp)
* Now send an ack, and read the file data.
*/
sshfwd_write(scp->sc, "\0", 1);
scp->file_offset = uint64_make(0, 0);
while (uint64_compare(scp->file_offset, scp->file_size) < 0) {
scp->file_offset = 0;
while (scp->file_offset < scp->file_size) {
void *vdata;
int len;
uint64 this_len, remaining;
uint64_t this_len, remaining;
crMaybeWaitUntilV(
scp->input_eof || bufchain_size(&scp->data) > 0);
@ -1200,22 +1192,21 @@ static void scp_sink_coroutine(ScpSink *scp)
}
bufchain_prefix(&scp->data, &vdata, &len);
this_len = uint64_make(0, len);
remaining = uint64_subtract(
scp->file_size, scp->file_offset);
if (uint64_compare(this_len, remaining) > 0)
this_len = len;
remaining = scp->file_size - scp->file_offset;
if (this_len > remaining)
this_len = remaining;
sftpsrv_write(scp->sf, &scp->reply.srb,
scp->reply.handle, scp->file_offset,
make_ptrlen(vdata, this_len.lo));
make_ptrlen(vdata, this_len));
if (scp->reply.err) {
scp->errmsg = dupprintf(
"'%.*s': unable to write to file: %s",
PTRLEN_PRINTF(scp->filename), scp->reply.errmsg);
goto done;
}
bufchain_consume(&scp->data, this_len.lo);
scp->file_offset = uint64_add(scp->file_offset, this_len);
bufchain_consume(&scp->data, this_len);
scp->file_offset += this_len;
}
/*

45
sftp.c
View File

@ -9,7 +9,6 @@
#include <limits.h>
#include "misc.h"
#include "int64.h"
#include "tree234.h"
#include "sftp.h"
@ -683,7 +682,7 @@ int fxp_fsetstat_recv(struct sftp_packet *pktin, struct sftp_request *req)
* error indicator. It might even depend on the SFTP server.)
*/
struct sftp_request *fxp_read_send(struct fxp_handle *handle,
uint64 offset, int len)
uint64_t offset, int len)
{
struct sftp_request *req = sftp_alloc_request();
struct sftp_packet *pktout;
@ -812,7 +811,7 @@ struct fxp_names *fxp_readdir_recv(struct sftp_packet *pktin,
* Write to a file. Returns 0 on error, 1 on OK.
*/
struct sftp_request *fxp_write_send(struct fxp_handle *handle,
void *buffer, uint64 offset, int len)
void *buffer, uint64_t offset, int len)
{
struct sftp_request *req = sftp_alloc_request();
struct sftp_packet *pktout;
@ -894,18 +893,18 @@ void fxp_set_userdata(struct sftp_request *req, void *data)
struct req {
char *buffer;
int len, retlen, complete;
uint64 offset;
uint64_t offset;
struct req *next, *prev;
};
struct fxp_xfer {
uint64 offset, furthestdata, filesize;
uint64_t offset, furthestdata, filesize;
int req_totalsize, req_maxsize, eof, err;
struct fxp_handle *fh;
struct req *head, *tail;
};
static struct fxp_xfer *xfer_init(struct fxp_handle *fh, uint64 offset)
static struct fxp_xfer *xfer_init(struct fxp_handle *fh, uint64_t offset)
{
struct fxp_xfer *xfer = snew(struct fxp_xfer);
@ -915,8 +914,8 @@ static struct fxp_xfer *xfer_init(struct fxp_handle *fh, uint64 offset)
xfer->req_totalsize = 0;
xfer->req_maxsize = 1048576;
xfer->err = 0;
xfer->filesize = uint64_make(ULONG_MAX, ULONG_MAX);
xfer->furthestdata = uint64_make(0, 0);
xfer->filesize = UINT64_MAX;
xfer->furthestdata = 0;
return xfer;
}
@ -958,16 +957,16 @@ void xfer_download_queue(struct fxp_xfer *xfer)
sftp_register(req = fxp_read_send(xfer->fh, rr->offset, rr->len));
fxp_set_userdata(req, rr);
xfer->offset = uint64_add32(xfer->offset, rr->len);
xfer->offset += rr->len;
xfer->req_totalsize += rr->len;
#ifdef DEBUG_DOWNLOAD
{ char buf[40]; uint64_decimal(rr->offset, buf); printf("queueing read request %p at %s\n", rr, buf); }
printf("queueing read request %p at %"PRIu64"\n", rr, rr->offset);
#endif
}
}
struct fxp_xfer *xfer_download_init(struct fxp_handle *fh, uint64 offset)
struct fxp_xfer *xfer_download_init(struct fxp_handle *fh, uint64_t offset)
{
struct fxp_xfer *xfer = xfer_init(fh, offset);
@ -1027,24 +1026,19 @@ int xfer_download_gotpkt(struct fxp_xfer *xfer, struct sftp_packet *pktin)
* I simply shouldn't have been queueing multiple requests in
* the first place...
*/
if (rr->retlen > 0 && uint64_compare(xfer->furthestdata, rr->offset) < 0) {
if (rr->retlen > 0 && xfer->furthestdata < rr->offset) {
xfer->furthestdata = rr->offset;
#ifdef DEBUG_DOWNLOAD
{ char buf[40];
uint64_decimal(xfer->furthestdata, buf);
printf("setting furthestdata = %s\n", buf); }
printf("setting furthestdata = %"PRIu64"\n", xfer->furthestdata);
#endif
}
if (rr->retlen < rr->len) {
uint64 filesize = uint64_add32(rr->offset,
(rr->retlen < 0 ? 0 : rr->retlen));
uint64_t filesize = rr->offset + (rr->retlen < 0 ? 0 : rr->retlen);
#ifdef DEBUG_DOWNLOAD
{ char buf[40];
uint64_decimal(filesize, buf);
printf("short block! trying filesize = %s\n", buf); }
printf("short block! trying filesize = %"PRIu64"\n", filesize);
#endif
if (uint64_compare(xfer->filesize, filesize) > 0) {
if (xfer->filesize > filesize) {
xfer->filesize = filesize;
#ifdef DEBUG_DOWNLOAD
printf("actually changing filesize\n");
@ -1052,7 +1046,7 @@ int xfer_download_gotpkt(struct fxp_xfer *xfer, struct sftp_packet *pktin)
}
}
if (uint64_compare(xfer->furthestdata, xfer->filesize) > 0) {
if (xfer->furthestdata > xfer->filesize) {
fxp_error_message = "received a short buffer from FXP_READ, but not"
" at EOF";
fxp_errtype = -1;
@ -1109,7 +1103,7 @@ int xfer_download_data(struct fxp_xfer *xfer, void **buf, int *len)
return 0;
}
struct fxp_xfer *xfer_upload_init(struct fxp_handle *fh, uint64 offset)
struct fxp_xfer *xfer_upload_init(struct fxp_handle *fh, uint64_t offset)
{
struct fxp_xfer *xfer = xfer_init(fh, offset);
@ -1157,11 +1151,12 @@ void xfer_upload_data(struct fxp_xfer *xfer, char *buffer, int len)
sftp_register(req = fxp_write_send(xfer->fh, buffer, rr->offset, len));
fxp_set_userdata(req, rr);
xfer->offset = uint64_add32(xfer->offset, rr->len);
xfer->offset += rr->len;
xfer->req_totalsize += rr->len;
#ifdef DEBUG_UPLOAD
{ char buf[40]; uint64_decimal(rr->offset, buf); printf("queueing write request %p at %s [len %d]\n", rr, buf, len); }
printf("queueing write request %p at %"PRIu64" [len %d]\n",
rr, rr->offset, len);
#endif
}

15
sftp.h
View File

@ -3,7 +3,6 @@
*/
#include "defs.h"
#include "int64.h"
#define SSH_FXP_INIT 1 /* 0x1 */
#define SSH_FXP_VERSION 2 /* 0x2 */
@ -81,7 +80,7 @@ void sftp_cleanup_request(void);
struct fxp_attrs {
unsigned long flags;
uint64 size;
uint64_t size;
unsigned long uid;
unsigned long gid;
unsigned long permissions;
@ -248,7 +247,7 @@ int fxp_fsetstat_recv(struct sftp_packet *pktin, struct sftp_request *req);
* Read from a file.
*/
struct sftp_request *fxp_read_send(struct fxp_handle *handle,
uint64 offset, int len);
uint64_t offset, int len);
int fxp_read_recv(struct sftp_packet *pktin, struct sftp_request *req,
char *buffer, int len);
@ -256,7 +255,7 @@ int fxp_read_recv(struct sftp_packet *pktin, struct sftp_request *req,
* Write to a file. Returns 0 on error, 1 on OK.
*/
struct sftp_request *fxp_write_send(struct fxp_handle *handle,
void *buffer, uint64 offset, int len);
void *buffer, uint64_t offset, int len);
int fxp_write_recv(struct sftp_packet *pktin, struct sftp_request *req);
/*
@ -299,12 +298,12 @@ struct sftp_packet *sftp_recv(void);
struct fxp_xfer;
struct fxp_xfer *xfer_download_init(struct fxp_handle *fh, uint64 offset);
struct fxp_xfer *xfer_download_init(struct fxp_handle *fh, uint64_t offset);
void xfer_download_queue(struct fxp_xfer *xfer);
int xfer_download_gotpkt(struct fxp_xfer *xfer, struct sftp_packet *pktin);
int xfer_download_data(struct fxp_xfer *xfer, void **buf, int *len);
struct fxp_xfer *xfer_upload_init(struct fxp_handle *fh, uint64 offset);
struct fxp_xfer *xfer_upload_init(struct fxp_handle *fh, uint64_t offset);
int xfer_upload_ready(struct fxp_xfer *xfer);
void xfer_upload_data(struct fxp_xfer *xfer, char *buffer, int len);
int xfer_upload_gotpkt(struct fxp_xfer *xfer, struct sftp_packet *pktin);
@ -378,11 +377,11 @@ struct SftpServerVtable {
/* Should call fxp_reply_error or fxp_reply_data */
void (*read)(SftpServer *srv, SftpReplyBuilder *reply,
ptrlen handle, uint64 offset, unsigned length);
ptrlen handle, uint64_t offset, unsigned length);
/* Should call fxp_reply_error or fxp_reply_ok */
void (*write)(SftpServer *srv, SftpReplyBuilder *reply,
ptrlen handle, uint64 offset, ptrlen data);
ptrlen handle, uint64_t offset, ptrlen data);
/* Should call fxp_reply_error, or fxp_reply_name_count once and
* then fxp_reply_full_name that many times */

2
sftpserver.c
View File

@ -16,7 +16,7 @@ struct sftp_packet *sftp_handle_request(
struct sftp_packet *reply;
unsigned id;
ptrlen path, dstpath, handle, data;
uint64 offset;
uint64_t offset;
unsigned length;
struct fxp_attrs attrs;
DefaultSftpReplyBuilder dsrb;

23
ssh.h
View File

@ -4,7 +4,6 @@
#include "puttymem.h"
#include "tree234.h"
#include "network.h"
#include "int64.h"
#include "misc.h"
struct ssh_channel;
@ -507,8 +506,6 @@ void rsa_ssh1_public_blob(BinarySink *bs, struct RSAKey *key,
int rsa_ssh1_public_blob_len(void *data, int maxlen);
void freersakey(struct RSAKey *key);
typedef uint32 word32;
unsigned long crc32_compute(const void *s, size_t len);
unsigned long crc32_update(unsigned long crc_input, const void *s, size_t len);
@ -516,7 +513,7 @@ unsigned long crc32_update(unsigned long crc_input, const void *s, size_t len);
struct crcda_ctx;
struct crcda_ctx *crcda_make_context(void);
void crcda_free_context(struct crcda_ctx *ctx);
int detect_attack(struct crcda_ctx *ctx, unsigned char *buf, uint32 len,
int detect_attack(struct crcda_ctx *ctx, unsigned char *buf, uint32_t len,
unsigned char *IV);
/*
@ -556,14 +553,14 @@ struct ssh2_cipheralg;
typedef const struct ssh2_cipheralg *ssh2_cipher;
typedef struct {
uint32 h[4];
uint32_t h[4];
} MD5_Core_State;
struct MD5Context {
MD5_Core_State core;
unsigned char block[64];
int blkused;
uint32 lenhi, lenlo;
uint64_t len;
BinarySink_IMPLEMENTATION;
};
@ -581,10 +578,10 @@ void hmacmd5_do_hmac(struct hmacmd5_context *ctx,
int supports_sha_ni(void);
typedef struct SHA_State {
uint32 h[5];
uint32_t h[5];
unsigned char block[64];
int blkused;
uint32 lenhi, lenlo;
uint64_t len;
void (*sha1)(struct SHA_State * s, const unsigned char *p, int len);
BinarySink_IMPLEMENTATION;
} SHA_State;
@ -596,10 +593,10 @@ void hmac_sha1_simple(const void *key, int keylen,
const void *data, int datalen,
unsigned char *output);
typedef struct SHA256_State {
uint32 h[8];
uint32_t h[8];
unsigned char block[64];
int blkused;
uint32 lenhi, lenlo;
uint64_t len;
void (*sha256)(struct SHA256_State * s, const unsigned char *p, int len);
BinarySink_IMPLEMENTATION;
} SHA256_State;
@ -608,10 +605,10 @@ void SHA256_Final(SHA256_State * s, unsigned char *output);
void SHA256_Simple(const void *p, int len, unsigned char *output);
typedef struct {
uint64 h[8];
uint64_t h[8];
unsigned char block[128];
int blkused;
uint32 len[4];
uint64_t lenhi, lenlo;
BinarySink_IMPLEMENTATION;
} SHA512_State;
#define SHA384_State SHA512_State
@ -898,7 +895,7 @@ extern const char sshver[];
*/
extern int ssh_fallback_cmd(Backend *backend);
void SHATransform(word32 * digest, word32 * data);
void SHATransform(uint32_t *digest, uint32_t *data);
/*
* Check of compiler version

50
sshaes.c
View File

@ -49,10 +49,10 @@
#endif
struct AESContext {
word32 keysched_buf[(MAX_NR + 1) * NB + 3];
word32 invkeysched_buf[(MAX_NR + 1) * NB + 3];
word32 *keysched, *invkeysched;
word32 iv[NB];
uint32_t keysched_buf[(MAX_NR + 1) * NB + 3];
uint32_t invkeysched_buf[(MAX_NR + 1) * NB + 3];
uint32_t *keysched, *invkeysched;
uint32_t iv[NB];
int Nr; /* number of rounds */
void (*encrypt_cbc)(unsigned char*, int, AESContext*);
void (*decrypt_cbc)(unsigned char*, int, AESContext*);
@ -156,7 +156,7 @@ static const unsigned char Sboxinv[256] = {
0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
};
static const word32 E0[256] = {
static const uint32_t E0[256] = {
0xc66363a5, 0xf87c7c84, 0xee777799, 0xf67b7b8d,
0xfff2f20d, 0xd66b6bbd, 0xde6f6fb1, 0x91c5c554,
0x60303050, 0x02010103, 0xce6767a9, 0x562b2b7d,
@ -222,7 +222,7 @@ static const word32 E0[256] = {
0x824141c3, 0x299999b0, 0x5a2d2d77, 0x1e0f0f11,
0x7bb0b0cb, 0xa85454fc, 0x6dbbbbd6, 0x2c16163a,
};
static const word32 E1[256] = {
static const uint32_t E1[256] = {
0xa5c66363, 0x84f87c7c, 0x99ee7777, 0x8df67b7b,
0x0dfff2f2, 0xbdd66b6b, 0xb1de6f6f, 0x5491c5c5,
0x50603030, 0x03020101, 0xa9ce6767, 0x7d562b2b,
@ -288,7 +288,7 @@ static const word32 E1[256] = {
0xc3824141, 0xb0299999, 0x775a2d2d, 0x111e0f0f,
0xcb7bb0b0, 0xfca85454, 0xd66dbbbb, 0x3a2c1616,
};
static const word32 E2[256] = {
static const uint32_t E2[256] = {
0x63a5c663, 0x7c84f87c, 0x7799ee77, 0x7b8df67b,
0xf20dfff2, 0x6bbdd66b, 0x6fb1de6f, 0xc55491c5,
0x30506030, 0x01030201, 0x67a9ce67, 0x2b7d562b,
@ -354,7 +354,7 @@ static const word32 E2[256] = {
0x41c38241, 0x99b02999, 0x2d775a2d, 0x0f111e0f,
0xb0cb7bb0, 0x54fca854, 0xbbd66dbb, 0x163a2c16,
};
static const word32 E3[256] = {
static const uint32_t E3[256] = {
0x6363a5c6, 0x7c7c84f8, 0x777799ee, 0x7b7b8df6,
0xf2f20dff, 0x6b6bbdd6, 0x6f6fb1de, 0xc5c55491,
0x30305060, 0x01010302, 0x6767a9ce, 0x2b2b7d56,
@ -420,7 +420,7 @@ static const word32 E3[256] = {
0x4141c382, 0x9999b029, 0x2d2d775a, 0x0f0f111e,
0xb0b0cb7b, 0x5454fca8, 0xbbbbd66d, 0x16163a2c,
};
static const word32 D0[256] = {
static const uint32_t D0[256] = {
0x51f4a750, 0x7e416553, 0x1a17a4c3, 0x3a275e96,
0x3bab6bcb, 0x1f9d45f1, 0xacfa58ab, 0x4be30393,
0x2030fa55, 0xad766df6, 0x88cc7691, 0xf5024c25,
@ -486,7 +486,7 @@ static const word32 D0[256] = {
0x39a80171, 0x080cb3de, 0xd8b4e49c, 0x6456c190,
0x7bcb8461, 0xd532b670, 0x486c5c74, 0xd0b85742,
};
static const word32 D1[256] = {
static const uint32_t D1[256] = {
0x5051f4a7, 0x537e4165, 0xc31a17a4, 0x963a275e,
0xcb3bab6b, 0xf11f9d45, 0xabacfa58, 0x934be303,
0x552030fa, 0xf6ad766d, 0x9188cc76, 0x25f5024c,
@ -552,7 +552,7 @@ static const word32 D1[256] = {
0x7139a801, 0xde080cb3, 0x9cd8b4e4, 0x906456c1,
0x617bcb84, 0x70d532b6, 0x74486c5c, 0x42d0b857,
};
static const word32 D2[256] = {
static const uint32_t D2[256] = {
0xa75051f4, 0x65537e41, 0xa4c31a17, 0x5e963a27,
0x6bcb3bab, 0x45f11f9d, 0x58abacfa, 0x03934be3,
0xfa552030, 0x6df6ad76, 0x769188cc, 0x4c25f502,
@ -618,7 +618,7 @@ static const word32 D2[256] = {
0x017139a8, 0xb3de080c, 0xe49cd8b4, 0xc1906456,
0x84617bcb, 0xb670d532, 0x5c74486c, 0x5742d0b8,
};
static const word32 D3[256] = {
static const uint32_t D3[256] = {
0xf4a75051, 0x4165537e, 0x17a4c31a, 0x275e963a,
0xab6bcb3b, 0x9d45f11f, 0xfa58abac, 0xe303934b,
0x30fa5520, 0x766df6ad, 0xcc769188, 0x024c25f5,
@ -700,11 +700,11 @@ static void aes_setup(AESContext * ctx, const unsigned char *key, int keylen)
/* Ensure the key schedule arrays are 16-byte aligned */
bufaddr = (size_t)ctx->keysched_buf;
ctx->keysched = ctx->keysched_buf +
(0xF & -bufaddr) / sizeof(word32);
(0xF & -bufaddr) / sizeof(uint32_t);
assert((size_t)ctx->keysched % 16 == 0);
bufaddr = (size_t)ctx->invkeysched_buf;
ctx->invkeysched = ctx->invkeysched_buf +
(0xF & -bufaddr) / sizeof(word32);
(0xF & -bufaddr) / sizeof(uint32_t);
assert((size_t)ctx->invkeysched % 16 == 0);
ctx->isNI = supports_aes_ni();
@ -726,7 +726,7 @@ static void aes_setup(AESContext * ctx, const unsigned char *key, int keylen)
if (i < Nk)
ctx->keysched[i] = GET_32BIT_MSB_FIRST(key + 4 * i);
else {
word32 temp = ctx->keysched[i - 1];
uint32_t temp = ctx->keysched[i - 1];
if (i % Nk == 0) {
int a, b, c, d;
a = (temp >> 16) & 0xFF;
@ -758,7 +758,7 @@ static void aes_setup(AESContext * ctx, const unsigned char *key, int keylen)
*/
for (i = 0; i <= ctx->Nr; i++) {
for (j = 0; j < NB; j++) {
word32 temp;
uint32_t temp;
temp = ctx->keysched[(ctx->Nr - i) * NB + j];
if (i != 0 && i != ctx->Nr) {
/*
@ -826,7 +826,7 @@ static void aes_setup(AESContext * ctx, const unsigned char *key, int keylen)
*/
static void aes_encrypt_cbc_sw(unsigned char *blk, int len, AESContext * ctx)
{
word32 block[4];
uint32_t block[4];
unsigned char* finish = blk + len;
int i;
@ -835,8 +835,8 @@ static void aes_encrypt_cbc_sw(unsigned char *blk, int len, AESContext * ctx)
memcpy(block, ctx->iv, sizeof(block));
while (blk < finish) {
word32 *keysched = ctx->keysched;
word32 newstate[4];
uint32_t *keysched = ctx->keysched;
uint32_t newstate[4];
for (i = 0; i < 4; i++)
block[i] ^= GET_32BIT_MSB_FIRST(blk + 4 * i);
ADD_ROUND_KEY;
@ -872,7 +872,7 @@ static void aes_encrypt_cbc_sw(unsigned char *blk, int len, AESContext * ctx)
static void aes_sdctr_sw(unsigned char *blk, int len, AESContext *ctx)
{
word32 iv[4];
uint32_t iv[4];
unsigned char* finish = blk + len;
int i;
@ -881,8 +881,8 @@ static void aes_sdctr_sw(unsigned char *blk, int len, AESContext *ctx)
memcpy(iv, ctx->iv, sizeof(iv));
while (blk < finish) {
word32 *keysched = ctx->keysched;
word32 newstate[4], block[4], tmp;
uint32_t *keysched = ctx->keysched;
uint32_t newstate[4], block[4], tmp;
memcpy(block, iv, sizeof(block));
ADD_ROUND_KEY;
switch (ctx->Nr) {
@ -922,7 +922,7 @@ static void aes_sdctr_sw(unsigned char *blk, int len, AESContext *ctx)
static void aes_decrypt_cbc_sw(unsigned char *blk, int len, AESContext * ctx)
{
word32 iv[4];
uint32_t iv[4];
unsigned char* finish = blk + len;
int i;
@ -931,8 +931,8 @@ static void aes_decrypt_cbc_sw(unsigned char *blk, int len, AESContext * ctx)
memcpy(iv, ctx->iv, sizeof(iv));
while (blk < finish) {
word32 *keysched = ctx->invkeysched;
word32 newstate[4], ct[4], block[4];
uint32_t *keysched = ctx->invkeysched;
uint32_t newstate[4], ct[4], block[4];
for (i = 0; i < 4; i++)
block[i] = ct[i] = GET_32BIT_MSB_FIRST(blk + 4 * i);
ADD_ROUND_KEY;

86
sshblowf.c
View File

@ -10,8 +10,8 @@
#include "sshblowf.h"
struct BlowfishContext {
word32 S0[256], S1[256], S2[256], S3[256], P[18];
word32 iv0, iv1; /* for CBC mode */
uint32_t S0[256], S1[256], S2[256], S3[256], P[18];
uint32_t iv0, iv1; /* for CBC mode */
};
/*
@ -27,7 +27,7 @@ struct BlowfishContext {
open my $spig, "spigot -n -B16 -d8336 pi |";
read $spig, $ignore, 2; # throw away the leading "3."
for my $name ("parray", "sbox0".."sbox3") {
print "static const word32 ${name}[] = {\n";
print "static const uint32_t ${name}[] = {\n";
my $len = $name eq "parray" ? 18 : 256;
for my $i (1..$len) {
read $spig, $word, 8;
@ -39,13 +39,13 @@ for my $name ("parray", "sbox0".."sbox3") {
close $spig;
*/
static const word32 parray[] = {
static const uint32_t parray[] = {
0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344, 0xA4093822, 0x299F31D0,
0x082EFA98, 0xEC4E6C89, 0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C,
0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917, 0x9216D5D9, 0x8979FB1B,
};
static const word32 sbox0[] = {
static const uint32_t sbox0[] = {
0xD1310BA6, 0x98DFB5AC, 0x2FFD72DB, 0xD01ADFB7, 0xB8E1AFED, 0x6A267E96,
0xBA7C9045, 0xF12C7F99, 0x24A19947, 0xB3916CF7, 0x0801F2E2, 0x858EFC16,
0x636920D8, 0x71574E69, 0xA458FEA3, 0xF4933D7E, 0x0D95748F, 0x728EB658,
@ -91,7 +91,7 @@ static const word32 sbox0[] = {
0x53B02D5D, 0xA99F8FA1, 0x08BA4799, 0x6E85076A,
};
static const word32 sbox1[] = {
static const uint32_t sbox1[] = {
0x4B7A70E9, 0xB5B32944, 0xDB75092E, 0xC4192623, 0xAD6EA6B0, 0x49A7DF7D,
0x9CEE60B8, 0x8FEDB266, 0xECAA8C71, 0x699A17FF, 0x5664526C, 0xC2B19EE1,
0x193602A5, 0x75094C29, 0xA0591340, 0xE4183A3E, 0x3F54989A, 0x5B429D65,
@ -137,7 +137,7 @@ static const word32 sbox1[] = {
0x153E21E7, 0x8FB03D4A, 0xE6E39F2B, 0xDB83ADF7,
};
static const word32 sbox2[] = {
static const uint32_t sbox2[] = {
0xE93D5A68, 0x948140F7, 0xF64C261C, 0x94692934, 0x411520F7, 0x7602D4F7,
0xBCF46B2E, 0xD4A20068, 0xD4082471, 0x3320F46A, 0x43B7D4B7, 0x500061AF,
0x1E39F62E, 0x97244546, 0x14214F74, 0xBF8B8840, 0x4D95FC1D, 0x96B591AF,
@ -183,7 +183,7 @@ static const word32 sbox2[] = {
0xD79A3234, 0x92638212, 0x670EFA8E, 0x406000E0,
};
static const word32 sbox3[] = {
static const uint32_t sbox3[] = {
0x3A39CE37, 0xD3FAF5CF, 0xABC27737, 0x5AC52D1B, 0x5CB0679E, 0x4FA33742,
0xD3822740, 0x99BC9BBE, 0xD5118E9D, 0xBF0F7315, 0xD62D1C7E, 0xC700C47B,
0xB78C1B6B, 0x21A19045, 0xB26EB1BE, 0x6A366EB4, 0x5748AB2F, 0xBC946E79,
@ -233,15 +233,15 @@ static const word32 sbox3[] = {
#define F(x) Fprime( ((x>>24)&0xFF), ((x>>16)&0xFF), ((x>>8)&0xFF), (x&0xFF) )
#define ROUND(n) ( xL ^= P[n], t = xL, xL = F(xL) ^ xR, xR = t )
static void blowfish_encrypt(word32 xL, word32 xR, word32 * output,
static void blowfish_encrypt(uint32_t xL, uint32_t xR, uint32_t *output,
BlowfishContext * ctx)
{
word32 *S0 = ctx->S0;
word32 *S1 = ctx->S1;
word32 *S2 = ctx->S2;
word32 *S3 = ctx->S3;
word32 *P = ctx->P;
word32 t;
uint32_t *S0 = ctx->S0;
uint32_t *S1 = ctx->S1;
uint32_t *S2 = ctx->S2;
uint32_t *S3 = ctx->S3;
uint32_t *P = ctx->P;
uint32_t t;
ROUND(0);
ROUND(1);
@ -266,15 +266,15 @@ static void blowfish_encrypt(word32 xL, word32 xR, word32 * output,
output[1] = xL;
}
static void blowfish_decrypt(word32 xL, word32 xR, word32 * output,
static void blowfish_decrypt(uint32_t xL, uint32_t xR, uint32_t *output,
BlowfishContext * ctx)
{
word32 *S0 = ctx->S0;
word32 *S1 = ctx->S1;
word32 *S2 = ctx->S2;
word32 *S3 = ctx->S3;
word32 *P = ctx->P;
word32 t;
uint32_t *S0 = ctx->S0;
uint32_t *S1 = ctx->S1;
uint32_t *S2 = ctx->S2;
uint32_t *S3 = ctx->S3;
uint32_t *P = ctx->P;
uint32_t t;
ROUND(17);
ROUND(16);
@ -302,7 +302,7 @@ static void blowfish_decrypt(word32 xL, word32 xR, word32 * output,
static void blowfish_lsb_encrypt_cbc(unsigned char *blk, int len,
BlowfishContext * ctx)
{
word32 xL, xR, out[2], iv0, iv1;
uint32_t xL, xR, out[2], iv0, iv1;
assert((len & 7) == 0);
@ -330,7 +330,7 @@ static void blowfish_lsb_encrypt_cbc(unsigned char *blk, int len,
void blowfish_lsb_encrypt_ecb(void *vblk, int len, BlowfishContext * ctx)
{
unsigned char *blk = (unsigned char *)vblk;
word32 xL, xR, out[2];
uint32_t xL, xR, out[2];
assert((len & 7) == 0);
@ -348,7 +348,7 @@ void blowfish_lsb_encrypt_ecb(void *vblk, int len, BlowfishContext * ctx)
static void blowfish_lsb_decrypt_cbc(unsigned char *blk, int len,
BlowfishContext * ctx)
{
word32 xL, xR, out[2], iv0, iv1;
uint32_t xL, xR, out[2], iv0, iv1;
assert((len & 7) == 0);
@ -376,7 +376,7 @@ static void blowfish_lsb_decrypt_cbc(unsigned char *blk, int len,
static void blowfish_msb_encrypt_cbc(unsigned char *blk, int len,
BlowfishContext * ctx)
{
word32 xL, xR, out[2], iv0, iv1;
uint32_t xL, xR, out[2], iv0, iv1;
assert((len & 7) == 0);
@ -404,7 +404,7 @@ static void blowfish_msb_encrypt_cbc(unsigned char *blk, int len,
static void blowfish_msb_decrypt_cbc(unsigned char *blk, int len,
BlowfishContext * ctx)
{
word32 xL, xR, out[2], iv0, iv1;
uint32_t xL, xR, out[2], iv0, iv1;
assert((len & 7) == 0);
@ -432,7 +432,7 @@ static void blowfish_msb_decrypt_cbc(unsigned char *blk, int len,
static void blowfish_msb_sdctr(unsigned char *blk, int len,
BlowfishContext * ctx)
{
word32 b[2], iv0, iv1, tmp;
uint32_t b[2], iv0, iv1, tmp;
assert((len & 7) == 0);
@ -477,12 +477,12 @@ void blowfish_expandkey(BlowfishContext * ctx,
{
const unsigned char *key = (const unsigned char *)vkey;
const unsigned char *salt = (const unsigned char *)vsalt;
word32 *S0 = ctx->S0;
word32 *S1 = ctx->S1;
word32 *S2 = ctx->S2;
word32 *S3 = ctx->S3;
word32 *P = ctx->P;
word32 str[2];
uint32_t *S0 = ctx->S0;
uint32_t *S1 = ctx->S1;
uint32_t *S2 = ctx->S2;
uint32_t *S3 = ctx->S3;
uint32_t *P = ctx->P;
uint32_t str[2];
int i, j;
int saltpos;
unsigned char dummysalt[1];
@ -496,19 +496,19 @@ void blowfish_expandkey(BlowfishContext * ctx,
for (i = 0; i < 18; i++) {
P[i] ^=
((word32) (unsigned char) (key[(i * 4 + 0) % keybytes])) << 24;
((uint32_t) (unsigned char) (key[(i * 4 + 0) % keybytes])) << 24;
P[i] ^=
((word32) (unsigned char) (key[(i * 4 + 1) % keybytes])) << 16;
((uint32_t) (unsigned char) (key[(i * 4 + 1) % keybytes])) << 16;
P[i] ^=
((word32) (unsigned char) (key[(i * 4 + 2) % keybytes])) << 8;
P[i] ^= ((word32) (unsigned char) (key[(i * 4 + 3) % keybytes]));
((uint32_t) (unsigned char) (key[(i * 4 + 2) % keybytes])) << 8;
P[i] ^= ((uint32_t) (unsigned char) (key[(i * 4 + 3) % keybytes]));
}
str[0] = str[1] = 0;
for (i = 0; i < 18; i += 2) {
for (j = 0; j < 8; j++)
str[j/4] ^= ((word32)salt[saltpos++ % saltbytes]) << (24-8*(j%4));
str[j/4] ^= ((uint32_t)salt[saltpos++ % saltbytes]) << (24-8*(j%4));
blowfish_encrypt(str[0], str[1], str, ctx);
P[i] = str[0];
@ -517,28 +517,28 @@ void blowfish_expandkey(BlowfishContext * ctx,
for (i = 0; i < 256; i += 2) {
for (j = 0; j < 8; j++)
str[j/4] ^= ((word32)salt[saltpos++ % saltbytes]) << (24-8*(j%4));
str[j/4] ^= ((uint32_t)salt[saltpos++ % saltbytes]) << (24-8*(j%4));
blowfish_encrypt(str[0], str[1], str, ctx);
S0[i] = str[0];
S0[i + 1] = str[1];
}
for (i = 0; i < 256; i += 2) {
for (j = 0; j < 8; j++)
str[j/4] ^= ((word32)salt[saltpos++ % saltbytes]) << (24-8*(j%4));
str[j/4] ^= ((uint32_t)salt[saltpos++ % saltbytes]) << (24-8*(j%4));
blowfish_encrypt(str[0], str[1], str, ctx);
S1[i] = str[0];
S1[i + 1] = str[1];
}
for (i = 0; i < 256; i += 2) {
for (j = 0; j < 8; j++)
str[j/4] ^= ((word32)salt[saltpos++ % saltbytes]) << (24-8*(j%4));
str[j/4] ^= ((uint32_t)salt[saltpos++ % saltbytes]) << (24-8*(j%4));
blowfish_encrypt(str[0], str[1], str, ctx);
S2[i] = str[0];
S2[i + 1] = str[1];
}
for (i = 0; i < 256; i += 2) {
for (j = 0; j < 8; j++)
str[j/4] ^= ((word32)salt[saltpos++ % saltbytes]) << (24-8*(j%4));
str[j/4] ^= ((uint32_t)salt[saltpos++ % saltbytes]) << (24-8*(j%4));
blowfish_encrypt(str[0], str[1], str, ctx);
S3[i] = str[0];
S3[i + 1] = str[1];

6
sshccp.c
View File

@ -45,7 +45,7 @@ struct chacha20 {
* 4-11 are the key
* 12-13 are the counter
* 14-15 are the IV */
uint32 state[16];
uint32_t state[16];
/* The output of the state above ready to xor */
unsigned char current[64];
/* The index of the above currently used to allow a true streaming cipher */
@ -55,7 +55,7 @@ struct chacha20 {
static INLINE void chacha20_round(struct chacha20 *ctx)
{
int i;
uint32 copy[16];
uint32_t copy[16];
/* Take a copy */
memcpy(copy, ctx->state, sizeof(copy));
@ -114,7 +114,7 @@ static INLINE void chacha20_round(struct chacha20 *ctx)
/* Increment round counter */
++ctx->state[12];
/* Check for overflow, not done in one line so the 32 bits are chopped by the type */
if (!(uint32)(ctx->state[12])) {
if (!(uint32_t)(ctx->state[12])) {
++ctx->state[13];
}
}

36
sshcrcda.c
View File

@ -25,16 +25,13 @@
#include "misc.h"
#include "ssh.h"
typedef unsigned char uchar;
typedef unsigned short uint16;
/* SSH Constants */
#define SSH_MAXBLOCKS (32 * 1024)
#define SSH_BLOCKSIZE (8)
/* Hashing constants */
#define HASH_MINSIZE (8 * 1024)
#define HASH_ENTRYSIZE (sizeof(uint16))
#define HASH_ENTRYSIZE (sizeof(uint16_t))
#define HASH_FACTOR(x) ((x)*3/2)
#define HASH_UNUSEDCHAR (0xff)
#define HASH_UNUSED (0xffff)
@ -47,12 +44,12 @@ typedef unsigned short uint16;
#define CMP(a, b) (memcmp(a, b, SSH_BLOCKSIZE))
uchar ONE[4] = { 1, 0, 0, 0 };
uchar ZERO[4] = { 0, 0, 0, 0 };
uint8_t ONE[4] = { 1, 0, 0, 0 };
uint8_t ZERO[4] = { 0, 0, 0, 0 };
struct crcda_ctx {
uint16 *h;
uint32 n;
uint16_t *h;
uint32_t n;
};
struct crcda_ctx *crcda_make_context(void)
@ -72,16 +69,16 @@ void crcda_free_context(struct crcda_ctx *ctx)
}
}
static void crc_update(uint32 *a, void *b)
static void crc_update(uint32_t *a, void *b)
{
*a = crc32_update(*a, b, 4);
}
/* detect if a block is used in a particular pattern */
static int check_crc(uchar *S, uchar *buf, uint32 len, uchar *IV)
static int check_crc(uint8_t *S, uint8_t *buf, uint32_t len, uint8_t *IV)
{
uint32 crc;
uchar *c;
uint32_t crc;
uint8_t *c;
crc = 0;
if (IV && !CMP(S, IV)) {
@ -101,12 +98,13 @@ static int check_crc(uchar *S, uchar *buf, uint32 len, uchar *IV)
}
/* Detect a crc32 compensation attack on a packet */
int detect_attack(struct crcda_ctx *ctx, uchar *buf, uint32 len, uchar *IV)
int detect_attack(
struct crcda_ctx *ctx, uint8_t *buf, uint32_t len, uint8_t *IV)
{
register uint32 i, j;
uint32 l;
register uchar *c;
uchar *d;
register uint32_t i, j;
uint32_t l;
register uint8_t *c;
uint8_t *d;
assert(!(len > (SSH_MAXBLOCKS * SSH_BLOCKSIZE) ||
len % SSH_BLOCKSIZE != 0));
@ -115,11 +113,11 @@ int detect_attack(struct crcda_ctx *ctx, uchar *buf, uint32 len, uchar *IV)
if (ctx->h == NULL) {
ctx->n = l;
ctx->h = snewn(ctx->n, uint16);
ctx->h = snewn(ctx->n, uint16_t);
} else {
if (l > ctx->n) {
ctx->n = l;
ctx->h = sresize(ctx->h, ctx->n, uint16);
ctx->h = sresize(ctx->h, ctx->n, uint16_t);
}
}

39
sshdes.c
View File

@ -277,16 +277,16 @@
*/
typedef struct {
word32 k0246[16], k1357[16];
word32 iv0, iv1;
uint32_t k0246[16], k1357[16];
uint32_t iv0, iv1;
} DESContext;
#define rotl(x, c) ( (x << c) | (x >> (32-c)) )
#define rotl28(x, c) ( ( (x << c) | (x >> (28-c)) ) & 0x0FFFFFFF)
static word32 bitsel(word32 * input, const int *bitnums, int size)
static uint32_t bitsel(uint32_t *input, const int *bitnums, int size)
{
word32 ret = 0;
uint32_t ret = 0;
while (size--) {
int bitpos = *bitnums++;
ret <<= 1;
@ -296,7 +296,8 @@ static word32 bitsel(word32 * input, const int *bitnums, int size)
return ret;
}
static void des_key_setup(word32 key_msw, word32 key_lsw, DESContext * sched)
static void des_key_setup(
uint32_t key_msw, uint32_t key_lsw, DESContext *sched)
{
static const int PC1_Cbits[] = {
@ -326,8 +327,8 @@ static void des_key_setup(word32 key_msw, word32 key_lsw, DESContext * sched)
static const int leftshifts[] =
{ 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
word32 C, D;
word32 buf[2];
uint32_t C, D;
uint32_t buf[2];
int i;
buf[0] = key_lsw;
@ -348,7 +349,7 @@ static void des_key_setup(word32 key_msw, word32 key_lsw, DESContext * sched)
sched->iv0 = sched->iv1 = 0;
}
static const word32 SPboxes[8][64] = {
static const uint32_t SPboxes[8][64] = {
{0x01010400, 0x00000000, 0x00010000, 0x01010404,
0x01010004, 0x00010404, 0x00000004, 0x00010000,
0x00000400, 0x01010400, 0x01010404, 0x00000400,
@ -520,10 +521,10 @@ static const word32 SPboxes[8][64] = {
bitswap(R, L, 16, 0x0000FFFF), \
bitswap(R, L, 4, 0x0F0F0F0F))
static void des_encipher(word32 * output, word32 L, word32 R,
DESContext * sched)
static void des_encipher(
uint32_t *output, uint32_t L, uint32_t R, DESContext *sched)
{
word32 swap, s0246, s1357;
uint32_t swap, s0246, s1357;
IP(L, R);
@ -560,10 +561,10 @@ static void des_encipher(word32 * output, word32 L, word32 R,
output[1] = R;
}
static void des_decipher(word32 * output, word32 L, word32 R,
DESContext * sched)
static void des_decipher(
uint32_t *output, uint32_t L, uint32_t R, DESContext *sched)
{
word32 swap, s0246, s1357;
uint32_t swap, s0246, s1357;
IP(L, R);
@ -603,7 +604,7 @@ static void des_decipher(word32 * output, word32 L, word32 R,
static void des_cbc_encrypt(unsigned char *blk,
unsigned int len, DESContext * sched)
{
word32 out[2], iv0, iv1;
uint32_t out[2], iv0, iv1;
unsigned int i;
assert((len & 7) == 0);
@ -627,7 +628,7 @@ static void des_cbc_encrypt(unsigned char *blk,
static void des_cbc_decrypt(unsigned char *blk,
unsigned int len, DESContext * sched)
{
word32 out[2], iv0, iv1, xL, xR;
uint32_t out[2], iv0, iv1, xL, xR;
unsigned int i;
assert((len & 7) == 0);
@ -661,7 +662,7 @@ static void des_3cbc_encrypt(unsigned char *blk,
static void des_cbc3_encrypt(unsigned char *blk,
unsigned int len, DESContext * scheds)
{
word32 out[2], iv0, iv1;
uint32_t out[2], iv0, iv1;
unsigned int i;
assert((len & 7) == 0);
@ -695,7 +696,7 @@ static void des_3cbc_decrypt(unsigned char *blk,
static void des_cbc3_decrypt(unsigned char *blk,
unsigned int len, DESContext * scheds)
{
word32 out[2], iv0, iv1, xL, xR;
uint32_t out[2], iv0, iv1, xL, xR;
unsigned int i;
assert((len & 7) == 0);
@ -723,7 +724,7 @@ static void des_cbc3_decrypt(unsigned char *blk,
static void des_sdctr3(unsigned char *blk,
unsigned int len, DESContext * scheds)
{
word32 b[2], iv0, iv1, tmp;
uint32_t b[2], iv0, iv1, tmp;
unsigned int i;
assert((len & 7) == 0);

37
sshmd5.c
View File

@ -15,7 +15,7 @@
#define H(x,y,z) ( (x) ^ (y) ^ (z) )
#define I(x,y,z) ( (y) ^ ( (x) | ~(z) ) )
#define rol(x,y) ( ((x) << (y)) | (((uint32)x) >> (32-y)) )
#define rol(x,y) ( ((x) << (y)) | (((uint32_t)x) >> (32-y)) )
#define subround(f,w,x,y,z,k,s,ti) \
w = x + rol(w + f(x,y,z) + block[k] + ti, s)
@ -28,9 +28,9 @@ static void MD5_Core_Init(MD5_Core_State * s)
s->h[3] = 0x10325476;
}
static void MD5_Block(MD5_Core_State * s, uint32 * block)
static void MD5_Block(MD5_Core_State *s, uint32_t *block)
{
uint32 a, b, c, d;
uint32_t a, b, c, d;
a = s->h[0];
b = s->h[1];
@ -122,7 +122,7 @@ void MD5Init(struct MD5Context *s)
{
MD5_Core_Init(&s->core);
s->blkused = 0;
s->lenhi = s->lenlo = 0;
s->len = 0;
BinarySink_INIT(s, MD5_BinarySink_write);
}
@ -130,8 +130,8 @@ static void MD5_BinarySink_write(BinarySink *bs, const void *data, size_t len)
{
struct MD5Context *s = BinarySink_DOWNCAST(bs, struct MD5Context);
const unsigned char *q = (const unsigned char *)data;
uint32 wordblock[16];
uint32 lenw = len;
uint32_t wordblock[16];
uint32_t lenw = len;
int i;
assert(lenw == len);
@ -139,8 +139,7 @@ static void MD5_BinarySink_write(BinarySink *bs, const void *data, size_t len)
/*
* Update the length field.
*/
s->lenlo += lenw;
s->lenhi += (s->lenlo < lenw);
s->len += lenw;
if (s->blkused + len < BLKSIZE) {
/*
@ -159,10 +158,10 @@ static void MD5_BinarySink_write(BinarySink *bs, const void *data, size_t len)
/* Now process the block. Gather bytes little-endian into words */
for (i = 0; i < 16; i++) {
wordblock[i] =
(((uint32) s->block[i * 4 + 3]) << 24) |
(((uint32) s->block[i * 4 + 2]) << 16) |
(((uint32) s->block[i * 4 + 1]) << 8) |
(((uint32) s->block[i * 4 + 0]) << 0);
(((uint32_t) s->block[i * 4 + 3]) << 24) |
(((uint32_t) s->block[i * 4 + 2]) << 16) |
(((uint32_t) s->block[i * 4 + 1]) << 8) |
(((uint32_t) s->block[i * 4 + 0]) << 0);
}
MD5_Block(&s->core, wordblock);
s->blkused = 0;
@ -177,28 +176,20 @@ void MD5Final(unsigned char output[16], struct MD5Context *s)
int i;
unsigned pad;
unsigned char c[64];
uint32 lenhi, lenlo;
uint64_t len;
if (s->blkused >= 56)
pad = 56 + 64 - s->blkused;
else
pad = 56 - s->blkused;
lenhi = (s->lenhi << 3) | (s->lenlo >> (32 - 3));
lenlo = (s->lenlo << 3);
len = (s->len << 3);
memset(c, 0, pad);
c[0] = 0x80;
put_data(s, c, pad);
c[7] = (lenhi >> 24) & 0xFF;
c[6] = (lenhi >> 16) & 0xFF;
c[5] = (lenhi >> 8) & 0xFF;
c[4] = (lenhi >> 0) & 0xFF;
c[3] = (lenlo >> 24) & 0xFF;
c[2] = (lenlo >> 16) & 0xFF;
c[1] = (lenlo >> 8) & 0xFF;
c[0] = (lenlo >> 0) & 0xFF;
PUT_64BIT_LSB_FIRST(c, len);
put_data(s, c, 8);

30
sshrand.c
View File

@ -70,8 +70,8 @@ int random_diagnostics = 0;
static void random_stir(void)
{
word32 block[HASHINPUT / sizeof(word32)];
word32 digest[HASHSIZE / sizeof(word32)];
uint32_t block[HASHINPUT / sizeof(uint32_t)];
uint32_t digest[HASHSIZE / sizeof(uint32_t)];
int i, j, k;
/*
@ -91,24 +91,24 @@ static void random_stir(void)
for (p = 0; p < POOLSIZE; p += HASHSIZE) {
printf(" ");
for (q = 0; q < HASHSIZE; q += 4) {
printf(" %08x", *(word32 *)(pool.pool + p + q));
printf(" %08x", *(uint32_t *)(pool.pool + p + q));
}
printf("\n");
}
printf("incoming:\n ");
for (q = 0; q < HASHSIZE; q += 4) {
printf(" %08x", *(word32 *)(pool.incoming + q));
printf(" %08x", *(uint32_t *)(pool.incoming + q));
}
printf("\nincomingb:\n ");
for (q = 0; q < HASHINPUT; q += 4) {
printf(" %08x", *(word32 *)(pool.incomingb + q));
printf(" %08x", *(uint32_t *)(pool.incomingb + q));
}
printf("\n");
random_diagnostics++;
}
#endif
SHATransform((word32 *) pool.incoming, (word32 *) pool.incomingb);
SHATransform((uint32_t *) pool.incoming, (uint32_t *) pool.incomingb);
pool.incomingpos = 0;
/*
@ -144,7 +144,7 @@ static void random_stir(void)
*/
for (k = 0; k < sizeof(digest) / sizeof(*digest); k++)
digest[k] ^= ((word32 *) (pool.pool + j))[k];
digest[k] ^= ((uint32_t *) (pool.pool + j))[k];
/*
* Munge our unrevealed first block of the pool into
@ -157,7 +157,7 @@ static void random_stir(void)
*/
for (k = 0; k < sizeof(digest) / sizeof(*digest); k++)
((word32 *) (pool.pool + j))[k] = digest[k];
((uint32_t *) (pool.pool + j))[k] = digest[k];
}
#ifdef RANDOM_DIAGNOSTICS
@ -167,17 +167,17 @@ static void random_stir(void)
for (p = 0; p < POOLSIZE; p += HASHSIZE) {
printf(" ");
for (q = 0; q < HASHSIZE; q += 4) {
printf(" %08x", *(word32 *)(pool.pool + p + q));
printf(" %08x", *(uint32_t *)(pool.pool + p + q));
}
printf("\n");
}
printf("incoming:\n ");
for (q = 0; q < HASHSIZE; q += 4) {
printf(" %08x", *(word32 *)(pool.incoming + q));
printf(" %08x", *(uint32_t *)(pool.incoming + q));
}
printf("\nincomingb:\n ");
for (q = 0; q < HASHINPUT; q += 4) {
printf(" %08x", *(word32 *)(pool.incomingb + q));
printf(" %08x", *(uint32_t *)(pool.incomingb + q));
}
printf("\n");
}
@ -202,17 +202,17 @@ static void random_stir(void)
for (p = 0; p < POOLSIZE; p += HASHSIZE) {
printf(" ");
for (q = 0; q < HASHSIZE; q += 4) {
printf(" %08x", *(word32 *)(pool.pool + p + q));
printf(" %08x", *(uint32_t *)(pool.pool + p + q));
}
printf("\n");
}
printf("incoming:\n ");
for (q = 0; q < HASHSIZE; q += 4) {
printf(" %08x", *(word32 *)(pool.incoming + q));
printf(" %08x", *(uint32_t *)(pool.incoming + q));
}
printf("\nincomingb:\n ");
for (q = 0; q < HASHINPUT; q += 4) {
printf(" %08x", *(word32 *)(pool.incomingb + q));
printf(" %08x", *(uint32_t *)(pool.incomingb + q));
}
printf("\n");
random_diagnostics--;
@ -238,7 +238,7 @@ void random_add_noise(void *noise, int length)
HASHINPUT - pool.incomingpos);
p += HASHINPUT - pool.incomingpos;
length -= HASHINPUT - pool.incomingpos;
SHATransform((word32 *) pool.incoming, (word32 *) pool.incomingb);
SHATransform((uint32_t *) pool.incoming, (uint32_t *) pool.incomingb);
for (i = 0; i < HASHSIZE; i++) {
pool.pool[pool.poolpos++] ^= pool.incoming[i];
if (pool.poolpos >= POOLSIZE)

39
sshsh256.c
View File

@ -11,8 +11,8 @@
* Core SHA256 algorithm: processes 16-word blocks into a message digest.
*/
#define ror(x,y) ( ((x) << (32-y)) | (((uint32)(x)) >> (y)) )
#define shr(x,y) ( (((uint32)(x)) >> (y)) )
#define ror(x,y) ( ((x) << (32-y)) | (((uint32_t)(x)) >> (y)) )
#define shr(x,y) ( (((uint32_t)(x)) >> (y)) )
#define Ch(x,y,z) ( ((x) & (y)) ^ (~(x) & (z)) )
#define Maj(x,y,z) ( ((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)) )
#define bigsigma0(x) ( ror((x),2) ^ ror((x),13) ^ ror((x),22) )
@ -34,9 +34,9 @@ void SHA256_Core_Init(SHA256_State *s) {
s->h[7] = 0x5be0cd19;
}
void SHA256_Block(SHA256_State *s, uint32 *block) {
uint32 w[80];
uint32 a,b,c,d,e,f,g,h;
void SHA256_Block(SHA256_State *s, uint32_t *block) {
uint32_t w[80];
uint32_t a,b,c,d,e,f,g,h;
static const int k[] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
@ -68,7 +68,7 @@ void SHA256_Block(SHA256_State *s, uint32 *block) {
e = s->h[4]; f = s->h[5]; g = s->h[6]; h = s->h[7];
for (t = 0; t < 64; t+=8) {
uint32 t1, t2;
uint32_t t1, t2;
#define ROUND(j,a,b,c,d,e,f,g,h) \
t1 = h + bigsigma1(e) + Ch(e,f,g) + k[j] + w[j]; \
@ -103,7 +103,7 @@ static void SHA256_BinarySink_write(BinarySink *bs,
void SHA256_Init(SHA256_State *s) {
SHA256_Core_Init(s);
s->blkused = 0;
s->lenhi = s->lenlo = 0;
s->len = 0;
if (supports_sha_ni())
s->sha256 = &SHA256_ni;
else
@ -117,19 +117,16 @@ static void SHA256_BinarySink_write(BinarySink *bs,
struct SHA256_State *s = BinarySink_DOWNCAST(bs, struct SHA256_State);
unsigned char *q = (unsigned char *)p;
uint32 lenw = len;
assert(len == lenw);
/*
* Update the length field.
*/
s->lenlo += lenw;
s->lenhi += (s->lenlo < lenw);
s->len += len;
(*(s->sha256))(s, q, len);
}
static void SHA256_sw(SHA256_State *s, const unsigned char *q, int len) {
uint32 wordblock[16];
uint32_t wordblock[16];
int i;
if (s->blkused && s->blkused+len < BLKSIZE) {
@ -149,10 +146,10 @@ static void SHA256_sw(SHA256_State *s, const unsigned char *q, int len) {
/* Now process the block. Gather bytes big-endian into words */
for (i = 0; i < 16; i++) {
wordblock[i] =
( ((uint32)s->block[i*4+0]) << 24 ) |
( ((uint32)s->block[i*4+1]) << 16 ) |
( ((uint32)s->block[i*4+2]) << 8 ) |
( ((uint32)s->block[i*4+3]) << 0 );
( ((uint32_t)s->block[i*4+0]) << 24 ) |
( ((uint32_t)s->block[i*4+1]) << 16 ) |
( ((uint32_t)s->block[i*4+2]) << 8 ) |
( ((uint32_t)s->block[i*4+3]) << 0 );
}
SHA256_Block(s, wordblock);
s->blkused = 0;
@ -166,22 +163,20 @@ void SHA256_Final(SHA256_State *s, unsigned char *digest) {
int i;
int pad;
unsigned char c[64];
uint32 lenhi, lenlo;
uint64_t len;
if (s->blkused >= 56)
pad = 56 + 64 - s->blkused;
else
pad = 56 - s->blkused;
lenhi = (s->lenhi << 3) | (s->lenlo >> (32-3));
lenlo = (s->lenlo << 3);
len = (s->len << 3);
memset(c, 0, pad);
c[0] = 0x80;
put_data(s, &c, pad);
put_uint32(s, lenhi);
put_uint32(s, lenlo);
put_uint64(s, len);
for (i = 0; i < 8; i++) {
digest[i*4+0] = (s->h[i] >> 24) & 0xFF;

104
sshsh512.c
View File

@ -15,21 +15,17 @@
* Arithmetic implementations. Note that AND, XOR and NOT can
* overlap destination with one source, but the others can't.
*/
#define add(r,x,y) ( r.lo = y.lo + x.lo, \
r.hi = y.hi + x.hi + ((uint32)r.lo < (uint32)y.lo) )
#define rorB(r,x,y) ( r.lo = ((uint32)x.hi >> ((y)-32)) | ((uint32)x.lo << (64-(y))), \
r.hi = ((uint32)x.lo >> ((y)-32)) | ((uint32)x.hi << (64-(y))) )
#define rorL(r,x,y) ( r.lo = ((uint32)x.lo >> (y)) | ((uint32)x.hi << (32-(y))), \
r.hi = ((uint32)x.hi >> (y)) | ((uint32)x.lo << (32-(y))) )
#define shrB(r,x,y) ( r.lo = (uint32)x.hi >> ((y)-32), r.hi = 0 )
#define shrL(r,x,y) ( r.lo = ((uint32)x.lo >> (y)) | ((uint32)x.hi << (32-(y))), \
r.hi = (uint32)x.hi >> (y) )
#define and(r,x,y) ( r.lo = x.lo & y.lo, r.hi = x.hi & y.hi )
#define xor(r,x,y) ( r.lo = x.lo ^ y.lo, r.hi = x.hi ^ y.hi )
#define not(r,x) ( r.lo = ~x.lo, r.hi = ~x.hi )
#define INIT(h,l) { h, l }
#define BUILD(r,h,l) ( r.hi = h, r.lo = l )
#define EXTRACT(h,l,r) ( h = r.hi, l = r.lo )
#define add(r,x,y) ( r = (x) + (y) )
#define rorB(r,x,y) ( r = ((x) >> (y)) | ((x) << (64-(y))) )
#define rorL(r,x,y) ( r = ((x) >> (y)) | ((x) << (64-(y))) )
#define shrB(r,x,y) ( r = (x) >> (y) )
#define shrL(r,x,y) ( r = (x) >> (y) )
#define and(r,x,y) ( r = (x) & (y) )
#define xor(r,x,y) ( r = (x) ^ (y) )
#define not(r,x) ( r = ~(x) )
#define INIT(h,l) ((((uint64_t)(h)) << 32) | (l))
#define BUILD(r,h,l) ( r = ((((uint64_t)(h)) << 32) | (l)) )
#define EXTRACT(h,l,r) ( h = (r) >> 32, l = (r) & 0xFFFFFFFFU )
/* ----------------------------------------------------------------------
* Core SHA512 algorithm: processes 16-doubleword blocks into a
@ -49,7 +45,7 @@
shrL(t,x,6), xor(r,r,t) )
static void SHA512_Core_Init(SHA512_State *s) {
static const uint64 iv[] = {
static const uint64_t iv[] = {
INIT(0x6a09e667, 0xf3bcc908),
INIT(0xbb67ae85, 0x84caa73b),
INIT(0x3c6ef372, 0xfe94f82b),
@ -65,7 +61,7 @@ static void SHA512_Core_Init(SHA512_State *s) {
}
static void SHA384_Core_Init(SHA512_State *s) {
static const uint64 iv[] = {
static const uint64_t iv[] = {
INIT(0xcbbb9d5d, 0xc1059ed8),
INIT(0x629a292a, 0x367cd507),
INIT(0x9159015a, 0x3070dd17),
@ -80,10 +76,10 @@ static void SHA384_Core_Init(SHA512_State *s) {
s->h[i] = iv[i];
}
static void SHA512_Block(SHA512_State *s, uint64 *block) {
uint64 w[80];
uint64 a,b,c,d,e,f,g,h;
static const uint64 k[] = {
static void SHA512_Block(SHA512_State *s, uint64_t *block) {
uint64_t w[80];
uint64_t a,b,c,d,e,f,g,h;
static const uint64_t k[] = {
INIT(0x428a2f98, 0xd728ae22), INIT(0x71374491, 0x23ef65cd),
INIT(0xb5c0fbcf, 0xec4d3b2f), INIT(0xe9b5dba5, 0x8189dbbc),
INIT(0x3956c25b, 0xf348b538), INIT(0x59f111f1, 0xb605d019),
@ -132,7 +128,7 @@ static void SHA512_Block(SHA512_State *s, uint64 *block) {
w[t] = block[t];
for (t = 16; t < 80; t++) {
uint64 p, q, r, tmp;
uint64_t p, q, r, tmp;
smallsigma1(p, tmp, w[t-2]);
smallsigma0(q, tmp, w[t-15]);
add(r, p, q);
@ -144,7 +140,7 @@ static void SHA512_Block(SHA512_State *s, uint64 *block) {
e = s->h[4]; f = s->h[5]; g = s->h[6]; h = s->h[7];
for (t = 0; t < 80; t+=8) {
uint64 tmp, p, q, r;
uint64_t tmp, p, q, r;
#define ROUND(j,a,b,c,d,e,f,g,h) \
bigsigma1(p, tmp, e); \
@ -171,7 +167,7 @@ static void SHA512_Block(SHA512_State *s, uint64 *block) {
}
{
uint64 tmp;
uint64_t tmp;
#define UPDATE(state, local) ( tmp = state, add(state, tmp, local) )
UPDATE(s->h[0], a); UPDATE(s->h[1], b);
UPDATE(s->h[2], c); UPDATE(s->h[3], d);
@ -190,20 +186,16 @@ static void SHA512_BinarySink_write(BinarySink *bs,
const void *p, size_t len);
void SHA512_Init(SHA512_State *s) {
int i;
SHA512_Core_Init(s);
s->blkused = 0;
for (i = 0; i < 4; i++)
s->len[i] = 0;
s->lenhi = s->lenlo = 0;
BinarySink_INIT(s, SHA512_BinarySink_write);
}
void SHA384_Init(SHA512_State *s) {
int i;
SHA384_Core_Init(s);
s->blkused = 0;
for (i = 0; i < 4; i++)
s->len[i] = 0;
s->lenhi = s->lenlo = 0;
BinarySink_INIT(s, SHA512_BinarySink_write);
}
@ -212,19 +204,14 @@ static void SHA512_BinarySink_write(BinarySink *bs,
{
SHA512_State *s = BinarySink_DOWNCAST(bs, SHA512_State);
unsigned char *q = (unsigned char *)p;
uint64 wordblock[16];
uint32 lenw = len;
uint64_t wordblock[16];
int i;
assert(lenw == len);
/*
* Update the length field.
*/
for (i = 0; i < 4; i++) {
s->len[i] += lenw;
lenw = (s->len[i] < lenw);
}
s->lenlo += len;
s->lenhi += (s->lenlo < len);
if (s->blkused && s->blkused+len < BLKSIZE) {
/*
@ -241,18 +228,8 @@ static void SHA512_BinarySink_write(BinarySink *bs,
q += BLKSIZE - s->blkused;
len -= BLKSIZE - s->blkused;
/* Now process the block. Gather bytes big-endian into words */
for (i = 0; i < 16; i++) {
uint32 h, l;
h = ( ((uint32)s->block[i*8+0]) << 24 ) |
( ((uint32)s->block[i*8+1]) << 16 ) |
( ((uint32)s->block[i*8+2]) << 8 ) |
( ((uint32)s->block[i*8+3]) << 0 );
l = ( ((uint32)s->block[i*8+4]) << 24 ) |
( ((uint32)s->block[i*8+5]) << 16 ) |
( ((uint32)s->block[i*8+6]) << 8 ) |
( ((uint32)s->block[i*8+7]) << 0 );
BUILD(wordblock[i], h, l);
}
for (i = 0; i < 16; i++)
wordblock[i] = GET_64BIT_MSB_FIRST(s->block + i*8);
SHA512_Block(s, wordblock);
s->blkused = 0;
}
@ -265,38 +242,25 @@ void SHA512_Final(SHA512_State *s, unsigned char *digest) {
int i;
int pad;
unsigned char c[BLKSIZE];
uint32 len[4];
uint64_t lenhi, lenlo;
if (s->blkused >= BLKSIZE-16)
pad = (BLKSIZE-16) + BLKSIZE - s->blkused;
else
pad = (BLKSIZE-16) - s->blkused;
for (i = 4; i-- ;) {
uint32 lenhi = s->len[i];
uint32 lenlo = i > 0 ? s->len[i-1] : 0;
len[i] = (lenhi << 3) | (lenlo >> (32-3));
}
lenhi = (s->lenhi << 3) | (s->lenlo >> (32-3));
lenlo = (s->lenlo << 3);
memset(c, 0, pad);
c[0] = 0x80;
put_data(s, &c, pad);
for (i = 0; i < 4; i++)
put_uint32(s, len[3-i]);
put_uint64(s, lenhi);
put_uint64(s, lenlo);
for (i = 0; i < 8; i++) {
uint32 h, l;
EXTRACT(h, l, s->h[i]);
digest[i*8+0] = (h >> 24) & 0xFF;
digest[i*8+1] = (h >> 16) & 0xFF;
digest[i*8+2] = (h >> 8) & 0xFF;
digest[i*8+3] = (h >> 0) & 0xFF;
digest[i*8+4] = (l >> 24) & 0xFF;
digest[i*8+5] = (l >> 16) & 0xFF;
digest[i*8+6] = (l >> 8) & 0xFF;
digest[i*8+7] = (l >> 0) & 0xFF;
}
for (i = 0; i < 8; i++)
PUT_64BIT_MSB_FIRST(digest + i*8, s->h[i]);
}
void SHA384_Final(SHA512_State *s, unsigned char *digest) {

46
sshsha.c
View File

@ -13,12 +13,12 @@
* Core SHA algorithm: processes 16-word blocks into a message digest.
*/
#define rol(x,y) ( ((x) << (y)) | (((uint32)x) >> (32-y)) )
#define rol(x,y) ( ((x) << (y)) | (((uint32_t)x) >> (32-y)) )
static void sha1_sw(SHA_State * s, const unsigned char *q, int len);
static void sha1_ni(SHA_State * s, const unsigned char *q, int len);
static void SHA_Core_Init(uint32 h[5])
static void SHA_Core_Init(uint32_t h[5])
{
h[0] = 0x67452301;
h[1] = 0xefcdab89;
@ -27,10 +27,10 @@ static void SHA_Core_Init(uint32 h[5])
h[4] = 0xc3d2e1f0;
}
void SHATransform(word32 * digest, word32 * block)
void SHATransform(uint32_t * digest, uint32_t * block)
{
word32 w[80];
word32 a, b, c, d, e;
uint32_t w[80];
uint32_t a, b, c, d, e;
int t;
#ifdef RANDOM_DIAGNOSTICS
@ -52,7 +52,7 @@ void SHATransform(word32 * digest, word32 * block)
w[t] = block[t];
for (t = 16; t < 80; t++) {
word32 tmp = w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16];
uint32_t tmp = w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16];
w[t] = rol(tmp, 1);
}
@ -63,7 +63,7 @@ void SHATransform(word32 * digest, word32 * block)
e = digest[4];
for (t = 0; t < 20; t++) {
word32 tmp =
uint32_t tmp =
rol(a, 5) + ((b & c) | (d & ~b)) + e + w[t] + 0x5a827999;
e = d;
d = c;
@ -72,7 +72,7 @@ void SHATransform(word32 * digest, word32 * block)
a = tmp;
}
for (t = 20; t < 40; t++) {
word32 tmp = rol(a, 5) + (b ^ c ^ d) + e + w[t] + 0x6ed9eba1;
uint32_t tmp = rol(a, 5) + (b ^ c ^ d) + e + w[t] + 0x6ed9eba1;
e = d;
d = c;
c = rol(b, 30);
@ -80,7 +80,7 @@ void SHATransform(word32 * digest, word32 * block)
a = tmp;
}
for (t = 40; t < 60; t++) {
word32 tmp = rol(a,
uint32_t tmp = rol(a,
5) + ((b & c) | (b & d) | (c & d)) + e + w[t] +
0x8f1bbcdc;
e = d;
@ -90,7 +90,7 @@ void SHATransform(word32 * digest, word32 * block)
a = tmp;
}
for (t = 60; t < 80; t++) {
word32 tmp = rol(a, 5) + (b ^ c ^ d) + e + w[t] + 0xca62c1d6;
uint32_t tmp = rol(a, 5) + (b ^ c ^ d) + e + w[t] + 0xca62c1d6;
e = d;
d = c;
c = rol(b, 30);
@ -130,7 +130,7 @@ void SHA_Init(SHA_State * s)
{
SHA_Core_Init(s->h);
s->blkused = 0;
s->lenhi = s->lenlo = 0;
s->len = 0;
if (supports_sha_ni())
s->sha1 = &sha1_ni;
else
@ -142,20 +142,18 @@ static void SHA_BinarySink_write(BinarySink *bs, const void *p, size_t len)
{
struct SHA_State *s = BinarySink_DOWNCAST(bs, struct SHA_State);
const unsigned char *q = (const unsigned char *) p;
uint32 lenw = len;
assert(lenw == len);
/*
* Update the length field.
*/
s->lenlo += lenw;
s->lenhi += (s->lenlo < lenw);
s->len += len;
(*(s->sha1))(s, q, len);
}
static void sha1_sw(SHA_State * s, const unsigned char *q, int len)
{
uint32 wordblock[16];
uint32_t wordblock[16];
int i;
if (s->blkused && s->blkused + len < 64) {
@ -175,10 +173,10 @@ static void sha1_sw(SHA_State * s, const unsigned char *q, int len)
/* Now process the block. Gather bytes big-endian into words */
for (i = 0; i < 16; i++) {
wordblock[i] =
(((uint32) s->block[i * 4 + 0]) << 24) |
(((uint32) s->block[i * 4 + 1]) << 16) |
(((uint32) s->block[i * 4 + 2]) << 8) |
(((uint32) s->block[i * 4 + 3]) << 0);
(((uint32_t) s->block[i * 4 + 0]) << 24) |
(((uint32_t) s->block[i * 4 + 1]) << 16) |
(((uint32_t) s->block[i * 4 + 2]) << 8) |
(((uint32_t) s->block[i * 4 + 3]) << 0);
}
SHATransform(s->h, wordblock);
s->blkused = 0;
@ -193,22 +191,20 @@ void SHA_Final(SHA_State * s, unsigned char *output)
int i;
int pad;
unsigned char c[64];
uint32 lenhi, lenlo;
uint64_t len;
if (s->blkused >= 56)
pad = 56 + 64 - s->blkused;
else
pad = 56 - s->blkused;
lenhi = (s->lenhi << 3) | (s->lenlo >> (32 - 3));
lenlo = (s->lenlo << 3);
len = (s->len << 3);
memset(c, 0, pad);
c[0] = 0x80;
put_data(s, &c, pad);
put_uint32(s, lenhi);
put_uint32(s, lenlo);
put_uint64(s, len);
for (i = 0; i < 5; i++) {
output[i * 4] = (s->h[i] >> 24) & 0xFF;

29
unix/uxsftp.c
View File

@ -20,7 +20,6 @@
#include "putty.h"
#include "ssh.h"
#include "psftp.h"
#include "int64.h"
/*
* In PSFTP our selects are synchronous, so these functions are
@ -118,7 +117,7 @@ struct RFile {
int fd;
};
RFile *open_existing_file(const char *name, uint64 *size,
RFile *open_existing_file(const char *name, uint64_t *size,
unsigned long *mtime, unsigned long *atime,
long *perms)
{
@ -140,8 +139,7 @@ RFile *open_existing_file(const char *name, uint64 *size,
}
if (size)
*size = uint64_make((statbuf.st_size >> 16) >> 16,
statbuf.st_size);
*size = statbuf.st_size;
if (mtime)
*mtime = statbuf.st_mtime;
@ -190,7 +188,7 @@ WFile *open_new_file(const char *name, long perms)
}
WFile *open_existing_wfile(const char *name, uint64 *size)
WFile *open_existing_wfile(const char *name, uint64_t *size)
{
int fd;
WFile *ret;
@ -210,8 +208,7 @@ WFile *open_existing_wfile(const char *name, uint64 *size)
memset(&statbuf, 0, sizeof(statbuf));
}
*size = uint64_make((statbuf.st_size >> 16) >> 16,
statbuf.st_size);
*size = statbuf.st_size;
}
return ret;
@ -260,13 +257,10 @@ void close_wfile(WFile *f)
/* Seek offset bytes through file, from whence, where whence is
FROM_START, FROM_CURRENT, or FROM_END */
int seek_file(WFile *f, uint64 offset, int whence)
int seek_file(WFile *f, uint64_t offset, int whence)
{
off_t fileofft;
int lseek_whence;
fileofft = (((off_t) offset.hi << 16) << 16) + offset.lo;
switch (whence) {
case FROM_START:
lseek_whence = SEEK_SET;
@ -281,19 +275,12 @@ int seek_file(WFile *f, uint64 offset, int whence)
return -1;
}
return lseek(f->fd, fileofft, lseek_whence) >= 0 ? 0 : -1;
return lseek(f->fd, offset, lseek_whence) >= 0 ? 0 : -1;
}
uint64 get_file_posn(WFile *f)
uint64_t get_file_posn(WFile *f)
{
off_t fileofft;
uint64 ret;
fileofft = lseek(f->fd, (off_t) 0, SEEK_CUR);
ret = uint64_make((fileofft >> 16) >> 16, fileofft);
return ret;
return lseek(f->fd, (off_t) 0, SEEK_CUR);
}
int file_type(const char *name)

31
unix/uxsftpserver.c
View File

@ -356,11 +356,6 @@ static void uss_rename(SftpServer *srv, SftpReplyBuilder *reply,
}
}
static uint64 uint64_from_off_t(off_t off)
{
return uint64_make((off >> 16) >> 16, (off & 0xFFFFFFFFU));
}
static struct fxp_attrs uss_translate_struct_stat(const struct stat *st)
{
struct fxp_attrs attrs;
@ -370,7 +365,7 @@ static struct fxp_attrs uss_translate_struct_stat(const struct stat *st)
SSH_FILEXFER_ATTR_UIDGID |
SSH_FILEXFER_ATTR_ACMODTIME);
attrs.size = uint64_from_off_t(st->st_size);
attrs.size = st->st_size;
attrs.permissions = st->st_mode;
attrs.uid = st->st_uid;
attrs.gid = st->st_gid;
@ -421,11 +416,6 @@ static void uss_fstat(SftpServer *srv, SftpReplyBuilder *reply,
}
}
static off_t uint64_to_off_t(uint64 u)
{
return ((((off_t)u.hi) << 16) << 16) | (off_t)u.lo;
}
/*
* The guts of setstat and fsetstat, macroised so that they can call
* fchown(fd,...) or chown(path,...) depending on parameters.
@ -433,8 +423,7 @@ static off_t uint64_to_off_t(uint64 u)
#define SETSTAT_GUTS(api_prefix, api_arg, attrs, success) do \
{ \
if (attrs.flags & SSH_FILEXFER_ATTR_SIZE) \
if (api_prefix(truncate)( \
api_arg, uint64_to_off_t(attrs.size)) < 0) \
if (api_prefix(truncate)(api_arg, attrs.size) < 0) \
success = FALSE; \
if (attrs.flags & SSH_FILEXFER_ATTR_UIDGID) \
if (api_prefix(chown)(api_arg, attrs.uid, attrs.gid) < 0) \
@ -492,7 +481,7 @@ static void uss_fsetstat(SftpServer *srv, SftpReplyBuilder *reply,
}
static void uss_read(SftpServer *srv, SftpReplyBuilder *reply,
ptrlen handle, uint64 offset, unsigned length)
ptrlen handle, uint64_t offset, unsigned length)
{
UnixSftpServer *uss = container_of(srv, UnixSftpServer, srv);
int fd;
@ -513,7 +502,7 @@ static void uss_read(SftpServer *srv, SftpReplyBuilder *reply,
char *p = buf;
int status = lseek(fd, uint64_to_off_t(offset), SEEK_SET);
int status = lseek(fd, offset, SEEK_SET);
if (status >= 0 || errno == ESPIPE) {
int seekable = (status >= 0);
while (length > 0) {
@ -549,7 +538,7 @@ static void uss_read(SftpServer *srv, SftpReplyBuilder *reply,
}
static void uss_write(SftpServer *srv, SftpReplyBuilder *reply,
ptrlen handle, uint64 offset, ptrlen data)
ptrlen handle, uint64_t offset, ptrlen data)
{
UnixSftpServer *uss = container_of(srv, UnixSftpServer, srv);
int fd;
@ -560,7 +549,7 @@ static void uss_write(SftpServer *srv, SftpReplyBuilder *reply,
const char *p = data.ptr;
unsigned length = data.len;
int status = lseek(fd, uint64_to_off_t(offset), SEEK_SET);
int status = lseek(fd, offset, SEEK_SET);
if (status >= 0 || errno == ESPIPE) {
while (length > 0) {
@ -609,7 +598,7 @@ static void uss_readdir(SftpServer *srv, SftpReplyBuilder *reply,
#if defined HAVE_FSTATAT && defined HAVE_DIRFD
struct stat st;
if (!fstatat(dirfd(udh->dp), de->d_name, &st, AT_SYMLINK_NOFOLLOW)) {
char perms[11], sizebuf[32], *uidbuf = NULL, *gidbuf = NULL;
char perms[11], *uidbuf = NULL, *gidbuf = NULL;
struct passwd *pwd;
struct group *grp;
const char *user, *group;
@ -660,13 +649,11 @@ static void uss_readdir(SftpServer *srv, SftpReplyBuilder *reply,
else
group = gidbuf = dupprintf("%u", (unsigned)st.st_gid);
uint64_decimal(uint64_from_off_t(st.st_size), sizebuf);
tm = *localtime(&st.st_mtime);
longnamebuf = dupprintf(
"%s %3u %-8s %-8s %8s %.3s %2d %02d:%02d %s",
perms, (unsigned)st.st_nlink, user, group, sizebuf,
"%s %3u %-8s %-8s %8"PRIu64" %.3s %2d %02d:%02d %s",
perms, (unsigned)st.st_nlink, user, group, st.st_size,
(&"JanFebMarAprMayJunJulAugSepOctNovDec"[3*tm.tm_mon]),
tm.tm_mday, tm.tm_hour, tm.tm_min, de->d_name);
longname = ptrlen_from_asciz(longnamebuf);

28
windows/winsftp.c
View File

@ -10,7 +10,6 @@
#include "putty.h"
#include "psftp.h"
#include "ssh.h"
#include "int64.h"
#include "winsecur.h"
int filexfer_get_userpass_input(Seat *seat, prompts_t *p, bufchain *input)
@ -71,6 +70,11 @@ char *psftp_getcwd(void)
return ret;
}
static inline uint64_t uint64_from_words(uint32_t hi, uint32_t lo)
{
return (((uint64_t)hi) << 32) | lo;
}
#define TIME_POSIX_TO_WIN(t, ft) do { \
ULARGE_INTEGER uli; \
uli.QuadPart = ((ULONGLONG)(t) + 11644473600ull) * 10000000ull; \
@ -89,7 +93,7 @@ struct RFile {
HANDLE h;
};
RFile *open_existing_file(const char *name, uint64 *size,
RFile *open_existing_file(const char *name, uint64_t *size,
unsigned long *mtime, unsigned long *atime,
long *perms)
{
@ -107,8 +111,7 @@ RFile *open_existing_file(const char *name, uint64 *size,
if (size) {
DWORD lo, hi;
lo = GetFileSize(h, &hi);
size->lo = lo;
size->hi = hi;
*size = uint64_from_words(hi, lo);
}
if (mtime || atime) {
@ -163,7 +166,7 @@ WFile *open_new_file(const char *name, long perms)
return ret;
}
WFile *open_existing_wfile(const char *name, uint64 *size)
WFile *open_existing_wfile(const char *name, uint64_t *size)
{
HANDLE h;
WFile *ret;
@ -179,8 +182,7 @@ WFile *open_existing_wfile(const char *name, uint64 *size)
if (size) {
DWORD lo, hi;
lo = GetFileSize(h, &hi);
size->lo = lo;
size->hi = hi;
*size = uint64_from_words(hi, lo);
}
return ret;
@ -213,7 +215,7 @@ void close_wfile(WFile *f)
/* Seek offset bytes through file, from whence, where whence is
FROM_START, FROM_CURRENT, or FROM_END */
int seek_file(WFile *f, uint64 offset, int whence)
int seek_file(WFile *f, uint64_t offset, int whence)
{
DWORD movemethod;
@ -232,7 +234,7 @@ int seek_file(WFile *f, uint64 offset, int whence)
}
{
LONG lo = offset.lo, hi = offset.hi;
LONG lo = offset & 0xFFFFFFFFU, hi = offset >> 32;
SetFilePointer(f->h, lo, &hi, movemethod);
}
@ -242,16 +244,12 @@ int seek_file(WFile *f, uint64 offset, int whence)
return 0;
}
uint64 get_file_posn(WFile *f)
uint64_t get_file_posn(WFile *f)
{
uint64 ret;
LONG lo, hi = 0;
lo = SetFilePointer(f->h, 0L, &hi, FILE_CURRENT);
ret.lo = lo;
ret.hi = hi;
return ret;
return uint64_from_words(hi, lo);
}
int file_type(const char *name)