QuasarApp/openssl
4
0
Fork 0
mirror of https://github.com/QuasarApp/openssl.git synced 2025-05-04 13:39:38 +00:00
Code Issues Projects Releases Wiki Activity

Fix satsub64be() to unconditionally use 64-bit integers

Browse Source 
Now we support (u)int64_t this can be very much simpler.

Reviewed-by: Andy Polyakov <appro@openssl.org>
Reviewed-by: Matt Caswell <matt@openssl.org>
This commit is contained in:
David Woodhouse 2016-08-05 10:58:52 +01:00 committed by Matt Caswell
parent e0421bd8b2
commit 31c34a3e2f
2 changed files with 21 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
ssl/record/dtls1_bitmap.c
View File

@ -13,83 +13,26 @@
/* mod 128 saturating subtract of two 64-bit values in big-endian order */ /* mod 128 saturating subtract of two 64-bit values in big-endian order */
static int satsub64be(const unsigned char *v1, const unsigned char *v2) static int satsub64be(const unsigned char *v1, const unsigned char *v2)
{ {
int ret, i; int64_t ret;
uint64_t l1, l2;
if (sizeof(long) == 8) n2l8(v1, l1);
do { n2l8(v2, l2);
const union {
long one;
char little;
} is_endian = {
1
};
long l;
if (is_endian.little) ret = l1 - l2;
break;
/* not reached on little-endians */
/*
* following test is redundant, because input is always aligned,
* but I take no chances...
*/
if (((size_t)v1 | (size_t)v2) & 0x7)
break;
l = *((long *)v1); /* We do not permit wrap-around */
l -= *((long *)v2); if (l1 > l2 && ret < 0)
if (l > 128) return 128;
return 128; else if (l2 > l1 && ret > 0)
else if (l < -128) return -128;
return -128;
else
return (int)l;
} while (0);
ret = 0;
for (i=0; i<7; i++) {
if (v1[i] > v2[i]) {
/* v1 is larger... but by how much? */
if (v1[i] != v2[i] + 1)
return 128;
while (++i <= 6) {
if (v1[i] != 0x00 || v2[i] != 0xff)
return 128; /* too much */
}
/* We checked all the way to the penultimate byte,
* so despite higher bytes changing we actually
* know that it only changed from (e.g.)
* ... (xx) ff ff ff ??
* to ... (xx+1) 00 00 00 ??
* so we add a 'bias' of 256 for the carry that
* happened, and will eventually return
* 256 + v1[7] - v2[7]. */
ret = 256;
break;
} else if (v2[i] > v1[i]) {
/* v2 is larger... but by how much? */
if (v2[i] != v1[i] + 1)
return -128;
while (++i <= 6) {
if (v2[i] != 0x00 || v1[i] != 0xff)
return -128; /* too much */
}
/* Similar to the case above, we know it changed
* from ... (xx) 00 00 00 ??
* to ... (xx-1) ff ff ff ??
* so we add a 'bias' of -256 for the borrow,
* to return -256 + v1[7] - v2[7]. */
ret = -256;
}
}
ret += (int)v1[7] - (int)v2[7];
if (ret > 128) if (ret > 128)
return 128; return 128;
else if (ret < -128) else if (ret < -128)
return -128; return -128;
else else
return ret; return (int)ret;
} }
int dtls1_record_replay_check(SSL *s, DTLS1_BITMAP *bitmap) int dtls1_record_replay_check(SSL *s, DTLS1_BITMAP *bitmap)

10
ssl/ssl_locl.h
View File

@ -105,6 +105,16 @@
l|=((unsigned long)(*((c)++)))<< 8, \ l|=((unsigned long)(*((c)++)))<< 8, \
l|=((unsigned long)(*((c)++)))) l|=((unsigned long)(*((c)++))))
# define n2l8(c,l) (l =((uint64_t)(*((c)++)))<<56, \
l|=((uint64_t)(*((c)++)))<<48, \
l|=((uint64_t)(*((c)++)))<<40, \
l|=((uint64_t)(*((c)++)))<<32, \
l|=((uint64_t)(*((c)++)))<<24, \
l|=((uint64_t)(*((c)++)))<<16, \
l|=((uint64_t)(*((c)++)))<< 8, \
l|=((uint64_t)(*((c)++))))
# define l2n(l,c) (*((c)++)=(unsigned char)(((l)>>24)&0xff), \ # define l2n(l,c) (*((c)++)=(unsigned char)(((l)>>24)&0xff), \
*((c)++)=(unsigned char)(((l)>>16)&0xff), \ *((c)++)=(unsigned char)(((l)>>16)&0xff), \
*((c)++)=(unsigned char)(((l)>> 8)&0xff), \ *((c)++)=(unsigned char)(((l)>> 8)&0xff), \