static BOOL bign_keyunwrap(byte *X, byte *d, byte *untoken){ Point q; REV_PI(X, q); BigInteger Q = bign_curve256v1::getQ(); byte s0[32]; memcpy(s0, d, sizeof s0); for (size_t jj = 0; jj < 32; jj += 4) change_endian(s0 + jj); BigInteger S0(s0, 32); S0 <<= 128; S0 %= Q; byte h_belt[32]; memcpy(h_belt, H, 32); for (size_t jj = 0; jj <32; jj += 4) change_endian(h_belt + jj); BigInteger temp2(h_belt, 32); temp2 %= Q; byte _qq[32]; memcpy(_qq, d + 32, sizeof _qq); for (size_t jj = 0; jj < 32; jj += 4) change_endian(_qq + jj); BigInteger S1(_qq, 32); if (S1 >= Q) return false; BigInteger rr = (temp2 + S1) % Q; BigInteger zero = BigInteger(0); Point G(zero, bign_curve256v1::getY()); Point R = shamir(G, rr, q, S0); if (R.x == zero && R.y == zero) return false; byte toHash[108]; byte bR[64]; PI(bR, R); belt_hash(toHash, sizeof toHash, h_belt); for (size_t jj = 0; jj < 32; ++jj) if (h_belt[jj] != bR[jj]) return false; return true; }
static BOOL bign_verify(byte *H, byte *_q, byte *S, uint32 size){ Point q; REV_PI(_q, q); BigInteger Q = bign_curve256v1::getQ(); byte s0[32]; memcpy(s0, S, sizeof s0); for (size_t jj = 0; jj < 32; jj += 4) change_endian(s0 + jj); BigInteger S0(s0, 32); S0 <<= 128; S0 %= Q; byte _qq[32]; memcpy(_qq, S + 32, sizeof _qq); for (size_t jj = 0; jj < 32; jj += 4) change_endian(_qq + jj); BigInteger S1(_qq, 32); if (S1 >= Q) return false; byte h_belt[32]; memcpy(h_belt, H, 32); for (size_t jj = 0; jj <32; jj += 4) change_endian(h_belt + jj); BigInteger temp2(h_belt, 32); temp2 %= Q; BigInteger rr = (temp2 + S1) % Q; BigInteger zero = BigInteger(0); Point G(zero, bign_curve256v1::getY()); Point R = shamir(G, rr, q, S0); if (R.x == zero && R.y == zero) return false; byte toHash[108]; byte bR[64]; PI(bR, R); memcpy(toHash, OID, sizeof OID); memcpy(toHash + sizeof OID, bR, sizeof bR); memcpy(toHash + sizeof OID + sizeof bR, H, 32); belt_hash(toHash, sizeof toHash, h_belt); for (size_t jj = 0; jj < 32; ++jj) if (h_belt[jj] != S[jj]) return false; return true; }
void camellia128_enc(void* block, const camellia128_ctx_t* s){ #define BL (((uint64_t*)block)[0]) #define BR (((uint64_t*)block)[1]) /* endian adjustment */ /*BL*/ /* 1 2 3 4 5 6 7 8 * 8 7 6 5 4 3 2 1 */ uint64_t temp64; change_endian(&BL, 64/8); change_endian(&BR, 64/8); /* Prewhitening */ BL ^= s->kll; BR ^= s->klr; /* the first 6 */ camellia_6rounds(s, &BL, &BR, KEY_ROL15 | KEY_DIR_NORM | KEY_POSTC1 , 0x33); /* FL injection */ camellia128_keyop((camellia128_ctx_t*)s, -1); BL = camellia_fl(BL, s->kal); BR = camellia_fl_inv(BR, s->kar); camellia128_keyop((camellia128_ctx_t*)s, -1); /* middle 6 */ camellia_6rounds(s, &BL, &BR, KEY_ROL15 | KEY_DIR_NORM | KEY_INC2 , 0x34); /* FL injection */ camellia128_keyop((camellia128_ctx_t*)s, 1); BL = camellia_fl(BL, s->kll); BR = camellia_fl_inv(BR, s->klr); camellia128_keyop((camellia128_ctx_t*)s, 1); /* last 6 */ camellia_6rounds(s, &BL, &BR, KEY_ROL17 | KEY_DIR_NORM | KEY_POSTC2 , 0x0C); /* Postwhitening */ BR ^= s->kal; BL ^= s->kar; temp64 = BR; BR = BL; BL = temp64; camellia128_keyop((camellia128_ctx_t*)s,1); change_endian(&BL, 64/8); change_endian(&BR, 64/8); #undef BL #undef BR }
static void PI(byte *A, Point & b) { uint32 ARRAY_OFFSET = 0x00; byte PI_HELPER[1 << 2] = {0x00}; for (size_t jj = 0; jj < 8; ++jj) { memcpy(PI_HELPER, b.x.data + jj, 4); change_endian(PI_HELPER); for (size_t ll = 0; ll < 4; ++ll) A[ARRAY_OFFSET + (jj << 2) + ll] = PI_HELPER[ll]; } ARRAY_OFFSET += 1 << 4; for (size_t jj = 0; jj < 8; ++jj) { memcpy(PI_HELPER, b.y.data + jj, 4); change_endian(PI_HELPER); for (size_t ll = 0; ll < 4; ++ll) A[ARRAY_OFFSET + (jj << 2) + ll] = PI_HELPER[ll]; } }
static void REV_PI(byte *A, Point & b) { uint32 ARRAY_OFFSET = 0x00; byte PI_HELPER[1 << 2] = {0x00}; for (size_t jj = 0; jj < 8; ++jj) { memcpy(PI_HELPER, A + ARRAY_OFFSET + (jj << 2), 4); change_endian(PI_HELPER); memcpy(b.x.data + jj, PI_HELPER, 4); } ARRAY_OFFSET += 1 << 4; for (size_t jj = 0; jj < 8; ++jj) { memcpy(PI_HELPER, A + ARRAY_OFFSET + (jj << 2), 4); change_endian(PI_HELPER); memcpy(b.y.data + jj, PI_HELPER, 4); } b.y.length = b.x.length = 8; }
idx3_ubyte_reader::idx3_ubyte_reader(const char* filename) : matrix_reader<float>(filename, true),w(0),h(0) { if (this->in.fail()) throw std::runtime_error("Input stream error 0"); uint32_t x = 0; this->in.read((char*)&x,sizeof(x)); if (this->in.fail()) throw std::runtime_error("Input stream error 1"); this->in.read((char*)&x,sizeof(x)); h = change_endian(x); this->in.read((char*)&x,sizeof(x)); w = change_endian(x); this->in.read((char*)&x,sizeof(x)); w *= change_endian(x); std::cout << "D=" << w << "\n"; }
static void bign_dh(byte *k, uint32 kSize, byte *P, byte* to){ byte *_k = new byte[((kSize - 1 / 4) + 1) * 4]; memset(_k, 0x00, sizeof _k); memcpy(_k, k, kSize); for (size_t jj = 0; jj < sizeof _k; jj += 4) change_endian(_k + jj); BigInteger K(_k, sizeof _k); K %= bign_curve256v1::getQ(); Point PP; REV_PI(P, PP); Point ret = doit(PP, K); PI(to, ret); }
static void bign_sign(byte *H, byte *d, byte* to) { byte rand[32]; gen_rnd_data(rand, 32); BigInteger k(rand, 32); BigInteger P = bign_curve256v1::getP(); k %= P; byte dd[32]; memcpy(dd, d, 32); for (size_t jj = 0; jj < 32; jj += 4) change_endian(dd + jj); BigInteger D(dd, 32); BigInteger Q = bign_curve256v1::getQ(); Point G(BigInteger(0), bign_curve256v1::getY()); Point R = doit(G, k); byte toHash[108]; byte bR[64]; PI(bR, R); memcpy(toHash, OID, sizeof OID); memcpy(toHash + sizeof OID, bR, sizeof bR); memcpy(toHash + sizeof OID + sizeof bR, H, 32); byte h_belt[32]; belt_hash(toHash, sizeof toHash, h_belt); memcpy(to, h_belt, sizeof h_belt); for (size_t jj = 0; jj <32; jj += 4) change_endian(h_belt + jj); BigInteger temp1(h_belt, 32); temp1 <<= 128; temp1 %= Q; temp1 *= D %= Q; memcpy(h_belt, H, 32); for (size_t jj = 0; jj <32; jj += 4) change_endian(h_belt + jj); BigInteger temp2(h_belt, 32); temp2 %= Q; BigInteger temp3 = (k + Q - temp1 + Q - temp2) % Q; memcpy(h_belt, temp3.data, 32); for (size_t jj = 0; jj < 32; jj += 4) change_endian(h_belt + jj); memcpy(to + 32, h_belt, 32); }
static void encrypt_block(uint32* X, uint32 *Y, uint32 *sigma) { uint32 a = *X, b=*(X + 1), c= *(X + 2), d = *(X + 3),e; for (uint32 i = 1; i<= 8; ++i) { b ^= G<5>(plus_belt(a, *(sigma + eval(7*i - 6)))); c ^= G<21>(plus_belt(d, *(sigma + eval(7*i-5)))); a = minus_belt(a, G<13>(plus_belt(b, *(sigma + eval(7*i - 4))))); uint32 t_i = i; change_endian((byte*)&t_i); e =G<21>(plus_belt(plus_belt(b,c), *(sigma + eval(7 * i - 3)))) ^ t_i; b=plus_belt(b,e); c=minus_belt(c,e); d = plus_belt(d, G<13>(plus_belt(c, *(sigma + eval(7*i-2))))); b ^= G<21>(plus_belt(a, *(sigma + eval(7 * i - 1)))); c ^= G<5>(plus_belt(d, *(sigma + eval(7*i)))); a ^=b, b^=a, a^=b; c ^=d, d ^=c, c ^=d; b ^=c, c ^= b, b ^= c; } *Y = b; *(Y + 1) = d; *(Y + 2) = a; *(Y + 3) = c; }
// also works but sleeps between transfers static snd_pcm_sframes_t a2dp_transfer2(snd_pcm_ioplug_t *io, const snd_pcm_channel_area_t *areas, snd_pcm_uframes_t offset, snd_pcm_uframes_t size) { snd_pcm_a2dp_t *a2dp = io->private_data; char *buf; int len; struct media_packet_header packet_header; struct media_payload_header payload_header; int codesize,datatoread; unsigned long sleeptime; int written; struct timeval dt; codesize=a2dp->sbc.subbands*a2dp->sbc.blocks*a2dp->sbc.channels*2; datatoread=min(codesize,size*a2dp->frame_bytes); buf = (char *) areas->addr + (areas->first + areas->step * offset) / 8; if(lenbufe<codesize){ memcpy(bufe+lenbufe,buf,datatoread); lenbufe+=datatoread; } else{datatoread=0;} if(lenbufe>=codesize){ //enough data to encode change_endian(bufe,codesize); // changing the endianness len = sbc_encode(&(a2dp->sbc), bufe, codesize); //encode memmove(bufe, bufe + len, lenbufe - len); //shift the bufe lenbufe-=len; nbytes+=len; sleeptime += a2dp->sbc.duration; if (len <= 0) return len; if(a2dp->len + a2dp->sbc.len > 678) { // time to prepare and send the packet dt.tv_sec=0; dt.tv_usec=1000000*a2dp->sbc.subbands*a2dp->sbc.blocks*frame_count/io->rate; memset(&payload_header, 0, sizeof(payload_header)); memset(&packet_header, 0, sizeof(packet_header)); payload_header.frame_count=frame_count; packet_header.v = 2; packet_header.pt = 1; packet_header.sequence_number = htons(seq_num); packet_header.timestamp = htonl(timestamp); packet_header.ssrc = htonl(1); timestamp += (a2dp->sbc.blocks + 1)*4 * (a2dp->sbc.subbands + 1)*4; memcpy(a2dp->buf, &packet_header, sizeof(packet_header)); memcpy(a2dp->buf + sizeof(packet_header), &payload_header, sizeof(payload_header)); sleeptill(&tsend, &dt); if((written = write(a2dp->sk,a2dp->buf,a2dp->len)) != a2dp->len) { DBG("Wrote %d not %d bytes; errno %s(%d)", written, a2dp->len, strerror(errno), errno); } a2dp->len = sizeof(packet_header)+sizeof(payload_header); frame_count=0; sleeptime=0; seq_num++; } frame_count++; memcpy(a2dp->buf + a2dp->len, a2dp->sbc.data, a2dp->sbc.len); a2dp->len+=a2dp->sbc.len; if (a2dp->state == BT_CONNECTED) a2dp->num += len / a2dp->frame_bytes; } return datatoread / a2dp->frame_bytes; }
// transfers around correct time postions static snd_pcm_sframes_t a2dp_transfer(snd_pcm_ioplug_t *io, const snd_pcm_channel_area_t *areas, snd_pcm_uframes_t offset, snd_pcm_uframes_t size) { snd_pcm_a2dp_t *a2dp = io->private_data; char *buf; int len; struct media_packet_header packet_header; struct media_payload_header payload_header; int codesize,datatoread; unsigned long sleeptime; struct timeval dt; codesize=a2dp->sbc.subbands*a2dp->sbc.blocks*a2dp->sbc.channels*2; // size of data encoded by sbc_encode in one call datatoread=min(codesize,size*a2dp->frame_bytes); // amount of data to read buf = (char *) areas->addr + (areas->first + areas->step * offset) / 8; if(lenbufe<codesize && lenbufe+datatoread<sizeof(bufe)){ // if not enough data in bufe to encode and there is space in bufe memcpy(bufe+lenbufe,buf,datatoread);// we read data to bufe lenbufe+=datatoread; } else{datatoread=0;}//nothing has been read if(lenbufe>=codesize && a2dp->len + a2dp->sbc.len < 678){ // if enough data in bufe to encode and not enough frame to fill up mtu: encoding change_endian(bufe,codesize); // changing the endianness len = sbc_encode(&(a2dp->sbc), bufe, codesize); //encode memmove(bufe, bufe + len, lenbufe - len); //shift the bufe lenbufe-=len; nbytes+=len; sleeptime += a2dp->sbc.duration; if (len <= 0) return len; frame_count++; memcpy(a2dp->buf + a2dp->len, a2dp->sbc.data, a2dp->sbc.len); // copy encoded frames into a2dp->buf a2dp->len+=a2dp->sbc.len; if (a2dp->state == BT_CONNECTED) a2dp->num += len / a2dp->frame_bytes; //update pointer a2dp->num %=io->buffer_size; } if(a2dp->len + a2dp->sbc.len > 678){ // if packet is formed dt.tv_usec=1000000*a2dp->sbc.subbands*a2dp->sbc.blocks*frame_count/io->rate; // time interval between transmitions dt.tv_sec=0; if(time_to_wait(&tsend, &dt)==0){ // time to send data memset(&payload_header, 0, sizeof(payload_header)); // fill up the headers memset(&packet_header, 0, sizeof(packet_header)); //--- payload_header.frame_count=frame_count; packet_header.v = 2; packet_header.pt = 1; packet_header.sequence_number = htons(seq_num); packet_header.timestamp = htonl(timestamp); packet_header.ssrc = htonl(1); timestamp += (a2dp->sbc.blocks + 1)*4 * (a2dp->sbc.subbands + 1)*4; memcpy(a2dp->buf, &packet_header, sizeof(packet_header)); //copy the headers to buf memcpy(a2dp->buf + sizeof(packet_header), &payload_header, sizeof(payload_header));//--- write(a2dp->sk,a2dp->buf,a2dp->len); // sending the packet a2dp->len = sizeof(packet_header)+sizeof(payload_header); //inital position in buf, just after headers frame_count=0; sleeptime=0; seq_num++; }else{usleep(1);} } return datatoread / a2dp->frame_bytes; }
operator INT() { return change_endian(value); }
other_endian(const INT i = 0) { value = change_endian(i); }
static void brng_hmac(byte *Sigma, byte *S, byte *to, uint32 size){ uint32* sigma = (uint32*)Sigma; uint32 act_sz = ((size - 1) / 16 + 1) * 4; uint32 *X = new uint32[act_sz]; uint32 *Y = new uint32[act_sz]; uint32 byteSZ = act_sz << 2; memset(X, 0x00, sizeof X); for (size_t jj = 0; jj < act_sz; ++jj) X[jj] ^= X[jj]; memcpy(X, S, size); for (size_t i = 0; i < byteSZ; i += 4) { byte*l = ((byte*)X) + i, *r = ((byte*)X) + 3 + i; *r ^= *l, *l ^= *r, *r ^= *l; l = ((byte*)X) + i + 1, r = ((byte*)X) + 2 + i; *r ^= *l, *l ^= *r, *r ^= *l; } for (size_t i = 0; i < 32; i += 4) { byte*l = ((byte*)sigma) + i, *r = ((byte*)sigma) + 3 + i; *r ^= *l, *l ^= *r, *r ^= *l; l = ((byte*)sigma) + i + 1, r = ((byte*)sigma) + 2 + i; *r ^= *l, *l ^= *r, *r ^= *l; } uint32 s[4], r[4]; memset(s, 0, sizeof s); encrypt_block(s, r, sigma); for (size_t i = 0; i < act_sz - 4; i += 4) { for (size_t j = 0; j < 4; ++j) X[i + j] ^= s[j]; encrypt_block(X + i, s, sigma); } uint32 diff = byteSZ - size; if (!diff) { phi1(r); for (size_t i = 0; i < 4; ++i) s[i] ^= r[i] ^ X[act_sz - 4 + i]; } else { psi(X + act_sz - 4,16- diff); phi2(r); for (size_t i = 0; i < 4; ++i) s[i] ^= r[i] ^ X[act_sz - 4 + i]; } encrypt_block(s, r, sigma); for (size_t jj = 0; jj < 4; ++jj) change_endian((byte*)(r + jj)); memcpy(to, r, 8); for (size_t i = 0; i < 32; i += 4) { byte*l = ((byte*)sigma) + i, *r = ((byte*)sigma) + 3 + i; *r ^= *l, *l ^= *r, *r ^= *l; l = ((byte*)sigma) + i + 1, r = ((byte*)sigma) + 2 + i; *r ^= *l, *l ^= *r, *r ^= *l; } delete X; delete Y; }