/* increment counter (128-bit int) by 1 */
static void AES_ctr128_inc(unsigned char *counter) {
unsigned long c;
/* Grab bottom dword of counter and increment */
c = GETU32(counter + 12);
c++; c &= 0xFFFFFFFF;
PUTU32(counter + 12, c);
/* if no overflow, we're done */
if (c)
return;
/* Grab 1st dword of counter and increment */
c = GETU32(counter + 8);
c++; c &= 0xFFFFFFFF;
PUTU32(counter + 8, c);
/* if no overflow, we're done */
if (c)
return;
/* Grab 2nd dword of counter and increment */
c = GETU32(counter + 4);
c++; c &= 0xFFFFFFFF;
PUTU32(counter + 4, c);
/* if no overflow, we're done */
if (c)
return;
/* Grab top dword of counter and increment */
c = GETU32(counter + 0);
c++; c &= 0xFFFFFFFF;
PUTU32(counter + 0, c);
}
static void
garmin_pack_d1005 ( D1005 * limits, uint8 ** pos )
{
PUTU32(limits->max_workouts);
PUTU32(limits->max_unscheduled_workouts);
PUTU32(limits->max_occurrences);
}
static void
garmin_pack_d1015 ( D1015 * lap, uint8 ** pos )
{
PUTU16(lap->index);
SKIP(2);
PUTU32(lap->start_time);
PUTU32(lap->total_time);
PUTF32(lap->total_dist);
PUTF32(lap->max_speed);
PUTPOS(lap->begin);
PUTPOS(lap->end);
PUTU16(lap->calories);
PUTU8(lap->avg_heart_rate);
PUTU8(lap->max_heart_rate);
PUTU8(lap->intensity);
PUTU8(lap->avg_cadence);
PUTU8(lap->trigger_method);
/* Hopefully we'll know what this stuff actually is someday. */
PUTU8(lap->unknown[0]);
PUTU8(lap->unknown[1]);
PUTU8(lap->unknown[2]);
PUTU8(lap->unknown[3]);
PUTU8(lap->unknown[4]);
}
static void
garmin_pack_d110 ( D110 * wpt, uint8 ** pos )
{
PUTU8(wpt->dtyp);
PUTU8(wpt->wpt_class);
PUTU8(wpt->dspl_color);
PUTU8(wpt->attr);
PUTU16(wpt->smbl);
PUTSTR(wpt->subclass);
PUTPOS(wpt->posn);
PUTF32(wpt->alt);
PUTF32(wpt->dpth);
PUTF32(wpt->dist);
PUTSTR(wpt->state);
PUTSTR(wpt->cc);
PUTU32(wpt->ete);
PUTF32(wpt->temp);
PUTU32(wpt->time);
PUTU16(wpt->wpt_cat);
PUTVST(wpt->ident);
PUTVST(wpt->comment);
PUTVST(wpt->facility);
PUTVST(wpt->city);
PUTVST(wpt->addr);
PUTVST(wpt->cross_road);
}
/* increment counter (128-bit int) by 2^64 */
void AES_ctr128_inc(unsigned char *counter) {
unsigned long c;
/* Grab 3rd dword of counter and increment */
#ifdef L_ENDIAN
c = GETU32(counter + 8);
c++;
PUTU32(counter + 8, c);
#else
c = GETU32(counter + 4);
c++;
PUTU32(counter + 4, c);
#endif
/* if no overflow, we're done */
if (c)
return;
/* Grab top dword of counter and increment */
#ifdef L_ENDIAN
c = GETU32(counter + 12);
c++;
PUTU32(counter + 12, c);
#else
c = GETU32(counter + 0);
c++;
PUTU32(counter + 0, c);
#endif
}
void
Camellia_DecryptBlock(const int keyBitLength,
const unsigned char *ciphertext,
const uint32_t *subkey,
unsigned char *plaintext)
{
uint32_t tmp[4];
tmp[0] = GETU32(ciphertext);
tmp[1] = GETU32(ciphertext + 4);
tmp[2] = GETU32(ciphertext + 8);
tmp[3] = GETU32(ciphertext + 12);
switch (keyBitLength) {
case 128:
camellia_decrypt128(subkey, tmp);
break;
case 192:
/* fall through */
case 256:
camellia_decrypt256(subkey, tmp);
break;
default:
break;
}
PUTU32(plaintext, tmp[0]);
PUTU32(plaintext+4, tmp[1]);
PUTU32(plaintext+8, tmp[2]);
PUTU32(plaintext+12, tmp[3]);
}
static void
garmin_pack_d1013 ( D1013 * limits, uint8 ** pos )
{
PUTU32(limits->max_courses);
PUTU32(limits->max_course_laps);
PUTU32(limits->max_course_pnt);
PUTU32(limits->max_course_trk_pnt);
}
void ctr_init_iv(uint8 *iv, int64 counter)
{
int64 val = counter;
unsigned int ll = (unsigned int)counter;
unsigned int hh = (unsigned int)(counter >> 32);
memset(iv, 0, 16);
PUTU32(iv+8, hh);
PUTU32(iv+12, ll);
}
static void
garmin_pack_d906 ( D906 * lap, uint8 ** pos )
{
PUTU32(lap->start_time);
PUTU32(lap->total_time);
PUTF32(lap->total_distance);
PUTPOS(lap->begin);
PUTPOS(lap->end);
PUTU16(lap->calories);
PUTU8(lap->track_index);
}
static void
garmin_pack_dlist ( garmin_list * list, uint8 ** pos )
{
garmin_list_node * node;
PUTU32(list->id);
PUTU32(list->elements);
for ( node = list->head; node != NULL; node = node->next ) {
PUTU32(list->id);
garmin_pack(node->data,pos);
}
}
static void
garmin_pack_d1000 ( D1000 * run, uint8 ** pos )
{
PUTU32(run->track_index);
PUTU32(run->first_lap_index);
PUTU32(run->last_lap_index);
PUTU8(run->sport_type);
PUTU8(run->program_type);
SKIP(2);
PUTU32(run->virtual_partner.time);
PUTF32(run->virtual_partner.distance);
garmin_pack_d1002(&run->workout,pos);
}
void rijndaelDecrypt_Final(const u32 rk[/*44*/], u8 pt[16], int rank)
{
//printf("In AES final thread\n");
float tempArray[4];
int i = 0;
u32 s[4], t0 = 0, t1 = 0, t2 = 0, t3 = 0;
int Nr = 10;
int * s_sign = (int*)s;
MPI_Recv(s_sign, 4, MPI_INT, rank - 1, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
ROUND(9, &t0, &t1, &t2, &t3, s[0], s[1], s[2], s[3], rk);
/*
* apply last round and
* map cipher state to byte array block:
*/
rk += Nr << 2;
s[0] = TD41(t0) ^ TD42(t3) ^ TD43(t2) ^ TD44(t1) ^ rk[0];
PUTU32(pt , s[0]);
s[1] = TD41(t1) ^ TD42(t0) ^ TD43(t3) ^ TD44(t2) ^ rk[1];
PUTU32(pt + 4, s[1]);
s[2] = TD41(t2) ^ TD42(t1) ^ TD43(t0) ^ TD44(t3) ^ rk[2];
PUTU32(pt + 8, s[2]);
s[3] = TD41(t3) ^ TD42(t2) ^ TD43(t1) ^ TD44(t0) ^ rk[3];
PUTU32(pt + 12, s[3]);
for(i=0; i <4; i++)
{
union {
float f;
unsigned char b[4];
} u;
u.b[3] = pt[4*i+0];
u.b[2] = pt[4*i+1];
u.b[1] = pt[4*i+2];
u.b[0] = pt[4*i+3];
tempArray[i] = u.f;
//printf("%f ",tempArray[i]);
}
//printf("\n");
//for(i = 1; i <= 4; i++)
//printf("Sent the values to %d\n", rank + 1);
MPI_Send(tempArray, 4, MPI_FLOAT, rank + 1, 0, MPI_COMM_WORLD);
}
static void
garmin_pack_d1001 ( D1001 * lap, uint8 ** pos )
{
PUTU32(lap->index);
PUTU32(lap->start_time);
PUTU32(lap->total_time);
PUTF32(lap->total_dist);
PUTF32(lap->max_speed);
PUTPOS(lap->begin);
PUTPOS(lap->end);
PUTU16(lap->calories);
PUTU8(lap->avg_heart_rate);
PUTU8(lap->max_heart_rate);
PUTU8(lap->intensity);
}
void sms4_encrypt(const unsigned char *in, unsigned char *out, const sms4_key_t *key)
{
const uint32_t *rk = key->rk;
uint32_t X0, X1, X2, X3, X4;
X0 = GETU32(in );
X1 = GETU32(in + 4);
X2 = GETU32(in + 8);
X3 = GETU32(in + 12);
ROUND(X0, X1, X2, X3, X4, rk[0]);
ROUND(X1, X2, X3, X4, X0, rk[1]);
ROUND(X2, X3, X4, X0, X1, rk[2]);
ROUND(X3, X4, X0, X1, X2, rk[3]);
ROUND(X4, X0, X1, X2, X3, rk[4]);
ROUND(X0, X1, X2, X3, X4, rk[5]);
ROUND(X1, X2, X3, X4, X0, rk[6]);
ROUND(X2, X3, X4, X0, X1, rk[7]);
ROUND(X3, X4, X0, X1, X2, rk[8]);
ROUND(X4, X0, X1, X2, X3, rk[9]);
ROUND(X0, X1, X2, X3, X4, rk[10]);
ROUND(X1, X2, X3, X4, X0, rk[11]);
ROUND(X2, X3, X4, X0, X1, rk[12]);
ROUND(X3, X4, X0, X1, X2, rk[13]);
ROUND(X4, X0, X1, X2, X3, rk[14]);
ROUND(X0, X1, X2, X3, X4, rk[15]);
ROUND(X1, X2, X3, X4, X0, rk[16]);
ROUND(X2, X3, X4, X0, X1, rk[17]);
ROUND(X3, X4, X0, X1, X2, rk[18]);
ROUND(X4, X0, X1, X2, X3, rk[19]);
ROUND(X0, X1, X2, X3, X4, rk[20]);
ROUND(X1, X2, X3, X4, X0, rk[21]);
ROUND(X2, X3, X4, X0, X1, rk[22]);
ROUND(X3, X4, X0, X1, X2, rk[23]);
ROUND(X4, X0, X1, X2, X3, rk[24]);
ROUND(X0, X1, X2, X3, X4, rk[25]);
ROUND(X1, X2, X3, X4, X0, rk[26]);
ROUND(X2, X3, X4, X0, X1, rk[27]);
ROUND(X3, X4, X0, X1, X2, rk[28]);
ROUND(X4, X0, X1, X2, X3, rk[29]);
ROUND(X0, X1, X2, X3, X4, rk[30]);
ROUND(X1, X2, X3, X4, X0, rk[31]);
PUTU32(X0, out);
PUTU32(X4, out + 4);
PUTU32(X3, out + 8);
PUTU32(X2, out + 12);
}
int aes_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
const unsigned char *in, size_t len)
{
int block;
int i, j;
unsigned int mode, key_len;
mode = EVP_CIPHER_CTX_mode(ctx) - 1;
key_len = (ctx->key_len)/8 - 2;
block = len / 16;
for (i = 0; i < block; i++) {
for (j = 0; j < 4; j++) {
REG_TEXT(j) = GETU32(in + i*16 + j*4);
}
REG_AES = ED(0, key_len, ctx->encrypt, mode, 0, 0);
int a[5];
a[4] = REG_RESULT(0);
for (j = 0; j < 4; j++) {
a[j] = REG_RESULT(j);
}
for (j = 0; j < 4; j++) {
PUTU32(a[j], out + i*16 + j*4);
}
}
return 1;
}
static void
garmin_pack_d300 ( D300 * point, uint8 ** pos )
{
PUTPOS(point->posn);
PUTU32(point->time);
PUTU8(point->new_trk);
}
static void
garmin_pack_d303 ( D303 * point, uint8 ** pos )
{
PUTPOS(point->posn);
PUTU32(point->time);
PUTF32(point->alt);
PUTU8(point->heart_rate);
}
static void
garmin_pack_d450 ( D450 * prx, uint8 ** pos )
{
PUTU32(prx->idx);
garmin_pack_d150(&prx->wpt,pos);
SKIP(sizeof(D150));
PUTF32(prx->dst);
}
void Camellia_DecryptBlock_Rounds(int grandRounds, const u8 ciphertext[],
const KEY_TABLE_TYPE keyTable,
u8 plaintext[])
{
u32 s0, s1, s2, s3;
const u32 *k = keyTable + grandRounds * 16, *kend = keyTable + 4;
s0 = GETU32(ciphertext) ^ k[0];
s1 = GETU32(ciphertext + 4) ^ k[1];
s2 = GETU32(ciphertext + 8) ^ k[2];
s3 = GETU32(ciphertext + 12) ^ k[3];
while (1) {
/* Camellia makes 6 Feistel rounds */
k -= 12;
Camellia_Feistel(s0, s1, s2, s3, k + 10);
Camellia_Feistel(s2, s3, s0, s1, k + 8);
Camellia_Feistel(s0, s1, s2, s3, k + 6);
Camellia_Feistel(s2, s3, s0, s1, k + 4);
Camellia_Feistel(s0, s1, s2, s3, k + 2);
Camellia_Feistel(s2, s3, s0, s1, k + 0);
if (k == kend)
break;
/*
* This is the same function as the diffusion function D of the
* accompanying documentation. See section 3.2 for properties of the
* FLlayer function.
*/
k -= 4;
s1 ^= LeftRotate(s0 & k[2], 1);
s2 ^= s3 | k[1];
s0 ^= s1 | k[3];
s3 ^= LeftRotate(s2 & k[0], 1);
}
k -= 4;
s2 ^= k[0], s3 ^= k[1], s0 ^= k[2], s1 ^= k[3];
PUTU32(plaintext, s2);
PUTU32(plaintext + 4, s3);
PUTU32(plaintext + 8, s0);
PUTU32(plaintext + 12, s1);
}
static void
garmin_pack_d301 ( D301 * point, uint8 ** pos )
{
PUTPOS(point->posn);
PUTU32(point->time);
PUTF32(point->alt);
PUTF32(point->dpth);
PUTU8(point->new_trk);
}
static void
garmin_pack_d650 ( D650 * fbr, uint8 ** pos )
{
PUTU32(fbr->takeoff_time);
PUTU32(fbr->landing_time);
PUTPOS(fbr->takeoff_posn);
PUTPOS(fbr->landing_posn);
PUTU32(fbr->night_time);
PUTU32(fbr->num_landings);
PUTF32(fbr->max_speed);
PUTF32(fbr->max_alt);
PUTF32(fbr->distance);
PUTU8(fbr->cross_country_flag);
PUTVST(fbr->departure_name);
PUTVST(fbr->departure_ident);
PUTVST(fbr->arrival_name);
PUTVST(fbr->arrival_ident);
PUTVST(fbr->ac_id);
}
static void
garmin_pack_d1012 ( D1012 * point, uint8 ** pos )
{
PUTSTR(point->name);
SKIP(1);
PUTU16(point->course_index);
SKIP(2);
PUTU32(point->track_point_time);
PUTU8(point->point_type);
}
static void
garmin_pack_d304 ( D304 * point, uint8 ** pos )
{
PUTPOS(point->posn);
PUTU32(point->time);
PUTF32(point->alt);
PUTF32(point->distance);
PUTU8(point->heart_rate);
PUTU8(point->cadence);
PUTU8(point->sensor);
}
/* increment counter (128-bit int) by 1 */
static void ctr128_inc(unsigned char *counter) {
u32 c,n=16;
do {
n -= 4;
c = GETU32(counter+n);
++c; c &= 0xFFFFFFFF;
PUTU32(counter + n, c);
if (c) return;
} while (n);
}
void rijndaelDecrypt_Final(const u32 rk[/*44*/], u8 pt[16], int rank)
{
u32 s[4], t0 = 0, t1 = 0, t2 = 0, t3 = 0;
int Nr = 10;
int * s_sign = (int*)s;
MPI_Recv(s_sign, 4, MPI_INT, rank - 1, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
//printf("read:rank %d val: %#x,%#x,%#x,%#x\n",rank,s_sign[0],s_sign[1],s_sign[2],s_sign[3]);
ROUND(9, &t0, &t1, &t2, &t3, s[0], s[1], s[2], s[3], rk);
/*
* apply last round and
* map cipher state to byte array block:
*/
rk += Nr << 2;
s[0] = TD41(t0) ^ TD42(t3) ^ TD43(t2) ^ TD44(t1) ^ rk[0];
PUTU32(pt , s[0]);
s[1] = TD41(t1) ^ TD42(t0) ^ TD43(t3) ^ TD44(t2) ^ rk[1];
PUTU32(pt + 4, s[1]);
s[2] = TD41(t2) ^ TD42(t1) ^ TD43(t0) ^ TD44(t3) ^ rk[2];
PUTU32(pt + 8, s[2]);
s[3] = TD41(t3) ^ TD42(t2) ^ TD43(t1) ^ TD44(t0) ^ rk[3];
PUTU32(pt + 12, s[3]);
/*
s[0] = TE41(t0) ^ TE42(t1) ^ TE43(t2) ^ TE44(t3) ^ rk[8];
PUTU32(ct , s[0]);
s[1] = TE41(t1) ^ TE42(t2) ^ TE43(t3) ^ TE44(t0) ^ rk[9];
PUTU32(ct + 4, s[1]);
s[2] = TE41(t2) ^ TE42(t3) ^ TE43(t0) ^ TE44(t1) ^ rk[10];
PUTU32(ct + 8, s[2]);
s[3] = TE41(t3) ^ TE42(t0) ^ TE43(t1) ^ TE44(t2) ^ rk[11];
PUTU32(ct + 12, s[3]);
*/
}
static void
garmin_pack_d1007 ( D1007 * lap, uint8 ** pos )
{
PUTU16(lap->course_index);
PUTU16(lap->lap_index);
PUTU32(lap->total_time);
PUTF32(lap->total_dist);
PUTPOS(lap->begin);
PUTPOS(lap->end);
PUTU8(lap->avg_heart_rate);
PUTU8(lap->max_heart_rate);
PUTU8(lap->intensity);
PUTU8(lap->avg_cadence);
}
static void
garmin_pack_d1009 ( D1009 * run, uint8 ** pos )
{
PUTU16(run->track_index);
PUTU16(run->first_lap_index);
PUTU16(run->last_lap_index);
PUTU8(run->sport_type);
PUTU8(run->program_type);
PUTU8(run->multisport);
SKIP(3);
PUTU32(run->quick_workout.time);
PUTF32(run->quick_workout.distance);
garmin_pack_d1008(&run->workout,pos);
}
static void
garmin_pack_d800 ( D800 * pvt, uint8 ** pos )
{
PUTF32(pvt->alt);
PUTF32(pvt->epe);
PUTF32(pvt->eph);
PUTF32(pvt->epv);
PUTU16(pvt->fix);
PUTF64(pvt->tow);
PUTRPT(pvt->posn);
PUTF32(pvt->east);
PUTF32(pvt->north);
PUTF32(pvt->up);
PUTF32(pvt->msl_hght);
PUTS16(pvt->leap_scnds);
PUTU32(pvt->wn_days);
}
static void
garmin_pack_d1002 ( D1002 * wkt, uint8 ** pos )
{
int i;
PUTU32(wkt->num_valid_steps);
for ( i = 0; i < 20; i++ ) {
PUTSTR(wkt->steps[i].custom_name);
PUTF32(wkt->steps[i].target_custom_zone_low);
PUTF32(wkt->steps[i].target_custom_zone_high);
PUTU16(wkt->steps[i].duration_value);
PUTU8(wkt->steps[i].intensity);
PUTU8(wkt->steps[i].duration_type);
PUTU8(wkt->steps[i].target_type);
PUTU8(wkt->steps[i].target_value);
SKIP(2);
}
PUTSTR(wkt->name);
PUTU8(wkt->sport_type);
}
void CRYPTO_ctr128_encrypt_ctr32(const unsigned char *in, unsigned char *out,
size_t len, const void *key,
unsigned char ivec[16],
unsigned char ecount_buf[16],
unsigned int *num, ctr128_f func)
{
unsigned int n, ctr32;
assert(in && out && key && ecount_buf && num);
assert(*num < 16);
n = *num;
while (n && len) {
*(out++) = *(in++) ^ ecount_buf[n];
--len;
n = (n + 1) % 16;
}
ctr32 = GETU32(ivec + 12);
while (len >= 16) {
size_t blocks = len / 16;
/*
* 1<<28 is just a not-so-small yet not-so-large number...
* Below condition is practically never met, but it has to
* be checked for code correctness.
*/
if (sizeof(size_t) > sizeof(unsigned int) && blocks > (1U << 28))
blocks = (1U << 28);
/*
* As (*func) operates on 32-bit counter, caller
* has to handle overflow. 'if' below detects the
* overflow, which is then handled by limiting the
* amount of blocks to the exact overflow point...
*/
ctr32 += (u32)blocks;
if (ctr32 < blocks) {
blocks -= ctr32;
ctr32 = 0;
}
(*func) (in, out, blocks, key, ivec);
/* (*ctr) does not update ivec, caller does: */
PUTU32(ivec + 12, ctr32);
/* ... overflow was detected, propogate carry. */
if (ctr32 == 0)
ctr96_inc(ivec);
blocks *= 16;
len -= blocks;
out += blocks;
in += blocks;
}
if (len) {
memset(ecount_buf, 0, 16);
(*func) (ecount_buf, ecount_buf, 1, key, ivec);
++ctr32;
PUTU32(ivec + 12, ctr32);
if (ctr32 == 0)
ctr96_inc(ivec);
while (len--) {
out[n] = in[n] ^ ecount_buf[n];
++n;
}
}
*num = n;
}
