Example #1
0
// Decryption and Verification procedure
int crypto_aead_decrypt(
	unsigned char *m, unsigned long long *mlen,
	unsigned char *nsec,
	const unsigned char *c, unsigned long long clen,
	const unsigned char *ad, unsigned long long adlen,
	const unsigned char *npub,
	const unsigned char *k
	)
{
	//...
	//... the code for the cipher implementation goes here,
	//... generating a plaintext m[0],m[1],...,m[*mlen-1]
	//... and secret message number nsec[0],nsec[1],...
	//... from a ciphertext c[0],c[1],...,c[clen-1]
	//... and associated data ad[0],ad[1],...,ad[adlen-1]
	//... and public message number npub[0],npub[1],...
	//... and secret key k[0],k[1],...
	//...

	// some 64-bit temp variables
	u_int64_t  t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13;
	// more 64-bit temp variables
	u_int64_t  x0, x1, x2, x3, y0, y1, y2, y3, z0, z1, z2, z3;
	// more 64-bit temp variables
	u_int64_t  pom1, pom2, pom3, pom4, nu1, nu2, nu3, nu4;
	// more 64-bit temp variables
	u_int64_t IS0, IS1, IS2, IS3, IS4, IS5, IS6, IS7, IS8, IS9, IS10, IS11, IS12, IS13, IS14, IS15;
	// more 64-bit temp variables
	u_int64_t preCompIS0, preCompIS1, preCompIS2, preCompIS3, preCompIS4, preCompIS5, preCompIS6, preCompIS7, preCompIS8, preCompIS9, preCompIS10, preCompIS11, preCompIS12, preCompIS13, preCompIS14, preCompIS15;
	// pointers to 64-bit variables
	u_int64_t  *c64, *m64, *ad64, *nsec64, *npub64, *k64;
	// an array for storing some temporal values for the Tag computation
	u_int64_t  tempTag[CRYPTO_ABYTES / W] = { 0 };
	// counter ctr is a 64-bit variable in all variants of PiCipher
	u_int64_t  ctr = 0x0000000000000000ull;
	// an array for the Common Internal State
	u_int64_t  CIS[IS_SIZE] = { 0 };
	u_int64_t  CIS1[IS_SIZE] = { 0 };
	// pointers that look at the used data arrays as arrays of bytes
	u_int8_t   *InternalState8, *CommonInternalState8, *tempTag8;
	// variables for dealing with various lengths of the plaintext and associated data
	int LastMessageChunkLength, LastADChunkLength;
	// different iterator variables
	unsigned long long i, j, jj, ii, b, i1, j1, a, cblocks, ii1, ii2, b1;

	c64 = (u_int64_t *)c;
	m64 = (u_int64_t *)m;
	ad64 = (u_int64_t *)ad;
	nsec64 = (u_int64_t *)nsec;
	npub64 = (u_int64_t *)npub;
	k64 = (u_int64_t *)k;
	InternalState8 = (u_int8_t *)IS;
	CommonInternalState8 = (u_int8_t *)CIS;
	tempTag8 = (u_int8_t *)tempTag;

	// phase 1: Initialization
	/* for (i = 0; i < IS_SIZE; i++) {
	IS[i] = 0;
	} */
	IS[0] = 0;
	IS[1] = 0;
	IS[2] = 0;
	IS[3] = 0;
	IS[4] = 0;
	IS[5] = 0;
	IS[6] = 0;
	IS[7] = 0;
	IS[8] = 0;
	IS[9] = 0;
	IS[10] = 0;
	IS[11] = 0;
	IS[12] = 0;
	IS[13] = 0;
	IS[14] = 0;
	IS[15] = 0;

	// injection of the key
	/*for (i = 0; i < CRYPTO_KEYBYTES; i++) {
	InternalState8[i] = k[i];
	}*/
	IS[0] = k64[0];
	IS[1] = k64[1];
	IS[2] = k64[2];
	IS[3] = k64[3];

	// injection of the nonce (public message number - PMN)
	/*for (j = 0; j < CRYPTO_NPUBBYTES; j++) {
	InternalState8[i++] = npub[j];
	}*/
	IS[4] = npub64[0];
	IS[5] = npub64[1];
	// appending a single 1 to the concatenated value of the key and PMN
	InternalState8[48] = 0x01;

	// applying the permutation function pi
	pi(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15]);

	// initialization of the Common Internal State (CIS), common for all parallel invocations of pi() with different ctrs
	/* for (i = 0; i < IS_SIZE; i++) {
	CIS[i] = IS[i];
	} */
	CIS[0] = IS[0];
	CIS[1] = IS[1];
	CIS[2] = IS[2];
	CIS[3] = IS[3];
	CIS[4] = IS[4];
	CIS[5] = IS[5];
	CIS[6] = IS[6];
	CIS[7] = IS[7];
	CIS[8] = IS[8];
	CIS[9] = IS[9];
	CIS[10] = IS[10];
	CIS[11] = IS[11];
	CIS[12] = IS[12];
	CIS[13] = IS[13];
	CIS[14] = IS[14];
	CIS[15] = IS[15];

	// initialization of the ctr obtained from the first 64 bits of the capacity of CIS
	ctr = CIS[4];

	// phase 2: Processing the associated data
	nu64(CIS[4], CIS[5], CIS[6], CIS[7], CIS1[4], CIS1[5], CIS1[6], CIS1[7]);
	nu64(CIS[8], CIS[9], CIS[10], CIS[11], CIS1[8], CIS1[9], CIS1[10], CIS1[11]);
	nu64(CIS[12], CIS[13], CIS[14], CIS[15], CIS1[12], CIS1[13], CIS1[14], CIS1[15]);
	nu1 = 0x8D8B87787472716C + CIS[2] + CIS[3];
	nu2 = 0x6A696665635C5A59 + CIS[1] + CIS[2] + CIS[3];
	nu2 = rotl64((nu2), 23);
	nu3 = 0x5655534E4D4B473C + CIS[1] + CIS[2];
	nu4 = 0x3A393635332E2D2B + CIS[1] + CIS[3];
	b = 0;
	a = adlen / RATE;
	for (j = 0; j < a; j++) {
		// IS for the triplex component is initialized by the CIS for every AD block
		/* for (i = 0; i < IS_SIZE; i++) {
		IS[i] = CIS[i];
		} */
		IS[0] =  CIS[0];
		IS[1] =  CIS[1];
		IS[2] =  CIS[2];
		IS[3] =  CIS[3];
		IS[4] =  CIS1[4];
		IS[5] =  CIS1[5];
		IS[6] =  CIS1[6];
		IS[7] =  CIS1[7];
		IS[8] =  CIS1[8];
		IS[9] =  CIS1[9];
		IS[10] = CIS1[10];
		IS[11] = CIS1[11];
		IS[12] = CIS1[12];
		IS[13] = CIS1[13];
		IS[14] = CIS1[14];
		IS[15] = CIS1[15];
		ctr++;
		// Inject ctr + j in IS
		IS[0] = IS[0] ^ ctr;
		pi1(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15], nu1, nu2, nu3, nu4);
		//pi(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15]);
		// process the AD block
		// Inject the AD block
		/* for (i = 0; i < N; i += 2) {
		ii1 = i * WORDS_CHUNK;
		for (i1 = 0; i1 < WORDS_CHUNK; i1++) {
		IS[ii1] = IS[ii1] ^ ad64[b];
		b++;
		ii1++;
		}
		} */
		IS[0] = IS[0] ^ ad64[b];
		b++;
		IS[1] = IS[1] ^ ad64[b];
		b++;
		IS[2] = IS[2] ^ ad64[b];
		b++;
		IS[3] = IS[3] ^ ad64[b];
		b++;
		IS[8] = IS[8] ^ ad64[b];
		b++;
		IS[9] = IS[9] ^ ad64[b];
		b++;
		IS[10] = IS[10] ^ ad64[b];
		b++;
		IS[11] = IS[11] ^ ad64[b];
		b++;
		pi(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15]);
		// Collect the tag for this block
		// Sum of the tags componentwise, where the length of one component is W
		/* jj = 0;
		for (i = 0; i < N; i += 2) {
		ii1 = i * WORDS_CHUNK;
		for (i1 = 0; i1 < WORDS_CHUNK; i1++) {
		tempTag[jj] = tempTag[jj] + IS[ii1];
		jj++;
		ii1++;
		}
		} */
		tempTag[0] = tempTag[0] + IS[0];
		tempTag[1] = tempTag[1] + IS[1];
		tempTag[2] = tempTag[2] + IS[2];
		tempTag[3] = tempTag[3] + IS[3];
		tempTag[4] = tempTag[4] + IS[8];
		tempTag[5] = tempTag[5] + IS[9];
		tempTag[6] = tempTag[6] + IS[10];
		tempTag[7] = tempTag[7] + IS[11];
	}
	// if the last AD block is not the full block, we process it byte by byte
	LastADChunkLength = adlen % RATE;
	if (LastADChunkLength) {
		b = b * W;
		i1 = 0;
		/* for (i = 0; i < IS_SIZE; i++) {
		IS[i] = CIS[i];
		} */
		IS[0] =  CIS[0];
		IS[1] =  CIS[1];
		IS[2] =  CIS[2];
		IS[3] =  CIS[3];
		IS[4] =  CIS1[4];
		IS[5] =  CIS1[5];
		IS[6] =  CIS1[6];
		IS[7] =  CIS1[7];
		IS[8] =  CIS1[8];
		IS[9] =  CIS1[9];
		IS[10] = CIS1[10];
		IS[11] = CIS1[11];
		IS[12] = CIS1[12];
		IS[13] = CIS1[13];
		IS[14] = CIS1[14];
		IS[15] = CIS1[15];
		ctr++;
		IS[0] = IS[0] ^ ctr;
		pi1(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15], nu1, nu2, nu3, nu4);
		//pi(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15]);
		for (i = 0; i < LastADChunkLength; i++) {
			InternalState8[i1] = InternalState8[i1] ^ ad[b];
			i1++;
			if (i1 % (RATE_OUT) == 0) i1 += RATE_OUT;
			b++;
		}
		// padding with 10*
		InternalState8[LastADChunkLength] = InternalState8[LastADChunkLength] ^ 0x01;
		pi(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15]);
		//updating the tag
		/* jj = 0;
		for (i = 0; i < N; i += 2) {
		ii1 = i * WORDS_CHUNK;
		for (i1 = 0; i1 < WORDS_CHUNK; i1++) {
		tempTag[jj] = tempTag[jj] + IS[ii1];
		jj++;
		ii1++;
		}
		} */
		tempTag[0] = tempTag[0] + IS[0];
		tempTag[1] = tempTag[1] + IS[1];
		tempTag[2] = tempTag[2] + IS[2];
		tempTag[3] = tempTag[3] + IS[3];
		tempTag[4] = tempTag[4] + IS[8];
		tempTag[5] = tempTag[5] + IS[9];
		tempTag[6] = tempTag[6] + IS[10];
		tempTag[7] = tempTag[7] + IS[11];
	}

	// updating the Common Internal State by injection of the tag (tempTag) obtained from the associated data
	/* jj = 0;
	for (i = 0; i < N; i += 2) {
	ii1 = i * WORDS_CHUNK;
	ii2 = (i + 1) * WORDS_CHUNK;
	for (i1 = 0; i1 < WORDS_CHUNK; i1++) {
	IS[ii1] = CIS[ii1] ^ tempTag[jj];
	IS[ii2] = CIS[ii2];
	jj++;
	ii1++;
	ii2++;
	}
	} */
	IS[0] = CIS[0] ^ tempTag[0];
	IS[1] = CIS[1] ^ tempTag[1];
	IS[2] = CIS[2] ^ tempTag[2];
	IS[3] = CIS[3] ^ tempTag[3];
	IS[4] = CIS[4];
	IS[5] = CIS[5];
	IS[6] = CIS[6];
	IS[7] = CIS[7];
	IS[8] = CIS[8] ^ tempTag[4];
	IS[9] = CIS[9] ^ tempTag[5];
	IS[10] = CIS[10] ^ tempTag[6];
	IS[11] = CIS[11] ^ tempTag[7];
	IS[12] = CIS[12];
	IS[13] = CIS[13];
	IS[14] = CIS[14];
	IS[15] = CIS[15];
	pi(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15]);
	/* for (i = 0; i < IS_SIZE; i++) {
	CIS[i] = IS[i];
	} */
	CIS[0] = IS[0];
	CIS[1] = IS[1];
	CIS[2] = IS[2];
	CIS[3] = IS[3];
	CIS[4] = IS[4];
	CIS[5] = IS[5];
	CIS[6] = IS[6];
	CIS[7] = IS[7];
	CIS[8] = IS[8];
	CIS[9] = IS[9];
	CIS[10] = IS[10];
	CIS[11] = IS[11];
	CIS[12] = IS[12];
	CIS[13] = IS[13];
	CIS[14] = IS[14];
	CIS[15] = IS[15];

	// phase 3: Processing the secret messge number
	if (CRYPTO_NSECBYTES > 0) {
		nu64(CIS[4], CIS[5], CIS[6], CIS[7], CIS[4], CIS[5], CIS[6], CIS[7]);
		nu64(CIS[8], CIS[9], CIS[10], CIS[11], CIS[8], CIS[9], CIS[10], CIS[11]);
		nu64(CIS[12], CIS[13], CIS[14], CIS[15], CIS[12], CIS[13], CIS[14], CIS[15]);
		nu1 = 0x8D8B87787472716C + CIS[2] + CIS[3];
		nu2 = 0x6A696665635C5A59 + CIS[1] + CIS[2] + CIS[3];
		nu2 = rotl64((nu2), 23);
		nu3 = 0x5655534E4D4B473C + CIS[1] + CIS[2];
		nu4 = 0x3A393635332E2D2B + CIS[1] + CIS[3];
		/* for (i = 0; i < IS_SIZE; i++) {
		IS[i] = CIS[i];
		} */
		IS[0] = CIS[0];
		IS[1] = CIS[1];
		IS[2] = CIS[2];
		IS[3] = CIS[3];
		IS[4] = CIS[4];
		IS[5] = CIS[5];
		IS[6] = CIS[6];
		IS[7] = CIS[7];
		IS[8] = CIS[8];
		IS[9] = CIS[9];
		IS[10] = CIS[10];
		IS[11] = CIS[11];
		IS[12] = CIS[12];
		IS[13] = CIS[13];
		IS[14] = CIS[14];
		IS[15] = CIS[15];
		ctr++;
		IS[0] = IS[0] ^ ctr;
		pi1(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15], nu1, nu2, nu3, nu4);
		//pi(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15]);
		// decrypt the SMN
		// Inject the SMN
		b = 0;
		/* for (i = 0; i < N; i += 2) {
		ii1 = i * WORDS_CHUNK;
		for (i1 = 0; i1 < WORDS_CHUNK; i1++) {
		nsec64[b] = IS[ii1] ^ c64[b];
		IS[ii1] = c64[b];
		b++;
		ii1++;
		}
		} */
		nsec64[b] = IS[0] ^ c64[b];
		IS[0] = c64[b];
		b++;
		nsec64[b] = IS[1] ^ c64[b];
		IS[1] = c64[b];
		b++;
		nsec64[b] = IS[2] ^ c64[b];
		IS[2] = c64[b];
		b++;
		nsec64[b] = IS[3] ^ c64[b];
		IS[3] = c64[b];
		b++;
		nsec64[b] = IS[8] ^ c64[b];
		IS[8] = c64[b];
		b++;
		nsec64[b] = IS[9] ^ c64[b];
		IS[9] = c64[b];
		b++;
		nsec64[b] = IS[10] ^ c64[b];
		IS[10] = c64[b];
		b++;
		nsec64[b] = IS[11] ^ c64[b];
		IS[11] = c64[b];
		pi(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15]);

		// updating the Common Internal State after decrypting the SMN
		/* for (i = 0; i < IS_SIZE; i++) {
		CIS[i] = IS[i];
		} */
		CIS[0] = IS[0];
		CIS[1] = IS[1];
		CIS[2] = IS[2];
		CIS[3] = IS[3];
		CIS[4] = IS[4];
		CIS[5] = IS[5];
		CIS[6] = IS[6];
		CIS[7] = IS[7];
		CIS[8] = IS[8];
		CIS[9] = IS[9];
		CIS[10] = IS[10];
		CIS[11] = IS[11];
		CIS[12] = IS[12];
		CIS[13] = IS[13];
		CIS[14] = IS[14];
		CIS[15] = IS[15];
		// Collect the tag from this encryption and update the tempTag
		/* jj = 0;
		for (i = 0; i < N; i += 2) {
		ii1 = i * WORDS_CHUNK;
		for (i1 = 0; i1 < WORDS_CHUNK; i1++) {
		tempTag[jj] = tempTag[jj] + IS[ii1];
		jj++;
		ii1++;
		}
		} */
		tempTag[0] = tempTag[0] + IS[0];
		tempTag[1] = tempTag[1] + IS[1];
		tempTag[2] = tempTag[2] + IS[2];
		tempTag[3] = tempTag[3] + IS[3];
		tempTag[4] = tempTag[4] + IS[8];
		tempTag[5] = tempTag[5] + IS[9];
		tempTag[6] = tempTag[6] + IS[10];
		tempTag[7] = tempTag[7] + IS[11];
	}

	//phase 4: Processing the ciphertext
	nu64(CIS[4], CIS[5], CIS[6], CIS[7], CIS[4], CIS[5], CIS[6], CIS[7]);
	nu64(CIS[8], CIS[9], CIS[10], CIS[11], CIS[8], CIS[9], CIS[10], CIS[11]);
	nu64(CIS[12], CIS[13], CIS[14], CIS[15], CIS[12], CIS[13], CIS[14], CIS[15]);
	nu1 = 0x8D8B87787472716C + CIS[2] + CIS[3];
	nu2 = 0x6A696665635C5A59 + CIS[1] + CIS[2] + CIS[3];
	nu2 = rotl64((nu2), 23);
	nu3 = 0x5655534E4D4B473C + CIS[1] + CIS[2];
	nu4 = 0x3A393635332E2D2B + CIS[1] + CIS[3];
	cblocks = (clen - CRYPTO_ABYTES - CRYPTO_NSECBYTES) / RATE;
	b = 0;
	b1 = bSMN;
	for (j = 0; j < cblocks; j++) {
		/* for (i = 0; i < IS_SIZE; i++) {
		IS[i] = CIS[i];
		} */
		IS[0] = CIS[0];
		IS[1] = CIS[1];
		IS[2] = CIS[2];
		IS[3] = CIS[3];
		IS[4] = CIS[4];
		IS[5] = CIS[5];
		IS[6] = CIS[6];
		IS[7] = CIS[7];
		IS[8] = CIS[8];
		IS[9] = CIS[9];
		IS[10] = CIS[10];
		IS[11] = CIS[11];
		IS[12] = CIS[12];
		IS[13] = CIS[13];
		IS[14] = CIS[14];
		IS[15] = CIS[15];
		ctr++;
		IS[0] = IS[0] ^ ctr;
		pi1(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15], nu1, nu2, nu3, nu4);
		//pi(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15]);
		// decrypt the ciphertext c
		/* for (i = 0; i < N; i += 2) {
		ii1 = i * WORDS_CHUNK;
		for (i1 = 0; i1 < WORDS_CHUNK; i1++) {
		// XOR the IS_bitrate (InternalState[0], InternalSate[2], ...) with the c to obtain m
		m64[b] = IS[ii1] ^ c64[b1];
		// in order to proceed for tag computation, put the ciphertext data in the InternalState
		IS[ii1] = c64[b1];
		b++;
		b1++;
		ii1++;
		}
		} */
		m64[b] = IS[0] ^ c64[b1];
		IS[0] = c64[b1];
		b++;
		b1++;
		m64[b] = IS[1] ^ c64[b1];
		IS[1] = c64[b1];
		b++;
		b1++;
		m64[b] = IS[2] ^ c64[b1];
		IS[2] = c64[b1];
		b++;
		b1++;
		m64[b] = IS[3] ^ c64[b1];
		IS[3] = c64[b1];
		b++;
		b1++;
		m64[b] = IS[8] ^ c64[b1];
		IS[8] = c64[b1];
		b++;
		b1++;
		m64[b] = IS[9] ^ c64[b1];
		IS[9] = c64[b1];
		b++;
		b1++;
		m64[b] = IS[10] ^ c64[b1];
		IS[10] = c64[b1];
		b++;
		b1++;
		m64[b] = IS[11] ^ c64[b1];
		IS[11] = c64[b1];
		b++;
		b1++;
		pi(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15]);
		// Collect the tag from this decryption and update the tempTag
		/* jj = 0;
		for (i = 0; i < N; i += 2) {
		ii1 = i * WORDS_CHUNK;
		for (i1 = 0; i1 < WORDS_CHUNK; i1++) {
		tempTag[jj] = tempTag[jj] + IS[ii1];
		jj++;
		ii1++;
		}
		} */
		tempTag[0] = tempTag[0] + IS[0];
		tempTag[1] = tempTag[1] + IS[1];
		tempTag[2] = tempTag[2] + IS[2];
		tempTag[3] = tempTag[3] + IS[3];
		tempTag[4] = tempTag[4] + IS[8];
		tempTag[5] = tempTag[5] + IS[9];
		tempTag[6] = tempTag[6] + IS[10];
		tempTag[7] = tempTag[7] + IS[11];
	}
	// if the last ciphertext block is not the full block, we process it byte by byte
	LastMessageChunkLength = (clen - CRYPTO_ABYTES - CRYPTO_NSECBYTES) % RATE;
	if (LastMessageChunkLength) {
		b = b * W;
		b1 = CRYPTO_NSECBYTES + b;
		i1 = 0;
		/* for (i = 0; i < IS_SIZE; i++) {
		IS[i] = CIS[i];
		} */
		IS[0] = CIS[0];
		IS[1] = CIS[1];
		IS[2] = CIS[2];
		IS[3] = CIS[3];
		IS[4] = CIS[4];
		IS[5] = CIS[5];
		IS[6] = CIS[6];
		IS[7] = CIS[7];
		IS[8] = CIS[8];
		IS[9] = CIS[9];
		IS[10] = CIS[10];
		IS[11] = CIS[11];
		IS[12] = CIS[12];
		IS[13] = CIS[13];
		IS[14] = CIS[14];
		IS[15] = CIS[15];
		ctr++;
		IS[0] = IS[0] ^ ctr;
		pi1(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15], nu1, nu2, nu3, nu4);
		//pi(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15]);
		for (i = 0; i < LastMessageChunkLength; i++) {
			m[b] = InternalState8[i1] ^ c[b1];
			InternalState8[i1] = c[b1];
			i1++;
			if (i1 % (RATE_OUT) == 0) i1 += RATE_OUT;
			b++;
			b1++;
		}
		// padding with 10*
		InternalState8[LastMessageChunkLength] = InternalState8[LastMessageChunkLength] ^ 0x01;
		pi(IS[0], IS[1], IS[2], IS[3], IS[4], IS[5], IS[6], IS[7], IS[8], IS[9], IS[10], IS[11], IS[12], IS[13], IS[14], IS[15]);
		// updating the tag
		/* jj = 0;
		for (i = 0; i < N; i += 2) {
		ii1 = i * WORDS_CHUNK;
		for (i1 = 0; i1 < WORDS_CHUNK; i1++) {
		tempTag[jj] = tempTag[jj] + IS[ii1];
		jj++;
		ii1++;
		}
		} */
		tempTag[0] = tempTag[0] + IS[0];
		tempTag[1] = tempTag[1] + IS[1];
		tempTag[2] = tempTag[2] + IS[2];
		tempTag[3] = tempTag[3] + IS[3];
		tempTag[4] = tempTag[4] + IS[8];
		tempTag[5] = tempTag[5] + IS[9];
		tempTag[6] = tempTag[6] + IS[10];
		tempTag[7] = tempTag[7] + IS[11];
	}

	//updating the lenght of the message
	*mlen = clen - CRYPTO_ABYTES - CRYPTO_NSECBYTES;

	// tag verification
	b = (*mlen + CRYPTO_NSECBYTES);
	for (ii = b; ii < clen; ii++) {
		if (c[ii] != tempTag8[ii - b])
			return -1;
	}

	return 0;
}
Example #2
0
File: main.c Project: Diego3010/PI
int main (void) {

	printf ("Valor de PI: %f\n", pi () );
}	
Example #3
0
float Sphere::area() const {
    return (float)pi() * 4.0f * powf((float)radius, 2.0f);
}
int main(){

    //run-time instance
    volatile double mut_val=-3.1415926;

    value_tuple<bool, char, double, int, pi> tuple(pos<1>(false),
                                               pos<3>(mut_val),
                                               pos<2>('m'));
    std::cout << tuple.get<1>() << " "
              << tuple.get<2>() << " "
              << tuple.get<3>() << " "
              << tuple.get<4>() << " "
              << tuple.get<5>() << " "
              << std::endl;

    value_tuple<bool, char, double, pi> default_tuple;
    std::cout << default_tuple.get<1>() << " "
              << default_tuple.get<2>() << " "
              << default_tuple.get<3>() << " "
              << default_tuple.get<4>() << " "
              << std::endl;


    constexpr value_tuple<bool, char, double, int> ctuple(pos<1>(false), pos<3>(3.14), pos<2>('m'));
    static_assert(ctuple.get<1>()==false, "error");
    static_assert(ctuple.get<2>()=='m', "error");
    static_assert(ctuple.get<3>()==3.14, "error");
    static_assert(ctuple.get<4>()==int(), "error");
    //    static_assert(c_tuple.get<4>()=='b', "error");  // This trigger an error


    //exercice: make the following tuple compile
    value_tuple<bool, short, std::string> tuple2(pos<1>(false), pos<2>(4), pos<3>(std::string("pink pig")));

    tuple2.set<3>(std::string("black dog"));

    std::cout<<tuple2.get<3>()<<std::endl;
    //advanced exercice:
    //implement a tuple which expands the interface make_tuple<type, 5> to
    //value_tuple<type, type, type, type, type>
    make_value_tuple<int, 5> new_tuple(pos<5>(66), pos<4>(55), pos<3>(44), pos<2>(33),pos<1>(22));

    std::cout << new_tuple.get<1>() << " "
              << new_tuple.get<2>() << " "
              << new_tuple.get<3>() << " "
              << new_tuple.get<4>() << " "
              << new_tuple.get<5>() << " "
              << std::endl;
    //very advanced exercice (probably not a good idea):
    //implement an interface which mixes run-time and compile-time components in an offset-tuple
    //using tuple_t = offset_tuple<int, 5>
    //using alias<pos<1>, 5> = new_tuple_t;
    //new_tuple_t(pos<4>(3));

    detail_::integer_tuple_mixed< make_value_tuple<int,4>, pair<5, 44> > tmp;

    static_assert(detail_::get<5>(tmp)==44, "error");
    static_assert(tmp.get<5>()==44, "error");


    //the interface for generic tuple (not only integers) becomes a bit cumbersome
    detail_::value_tuple_mixed< make_value_tuple<int,4>, const value_tuple<int, char, pi>, c_tuple_> tmp2;

    static_assert(tmp2.get<3>().m_value==pi(10).m_value, "error");
}
Example #5
0
unsigned int ompl::geometric::PathHybridization::recordPath(const base::PathPtr &pp, bool matchAcrossGaps)
{
    auto *p = dynamic_cast<PathGeometric *>(pp.get());
    if (!p)
    {
        OMPL_ERROR("Path hybridization only works for geometric paths");
        return 0;
    }

    if (p->getSpaceInformation() != si_)
    {
        OMPL_ERROR("Paths for hybridization must be from the same space information");
        return 0;
    }

    // skip empty paths
    if (p->getStateCount() == 0)
        return 0;

    PathInfo pi(pp);

    // if this path was previously included in the hybridization, skip it
    if (paths_.find(pi) != paths_.end())
        return 0;

    // the number of connection attempts
    unsigned int nattempts = 0;

    // start from virtual root
    Vertex v0 = boost::add_vertex(g_);
    stateProperty_[v0] = pi.states_[0];
    pi.vertices_.push_back(v0);

    // add all the vertices of the path, and the edges between them, to the HGraph
    // also compute the path length for future use (just for computational savings)
    const HGraph::edge_property_type prop0(0.0);
    boost::add_edge(root_, v0, prop0, g_);
    double length = 0.0;
    for (std::size_t j = 1; j < pi.states_.size(); ++j)
    {
        Vertex v1 = boost::add_vertex(g_);
        stateProperty_[v1] = pi.states_[j];
        double weight = si_->distance(pi.states_[j - 1], pi.states_[j]);
        const HGraph::edge_property_type properties(weight);
        boost::add_edge(v0, v1, properties, g_);
        length += weight;
        pi.vertices_.push_back(v1);
        v0 = v1;
    }

    // connect to virtual goal
    boost::add_edge(v0, goal_, prop0, g_);
    pi.length_ = length;

    // find matches with previously added paths
    for (const auto &path : paths_)
    {
        const auto *q = static_cast<const PathGeometric *>(path.path_.get());
        std::vector<int> indexP, indexQ;
        matchPaths(*p, *q, (pi.length_ + path.length_) / (2.0 / magic::GAP_COST_FRACTION), indexP, indexQ);

        if (matchAcrossGaps)
        {
            int lastP = -1;
            int lastQ = -1;
            int gapStartP = -1;
            int gapStartQ = -1;
            bool gapP = false;
            bool gapQ = false;
            for (std::size_t i = 0; i < indexP.size(); ++i)
            {
                // a gap is found in p
                if (indexP[i] < 0)
                {
                    // remember this as the beginning of the gap, if needed
                    if (!gapP)
                        gapStartP = i;
                    // mark the fact we are now in a gap on p
                    gapP = true;
                }
                else
                {
                    // check if a gap just ended;
                    // if it did, try to match the endpoint with the elements in q
                    if (gapP)
                        for (std::size_t j = gapStartP; j < i; ++j)
                        {
                            attemptNewEdge(pi, path, indexP[i], indexQ[j]);
                            ++nattempts;
                        }
                    // remember the last non-negative index in p
                    lastP = i;
                    gapP = false;
                }
                if (indexQ[i] < 0)
                {
                    if (!gapQ)
                        gapStartQ = i;
                    gapQ = true;
                }
                else
                {
                    if (gapQ)
                        for (std::size_t j = gapStartQ; j < i; ++j)
                        {
                            attemptNewEdge(pi, path, indexP[j], indexQ[i]);
                            ++nattempts;
                        }
                    lastQ = i;
                    gapQ = false;
                }

                // try to match corresponding index values and gep beginnings
                if (lastP >= 0 && lastQ >= 0)
                {
                    attemptNewEdge(pi, path, indexP[lastP], indexQ[lastQ]);
                    ++nattempts;
                }
            }
        }
        else
        {
            // attempt new edge only when states align
            for (std::size_t i = 0; i < indexP.size(); ++i)
                if (indexP[i] >= 0 && indexQ[i] >= 0)
                {
                    attemptNewEdge(pi, path, indexP[i], indexQ[i]);
                    ++nattempts;
                }
        }
    }

    // remember this path is part of the hybridization
    paths_.insert(pi);
    return nattempts;
}
Example #6
0
    void DrrnPsiClient::recv(Channel s0, Channel s1, span<block> inputs)
    {
        if (inputs.size() != mClientSetSize)
            throw std::runtime_error(LOCATION);

        Matrix<u64> bins(mNumSimpleBins, mBinSize);
        std::vector<u64> binSizes(mNumSimpleBins);
        u64 cuckooSlotsPerBin = (mCuckooParams.numBins() + mNumSimpleBins) / mNumSimpleBins;

        // Simple hashing with a PRP
        std::vector<block> hashs(inputs.size());
        AES hasher(mHashingSeed);
        u64 numCuckooBins = mCuckooParams.numBins();
        for (u64 i = 0; i < u64(inputs.size());)
        {
            auto min = std::min<u64>(inputs.size() - i, 8);
            auto end = i + min;
            hasher.ecbEncBlocks(inputs.data() + i, min, hashs.data() + i);
            for (; i < end; ++i)
            {
                hashs[i] = hashs[i] ^ inputs[i];
                for (u64 j = 0; j < mCuckooParams.mNumHashes; ++j)
                {
                    u64 idx = CuckooIndex<>::getHash(hashs[i], j, numCuckooBins) * mNumSimpleBins / mCuckooParams.numBins();

                    // insert this item in this bin. pack together the hash index and input index
                    bins(idx, binSizes[idx]++) = (j << 56) | i;
                }

                //if (!i)
                //{
                //    ostreamLock(std::cout) << "cinput[" << i << "] = " << inputs[i] << " -> " << hashs[i] << " ("
                //        << CuckooIndex<>::getHash(hashs[i], 0, numCuckooBins) << ", "
                //        << CuckooIndex<>::getHash(hashs[i], 1, numCuckooBins) << ", "
                //        << CuckooIndex<>::getHash(hashs[i], 2, numCuckooBins) << ")"
                //        << std::endl;
                //}
            }
        }



        // power of 2
        u64 numLeafBlocks = (cuckooSlotsPerBin + mBigBlockSize * 128 - 1) / (mBigBlockSize * 128);
        u64 gDepth = 2;
        u64 kDepth = std::max<u64>(gDepth, log2floor(numLeafBlocks)) - gDepth;
        u64 groupSize = (numLeafBlocks + (u64(1) << kDepth) - 1) / (u64(1) << kDepth);
        if (groupSize > 8) throw std::runtime_error(LOCATION);

        //std::cout << "kDepth:   " << kDepth << std::endl;
        //std::cout << "mBinSize: " << mBinSize << std::endl;

        u64 numQueries = mNumSimpleBins * mBinSize;
        auto permSize = numQueries * mBigBlockSize;

        // mask generation
        block rSeed = CCBlock;// mPrng.get<block>();
        AES rGen(rSeed);


        std::vector<block> shares(mClientSetSize * mCuckooParams.mNumHashes), r(permSize), piS1(permSize), s(permSize);
        //std::vector<u32> rIdxs(numQueries);
        //std::vector<u64> sharesIdx(shares.size());

        //TODO("use real masks");
        //memset(r.data(), 0, r.size() * sizeof(block));
        rGen.ecbEncCounterMode(r.size() * 0, r.size(), r.data());
        rGen.ecbEncCounterMode(r.size() * 1, r.size(), piS1.data());
        rGen.ecbEncCounterMode(r.size() * 2, r.size(), s.data());

        //auto encIter = enc.begin();
        auto shareIter = shares.begin();
        //auto shareIdxIter = sharesIdx.begin();
        u64 queryIdx = 0, dummyPermIdx = mClientSetSize * mCuckooParams.mNumHashes;

        std::unordered_map<u64, u64> inputMap;
        inputMap.reserve(mClientSetSize * mCuckooParams.mNumHashes);

        std::vector<u32> pi(permSize);
        auto piIter = pi.begin();


        u64 keySize = kDepth + 1 + groupSize;
        u64 mask = (u64(1) << 56) - 1;
        auto binIter = bins.begin();
        for (u64 bIdx = 0; bIdx < mNumSimpleBins; ++bIdx)
        {
            u64 i = 0;

            auto binOffset = (bIdx * numCuckooBins + mNumSimpleBins - 1) / mNumSimpleBins;

            std::vector<block> k0(keySize * mBinSize), k1(keySize * mBinSize);
            //std::vector<u64> idx0(mBinSize), idx1(mBinSize);
            auto k0Iter = k0.data(), k1Iter = k1.data();
            //auto idx0Iter = idx0.data(), idx1Iter = idx1.data();

            for (; i < binSizes[bIdx]; ++i)
            {
                span<block>
                    kk0(k0Iter, kDepth + 1),
                    g0(k0Iter + kDepth + 1, groupSize),
                    kk1(k1Iter, kDepth + 1),
                    g1(k1Iter + kDepth + 1, groupSize);

                k0Iter += keySize;
                k1Iter += keySize;

                u8 hashIdx = *binIter >> 56;
                u64 itemIdx = *binIter & mask;
                u64 cuckooIdx = CuckooIndex<>::getHash(hashs[itemIdx], hashIdx, numCuckooBins) - binOffset;
                ++binIter;

                auto bigBlockoffset = cuckooIdx % mBigBlockSize;
                auto bigBlockIdx = cuckooIdx / mBigBlockSize;

                BgiPirClient::keyGen(bigBlockIdx, mPrng.get<block>(), kk0, g0, kk1, g1);



                // the index of the mask that will mask this item
                auto rIdx = *piIter = itemIdx * mCuckooParams.mNumHashes + hashIdx * mBigBlockSize + bigBlockoffset;

                // the masked value that will be inputted into the PSI
                *shareIter = r[rIdx] ^ inputs[itemIdx];
                //*shareIter = inputs[itemIdx];

                //if (itemIdx == 0)
                //    ostreamLock(std::cout)
                //    << "item[" << i << "]    bin " << bIdx
                //    << " block " << bigBlockIdx 
                //    << " offset " << bigBlockoffset 
                //    << " psi " << *shareIter << std::endl;

                // This will be used to map itemed items in the intersection back to their input item
                inputMap.insert({ queryIdx, itemIdx });

                ++shareIter;
                ++piIter;
                ++queryIdx;
            }

            u64 rem = mBinSize - i;


            binIter += rem;
            for (u64 i = 0; i < rem; ++i)
            {
                *piIter++ = dummyPermIdx++;
            }

            //s0.asyncSendCopy(k0);
            //s0.asyncSendCopy(k1);
            //s1.asyncSendCopy(k1);
            //s1.asyncSendCopy(k0);

            s0.asyncSend(std::move(k0));
            s1.asyncSend(std::move(k1));

        }

        std::vector<u32> pi1(permSize), pi0(permSize), pi1Inv(permSize);
        for (u32 i = 0; i < pi1.size(); ++i) pi1[i] = i;
        PRNG prng(rSeed ^ OneBlock);
        std::random_shuffle(pi1.begin(), pi1.end(), prng);


        //std::vector<block> pi1RS(pi.size());
        for (u64 i = 0; i < permSize; ++i)
        {
            //auto pi1i = pi1[i];
            //pi1RS[i] = r[pi1i] ^ s[pi1i];

            pi1Inv[pi1[i]] = i;
            //std::cout << "pi1(r + s)[" << i << "] " << pi1RS[i] << std::endl;
        }
        std::vector<block> piS0(r.size());
        for (u64 i = 0; i < permSize; ++i)
        {
            //std::cout << "r[" << i << "] " << r[i] << std::endl;
            //std::cout << "pi(r + s)[" << i << "]=" << (r[pi[i]] ^ s[pi[i]]) << std::endl;


            pi0[i] = pi1Inv[pi[i]];
            piS0[i] = piS1[i] ^ s[pi[i]];
            //std::cout << "pi (r + s)[" << i << "] = " << (r[pi[i]] ^ s[pi[i]]) << " = " << r[pi[i]] << " ^ " << s[pi[i]] << " c " << pi[i] << std::endl;
            //std::cout << "pi`(r + s)[" << i << "] = " << pi1RS[pi0[i]]  <<" c " << pi0[pi1[i]] << std::endl;
        }

        s0.asyncSend(std::move(pi0));
        s0.asyncSend(std::move(piS0));
        //rGen.ecbEncBlocks(r.data(), r.size(), r.data());
        //for (u64 i = 0; i < shares.size(); ++i)
        //{
        //    std::cout << IoStream::lock << "cshares[" << i << "] " << shares[i] << " input[" << sharesIdx[i]<<"]" << std::endl << IoStream::unlock;
        //}
        mPsi.sendInput(shares, s0);

        mIntersection.reserve(mPsi.mIntersection.size());
        for (u64 i = 0; i < mPsi.mIntersection.size(); ++i) {
            // divide index by #hashes
            mIntersection.emplace(inputMap[mPsi.mIntersection[i]]);
        }

    }
Example #7
0
const double Gaussian2D::volume() const
{
    return pow(sqrt(2.0 * pi()) * bandwidth_, 2.0);
}
Example #8
0
double radToDeg(double rad) {
    return rad * 180.0 / pi();
}
Example #9
0
// Decryption and Verification procedure
int crypto_aead_decrypt(
unsigned char *m,unsigned long long *mlen,
unsigned char *nsec,
const unsigned char *c,unsigned long long clen,
const unsigned char *ad,unsigned long long adlen,
const unsigned char *npub,
const unsigned char *k
)
{
 //...
 //... the code for the cipher implementation goes here,
 //... generating a plaintext m[0],m[1],...,m[*mlen-1]
 //... and secret message number nsec[0],nsec[1],...
 //... from a ciphertext c[0],c[1],...,c[clen-1]
 //... and associated data ad[0],ad[1],...,ad[adlen-1]
 //... and public message number npub[0],npub[1],...
 //... and secret key k[0],k[1],...
 //...

 // some 64-bit temp variables
 u_int64_t  t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13;
 // more 64-bit temp variables
 u_int64_t  x0, x1, x2, x3, y0, y1, y2, y3, z0, z1, z2, z3;
 // pointers to 64-bit variables
 u_int64_t  *c64, *m64, *ad64, *nsec64, *npub64, *k64;
 // an array for storing some temporal values for the Tag computation
 u_int64_t  tempTag[CRYPTO_ABYTES/W] = {0};
 // counter ctr is a 64-bit variable in all variants of PiCipher
 u_int64_t  ctr = 0x0000000000000000ull;
 // an array for the Common Internal State
 u_int64_t  CIS[IS_SIZE]={0};
 // pointers that look at the used data arrays as arrays of bytes
 u_int8_t   *InternalState8, *CommonInternalState8, *tempTag8;
 // variables for dealing with various lengths of the plaintext and associated data
 int LastMessageChunkLength, LastADChunkLength;
 // different iterator variables
 unsigned long long i, j, jj, ii, b, i1, j1, a;

 c64    = (u_int64_t *) c;
 m64    = (u_int64_t *) m;
 ad64   = (u_int64_t *) ad;
 nsec64 = (u_int64_t *) nsec;
 npub64 = (u_int64_t *) npub;
 k64    = (u_int64_t *) k;
 InternalState8 = (u_int8_t *) IS;
 CommonInternalState8 = (u_int8_t *) CIS;
 tempTag8 = (u_int8_t *) tempTag;

 // phase 1: Initialization
 for (i = 0; i < IS_SIZE; i++ ) {
	 IS[i] = 0;
 }
 // injection of the key
	IS[0] = k64[0];
	IS[1] = k64[1];
	IS[2] = k64[2];
	IS[3] = k64[3];
	
 // injection of the nonce (public message number - PMN)
	IS[4]  = npub64[0];
	IS[5]  = npub64[1];
	IS[6]  = npub64[2];
	IS[7]  = npub64[3];
	IS[8]  = npub64[4];
	IS[9]  = npub64[5];
	IS[10] = npub64[6];
	IS[11] = npub64[7];
	
 // appending a single 1 to the concatenated value of the key and PMN
	InternalState8[96] = 0x01;

 // applying the permutation function pi
	pi();

 // initialization of the Common Internal State (CIS), common for all parallel invocations of pi() with different ctrs
 for ( i = 0; i < IS_SIZE; i++ ) {
	CIS[i] = IS[i];
 }

 // initialization of the ctr obtained from the first 64 bits of the capacity of CIS
	ctr = CIS[4];

 // phase 2: Processing the associated data
 b = 0;
 a = adlen/RATE;
 for ( j = 0; j < a; j ++ ) {
	 // IS for the triplex component is initialized by the CIS for every AD block
	for ( i = 0; i < IS_SIZE; i++ ) {
		IS[i] = CIS[i];
	}
	ctr ++;
	// Inject ctr + j in IS
	IS[0] = IS[0] ^ ctr;
	pi();
	// process the AD block
	// Inject the AD block
	for ( i = 0; i < N; i += 2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			IS[i*WORDS_CHUNK+i1] = IS[i*WORDS_CHUNK+i1] ^ ad64[b];
			b++;
		}
	}
	pi();
	// Collect the tag for this block
	// Sum of the tags componentwise, where the length of one component is W
	jj = 0;
	for ( i = 0; i < NTag; i+=2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			tempTag[jj] = tempTag[jj] + IS[i*WORDS_CHUNK+i1];
			jj++;
		}
	}
 }
 // if the last AD block is not the full block, we process it byte by byte
 LastADChunkLength = adlen % RATE;
 if ( LastADChunkLength ) {
	 b = b * W;
	 i1 = 0;
	 for ( i = 0; i < IS_SIZE; i++ ) {
		IS[i] = CIS[i];
	 }
	 ctr++;
	 IS[0] = IS[0] ^ ctr;
	 pi();
	 for ( i = 0; i < LastADChunkLength; i++ ) {
		 InternalState8[i1] = InternalState8[i1] ^ ad[b+i];
		 i1++;
		 if( i1 % (RATE_OUT) == 0 ) i1 += RATE_OUT;
	 }
	 // padding with 10*
	 InternalState8[i1] = InternalState8[i1] ^ 0x01;
	 pi();
	 //updating the tag
	 jj = 0;
	 for ( i = 0; i < NTag; i+=2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			tempTag[jj] = tempTag[jj] + IS[i*WORDS_CHUNK+i1];
			jj++;
		}
	 }
 }
 // if the AD is full blocks we still need to append 10* and it is done in an additional block
 else{
	for ( i = 0; i < IS_SIZE; i++ ) {
		IS[i] = CIS[i];
	}
	ctr++;
	IS[0] = IS[0] ^ ctr;
	pi();
	// padding with 10*
	InternalState8[0] = InternalState8[0] ^ 0x01;
	pi();
	//updating the tag
	jj = 0;
	for ( i = 0; i < NTag; i+=2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			tempTag[jj] = tempTag[jj] + IS[i*WORDS_CHUNK+i1];
			jj++;
		}
	}
 }

 // updating the Common Internal State by injection of the tag (tempTag) obtained from the associated data
 jj = 0;
 for ( i = 0; i < NTag; i+=2 ) {
	for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
		IS[i*WORDS_CHUNK+i1] = CIS[i*WORDS_CHUNK+i1] ^ tempTag[jj];
		IS[(i+1)*WORDS_CHUNK+i1] = CIS[(i+1)*WORDS_CHUNK+i1];
		jj++;
	}
 }
 pi();
 for ( i = 0; i < IS_SIZE; i++ ) {
	CIS[i] = IS[i];
 }


 // phase 3: Processing the secret message number
 if ( CRYPTO_NSECBYTES > 0 ) {
	for ( i = 0; i < IS_SIZE; i++ ) {
		IS[i] = CIS[i];
	}
	ctr++;
	IS[0] = IS[0] ^ ctr;
	pi();
	// decrypt the SMN
	// Inject the SMN
	i1 = 0;
	for ( i = 0; i < CRYPTO_NSECBYTES; i++ ) {
		 nsec[i] = InternalState8[i1] ^ c[i];
	 	 InternalState8[i1] = c[i];
		 i1++;
		 if( i1 % (RATE_OUT) == 0 ) i1 += RATE_OUT;
	 }
	 // padding with 10*
	 InternalState8[CRYPTO_NSECBYTES] = InternalState8[CRYPTO_NSECBYTES] ^ 0x01;
	 pi();
	 
	// updating the Common Internal State from the encrypted SMN
	for ( i = 0; i < IS_SIZE; i++ ) {
		CIS[i] = IS[i];
	}
	// Collect the tag from this encryption and update the tempTag
	jj = 0;
	for ( i = 0; i < NTag; i+=2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			tempTag[jj] = tempTag[jj] + IS[i*WORDS_CHUNK+i1];
			jj++;
		}
	}
 }

 //phase 4: Processing the ciphertext
 b = 0;
 for ( j = 0; j < (clen-CRYPTO_ABYTES-CRYPTO_NSECBYTES)/RATE; j ++ ) {
	for ( i = 0; i < IS_SIZE; i++ ) {
		IS[i] = CIS[i];
	}
	ctr ++;
	IS[0] = IS[0] ^ ctr;
	pi();
	// decrypt the ciphertext c
	for ( i = 0; i < N; i+=2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
	        // XOR the IS_bitrate (InternalState[0], InternalSate[2], ...) with the c to obtain m
			m64[b] = IS[i*WORDS_CHUNK+i1] ^ c64[bSMN+b];
			// in order to proceed for tag computation, put the ciphertext data in the InternalState
			IS[i*WORDS_CHUNK+i1] = c64[bSMN+b];
			b++;
		}
	}
	pi();
	// Collect the tag from this decryption and update the tempTag
	jj = 0;
	for ( i = 0; i < NTag; i+=2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			tempTag[jj] = tempTag[jj] + IS[i*WORDS_CHUNK+i1];
			jj++;
		}
	}
 }
 // if the last ciphertext block is not the full block, we process it byte by byte
 LastMessageChunkLength = (clen-CRYPTO_ABYTES-CRYPTO_NSECBYTES) % RATE;
 if ( LastMessageChunkLength ) {
	 b = b * W;
	 i1 = 0;
	 for ( i = 0; i < IS_SIZE; i++ ) {
		IS[i] = CIS[i];
	 }
	 ctr ++;
	 IS[0] = IS[0] ^ ctr;
	 pi();

	 for ( i = 0; i < LastMessageChunkLength; i++ ) {
	 	 m[b+i] = InternalState8[i1] ^ c[CRYPTO_NSECBYTES+b+i];
	 	 InternalState8[i1] = c[CRYPTO_NSECBYTES+b+i];
		 i1++;
		 if( i1 % (RATE_OUT) == 0 ) i1 += RATE_OUT;
	 }
	 // padding with 10*
	 InternalState8[i1] = InternalState8[i1] ^ 0x01;
	 pi();
	 // updating the tag
	 jj = 0;
	 for ( i = 0; i < NTag; i+=2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			tempTag[jj] = tempTag[jj] + IS[i*WORDS_CHUNK+i1];
			jj++;
		}
	 }
 }
 // if the message is full blocks we still need to append 10* and it is done in to an additional block
 else{
	for ( i = 0; i < IS_SIZE; i++ ) {
		IS[i] = CIS[i];
	}
	ctr++;
	IS[0] = IS[0] ^ ctr;
	pi();
	// padding with 10*
	InternalState8[0] = InternalState8[0] ^ 0x01;
	pi();
	//updating the tag
	jj = 0;
	for ( i = 0; i < NTag; i+=2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			tempTag[jj] = tempTag[jj] + IS[i*WORDS_CHUNK+i1];
			jj++;
		}
	}
 }

 //updating the length of the message
 *mlen = clen-CRYPTO_ABYTES-CRYPTO_NSECBYTES;

 // tag verification
 for ( ii = (*mlen + CRYPTO_NSECBYTES); ii < clen; ii ++ ) {
	 if ( c[ii] != tempTag8[ii-(*mlen + CRYPTO_NSECBYTES)] )
		return -1;
 }

 return 0;
}
Example #10
0
void Stokes::FACOps::smooth_Tackley_2D
(SAMRAI::solv::SAMRAIVectorReal<double>& solution,
 const SAMRAI::solv::SAMRAIVectorReal<double>& residual,
 int ln,
 int num_sweeps,
 double residual_tolerance)
{
  const int p_id(solution.getComponentDescriptorIndex(0)),
    p_rhs_id(residual.getComponentDescriptorIndex(0)),
    v_id(solution.getComponentDescriptorIndex(1)),
    v_rhs_id(residual.getComponentDescriptorIndex(1));

#ifdef DEBUG_CHECK_ASSERTIONS
  if (solution.getPatchHierarchy() != d_hierarchy
      || residual.getPatchHierarchy() != d_hierarchy)
    {
      TBOX_ERROR(d_object_name << ": Vector hierarchy does not match\n"
                 "internal hierarchy.");
    }
#endif
  boost::shared_ptr<SAMRAI::hier::PatchLevel> level = d_hierarchy->getPatchLevel(ln);

  /* Only need to sync the rhs once. This sync is needed because
     calculating a new pressure update requires computing in the ghost
     region so that the update for the velocity inside the box will be
     correct. */
  p_refine_patch_strategy.setTargetDataId(p_id);
  v_refine_patch_strategy.setTargetDataId(v_id);
  set_boundaries(p_id,v_id,level,true);
  xeqScheduleGhostFillNoCoarse(p_rhs_id,v_rhs_id,ln);

  if (ln > d_ln_min) {
    /*
     * Perform a one-time transfer of data from coarser level,
     * to fill ghost boundaries that will not change through
     * the smoothing loop.
     */
    xeqScheduleGhostFill(p_id, v_id, ln);
  }

  double theta_momentum=0.7;
  double theta_continuity=1.0;

  /*
   * Smooth the number of sweeps specified or until
   * the convergence is satisfactory.
   */
  double maxres;
  /*
   * Instead of checking residual convergence globally, we check the
   * converged flag.  This avoids possible round-off errors affecting
   * different processes differently, leading to disagreement on
   * whether to continue smoothing.
   */
  const SAMRAI::hier::Index ip(1,0), jp(0,1);
  bool converged = false;
  for (int sweep=0; sweep < num_sweeps*(1<<(d_ln_max-ln)) && !converged;
       ++sweep)
    {
      maxres=0;

      /* vx sweep */
      xeqScheduleGhostFillNoCoarse(p_id,invalid_id,ln);
      for(int rb=0;rb<2;++rb)
        {
          xeqScheduleGhostFillNoCoarse(invalid_id,v_id,ln);
          for (SAMRAI::hier::PatchLevel::Iterator pi(level->begin());
               pi!=level->end(); ++pi)
            {
              boost::shared_ptr<SAMRAI::hier::Patch> patch = *pi;

              boost::shared_ptr<SAMRAI::pdat::CellData<double> > p_ptr =
                boost::dynamic_pointer_cast<SAMRAI::pdat::CellData<double> >
                (patch->getPatchData(p_id));
              SAMRAI::pdat::CellData<double> &p(*p_ptr);
                
              boost::shared_ptr<SAMRAI::pdat::SideData<double> > v_ptr =
                boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
                (patch->getPatchData(v_id));
              SAMRAI::pdat::SideData<double> &v(*v_ptr);
              boost::shared_ptr<SAMRAI::pdat::SideData<double> > v_rhs_ptr =
                boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
                (patch->getPatchData(v_rhs_id));
              SAMRAI::pdat::SideData<double> &v_rhs(*v_rhs_ptr);
                
              boost::shared_ptr<SAMRAI::pdat::CellData<double> > cell_visc_ptr =
                boost::dynamic_pointer_cast<SAMRAI::pdat::CellData<double> >
                (patch->getPatchData(cell_viscosity_id));
              SAMRAI::pdat::CellData<double> &cell_viscosity(*cell_visc_ptr);
              boost::shared_ptr<SAMRAI::pdat::NodeData<double> > edge_visc_ptr =
                boost::dynamic_pointer_cast<SAMRAI::pdat::NodeData<double> >
                (patch->getPatchData(edge_viscosity_id));
              SAMRAI::pdat::NodeData<double> &edge_viscosity(*edge_visc_ptr);

              SAMRAI::hier::Box pbox=patch->getBox();
              boost::shared_ptr<SAMRAI::geom::CartesianPatchGeometry> geom =
                boost::dynamic_pointer_cast<SAMRAI::geom::CartesianPatchGeometry>
                (patch->getPatchGeometry());
              double dx = geom->getDx()[0];
              double dy = geom->getDx()[1];

              for(int j=pbox.lower(1); j<=pbox.upper(1); ++j)
                {
                  /* Do the red-black skip */
                  int i_min=pbox.lower(0) + (abs(pbox.lower(0) + j + rb))%2;
                  for(int i=i_min; i<=pbox.upper(0)+1; i+=2)
                    {
                      SAMRAI::pdat::CellIndex center(SAMRAI::tbox::Dimension(2));
                      center[0]=i;
                      center[1]=j;

                      /* Update v */
                      smooth_V_2D(0,pbox,geom,center,ip,jp,
                                  p,v,v_rhs,maxres,dx,dy,cell_viscosity,
                                  edge_viscosity,theta_momentum);
                    }
                }
            }
          set_boundaries(invalid_id,v_id,level,true);
        }


      /* vy sweep */

      for(int rb=0;rb<2;++rb)
        {
          xeqScheduleGhostFillNoCoarse(invalid_id,v_id,ln);
          for (SAMRAI::hier::PatchLevel::Iterator pi(level->begin());
               pi!=level->end(); ++pi)
            {
              boost::shared_ptr<SAMRAI::hier::Patch> patch = *pi;

              boost::shared_ptr<SAMRAI::pdat::CellData<double> > p_ptr =
                boost::dynamic_pointer_cast<SAMRAI::pdat::CellData<double> >
                (patch->getPatchData(p_id));
              SAMRAI::pdat::CellData<double> &p(*p_ptr);
                
              boost::shared_ptr<SAMRAI::pdat::SideData<double> > v_ptr =
                boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
                (patch->getPatchData(v_id));
              SAMRAI::pdat::SideData<double> &v(*v_ptr);
              boost::shared_ptr<SAMRAI::pdat::SideData<double> > v_rhs_ptr =
                boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
                (patch->getPatchData(v_rhs_id));
              SAMRAI::pdat::SideData<double> &v_rhs(*v_rhs_ptr);
                
              boost::shared_ptr<SAMRAI::pdat::CellData<double> > cell_visc_ptr =
                boost::dynamic_pointer_cast<SAMRAI::pdat::CellData<double> >
                (patch->getPatchData(cell_viscosity_id));
              SAMRAI::pdat::CellData<double> &cell_viscosity(*cell_visc_ptr);
              boost::shared_ptr<SAMRAI::pdat::NodeData<double> > edge_visc_ptr =
                boost::dynamic_pointer_cast<SAMRAI::pdat::NodeData<double> >
                (patch->getPatchData(edge_viscosity_id));
              SAMRAI::pdat::NodeData<double> &edge_viscosity(*edge_visc_ptr);

              SAMRAI::hier::Box pbox=patch->getBox();
              boost::shared_ptr<SAMRAI::geom::CartesianPatchGeometry> geom =
                boost::dynamic_pointer_cast<SAMRAI::geom::CartesianPatchGeometry>
                (patch->getPatchGeometry());
              double dx = geom->getDx()[0];
              double dy = geom->getDx()[1];

              for(int j=pbox.lower(1); j<=pbox.upper(1)+1; ++j)
                {
                  /* Do the red-black skip */
                  int i_min=pbox.lower(0) + (abs(pbox.lower(0) + j + rb))%2;
                  for(int i=i_min; i<=pbox.upper(0); i+=2)
                    {
                      SAMRAI::pdat::CellIndex center(SAMRAI::tbox::Dimension(2));
                      center[0]=i;
                      center[1]=j;

                      /* Update v */
                      smooth_V_2D(1,pbox,geom,center,jp,ip,
                                  p,v,v_rhs,maxres,dy,dx,cell_viscosity,
                                  edge_viscosity,theta_momentum);
                    }
                }
            }
          set_boundaries(invalid_id,v_id,level,true);
        }



      /* p sweep
         No need for red-black, because dp does not depend on
         the pressure. */
      xeqScheduleGhostFillNoCoarse(invalid_id,v_id,ln);

      for (SAMRAI::hier::PatchLevel::Iterator pi(level->begin()); pi!=level->end(); ++pi)
        {
          boost::shared_ptr<SAMRAI::hier::Patch> patch = *pi;

          boost::shared_ptr<SAMRAI::pdat::CellData<double> > p_ptr =
            boost::dynamic_pointer_cast<SAMRAI::pdat::CellData<double> >
            (patch->getPatchData(p_id));
          SAMRAI::pdat::CellData<double> &p(*p_ptr);
          boost::shared_ptr<SAMRAI::pdat::CellData<double> > dp_ptr =
            boost::dynamic_pointer_cast<SAMRAI::pdat::CellData<double> >
            (patch->getPatchData(dp_id));
          SAMRAI::pdat::CellData<double> &dp(*dp_ptr);
          boost::shared_ptr<SAMRAI::pdat::CellData<double> > p_rhs_ptr =
            boost::dynamic_pointer_cast<SAMRAI::pdat::CellData<double> >
            (patch->getPatchData(p_rhs_id));
          SAMRAI::pdat::CellData<double> &p_rhs(*p_rhs_ptr);
                
          boost::shared_ptr<SAMRAI::pdat::SideData<double> > v_ptr =
            boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
            (patch->getPatchData(v_id));
          SAMRAI::pdat::SideData<double> &v(*v_ptr);
                
          boost::shared_ptr<SAMRAI::pdat::CellData<double> > cell_visc_ptr =
            boost::dynamic_pointer_cast<SAMRAI::pdat::CellData<double> >
            (patch->getPatchData(cell_viscosity_id));
          SAMRAI::pdat::CellData<double> &cell_viscosity(*cell_visc_ptr);
          boost::shared_ptr<SAMRAI::pdat::NodeData<double> > edge_visc_ptr =
            boost::dynamic_pointer_cast<SAMRAI::pdat::NodeData<double> >
            (patch->getPatchData(edge_viscosity_id));
          SAMRAI::pdat::NodeData<double> &edge_viscosity(*edge_visc_ptr);

          SAMRAI::hier::Box pbox=patch->getBox();
          boost::shared_ptr<SAMRAI::geom::CartesianPatchGeometry> geom =
            boost::dynamic_pointer_cast<SAMRAI::geom::CartesianPatchGeometry>
            (patch->getPatchGeometry());
          double dx = geom->getDx()[0];
          double dy = geom->getDx()[1];

          SAMRAI::pdat::CellIterator cend(SAMRAI::pdat::CellGeometry::end(pbox));
          for(SAMRAI::pdat::CellIterator
                ci(SAMRAI::pdat::CellGeometry::begin(pbox)); ci!=cend; ++ci)
            {
              const SAMRAI::pdat::CellIndex &center(*ci);
              const SAMRAI::pdat::SideIndex
                x(center,0,SAMRAI::pdat::SideIndex::Lower),
                y(center,1,SAMRAI::pdat::SideIndex::Lower);

              /* Update p */
              double dvx_dx=(v(x+ip) - v(x))/dx;
              double dvy_dy=(v(y+jp) - v(y))/dy;

              double delta_R_continuity=
                p_rhs(center) - dvx_dx - dvy_dy;

              /* No scaling here, though there should be. */
              maxres=std::max(maxres,std::fabs(delta_R_continuity));

              dp(center)=delta_R_continuity*theta_continuity
                /Stokes_dRc_dp_2D(pbox,center,x,y,cell_viscosity,edge_viscosity,v,dx,dy);
              p(center)+=dp(center);
            }
        }
      set_boundaries(p_id,invalid_id,level,true);


      /* fix v sweep */
      xeqScheduleGhostFillNoCoarse(dp_id,invalid_id,ln);

      for (SAMRAI::hier::PatchLevel::Iterator pi(level->begin());
           pi!=level->end(); ++pi)
        {
          boost::shared_ptr<SAMRAI::hier::Patch> patch = *pi;

          boost::shared_ptr<SAMRAI::pdat::CellData<double> > dp_ptr =
            boost::dynamic_pointer_cast<SAMRAI::pdat::CellData<double> >
            (patch->getPatchData(dp_id));
          SAMRAI::pdat::CellData<double> &dp(*dp_ptr);
                
          boost::shared_ptr<SAMRAI::pdat::SideData<double> > v_ptr =
            boost::dynamic_pointer_cast<SAMRAI::pdat::SideData<double> >
            (patch->getPatchData(v_id));
          SAMRAI::pdat::SideData<double> &v(*v_ptr);
                
          boost::shared_ptr<SAMRAI::pdat::CellData<double> > cell_visc_ptr =
            boost::dynamic_pointer_cast<SAMRAI::pdat::CellData<double> >
            (patch->getPatchData(cell_viscosity_id));
          SAMRAI::pdat::CellData<double> &cell_viscosity(*cell_visc_ptr);
          boost::shared_ptr<SAMRAI::pdat::NodeData<double> > edge_visc_ptr =
            boost::dynamic_pointer_cast<SAMRAI::pdat::NodeData<double> >
            (patch->getPatchData(edge_viscosity_id));
          SAMRAI::pdat::NodeData<double> &edge_viscosity(*edge_visc_ptr);

          SAMRAI::hier::Box pbox=patch->getBox();
          boost::shared_ptr<SAMRAI::geom::CartesianPatchGeometry> geom =
            boost::dynamic_pointer_cast<SAMRAI::geom::CartesianPatchGeometry>
            (patch->getPatchGeometry());
          double dx = geom->getDx()[0];
          double dy = geom->getDx()[1];

          pbox.growUpper(SAMRAI::hier::IntVector::getOne(d_dim));

          SAMRAI::pdat::CellIterator cend(SAMRAI::pdat::CellGeometry::end(pbox));
          for(SAMRAI::pdat::CellIterator
                ci(SAMRAI::pdat::CellGeometry::begin(pbox)); ci!=cend; ++ci)
            {
              const SAMRAI::pdat::CellIndex &center(*ci);

              const SAMRAI::pdat::SideIndex
                x(center,0,SAMRAI::pdat::SideIndex::Lower),
                y(center,1,SAMRAI::pdat::SideIndex::Lower);
              const SAMRAI::pdat::NodeIndex
                edge(center,SAMRAI::pdat::NodeIndex::LowerLeft);

              /* Update v */
              if(center[1]<pbox.upper(1))
                {
                  if(!((center[0]==pbox.lower(0) && v(x-ip)==boundary_value)
                       || (center[0]==pbox.upper(0)
                           && v(x+ip)==boundary_value)))
                    v(x)+=(dp(center) - dp(center-ip))
                      /(dx*Stokes_dRm_dv_2D(cell_viscosity,edge_viscosity,center,
                                             center-ip,edge+jp,edge,dx,dy));
                }
              if(center[0]<pbox.upper(0))
                {
                  if(!((center[1]==pbox.lower(1) && v(y-jp)==boundary_value)
                       || (center[1]==pbox.upper(1)
                           && v(y+jp)==boundary_value)))
                    v(y)+=(dp(center) - dp(center-jp))
                      /(dy*Stokes_dRm_dv_2D(cell_viscosity,edge_viscosity,center,
                                             center-jp,edge+ip,edge,dy,dx));
                }
            }
        }
      set_boundaries(invalid_id,v_id,level,true);

      // if (residual_tolerance >= 0.0) {
      /*
       * Check for early end of sweeps due to convergence
       * only if it is numerically possible (user gave a
       * non negative value for residual tolerance).
       */
      converged = maxres < residual_tolerance;
      const SAMRAI::tbox::SAMRAI_MPI& mpi(d_hierarchy->getMPI());
      int tmp= converged ? 1 : 0;
      if (mpi.getSize() > 1)
        {
          mpi.AllReduce(&tmp, 1, MPI_MIN);
        }
      converged=(tmp==1);
      // if (d_enable_logging)
      //   SAMRAI::tbox::plog
      //     // << d_object_name << "\n"
      //     << "Tackley  " << ln << " " << sweep << " : " << maxres << "\n";
      // }
    }
}
Example #11
0
double degToRad(double deg) {
    return deg / 180.0 * pi();
}
Example #12
0
//-*****************************************************************************
Abc::Box3d PolyMesh::writeSample( const Abc::OSampleSelector &iSS )
{
    // First, call base class sample write, which will return bounds
    // of any children.
    Abc::index_t sampleIndex = iSS.getIndex();
    Abc::Box3d bounds = Exportable::writeSample( iSS );

    // If we're not deforming, don't bother with new sample.
    // Do calculate bounds and set them, though.
    if ( sampleIndex != 0 && !m_deforming )
    {
        bounds.extendBy( m_firstSampleSelfBounds );
        m_boundsProperty.set( bounds, iSS );
        return bounds;
    }

    // Make a mesh
    MStatus status;
    MFnMesh mesh( m_dagPath, &status );
    CHECK_MAYA_STATUS;
    mesh.updateSurface();
    mesh.syncObject();

    // Make a sample.
    Abc::OPolyMeshSchema::Sample abcPolyMeshSample;

    //-*************************************************************************
    // WRITE VERTICES
    //-*************************************************************************
    MPointArray vertices;
    mesh.getPoints( vertices );
    size_t npoints = vertices.length();
    std::vector<Abc::V3f> v3fVerts( npoints );

    Abc::Box3d shapeBounds;
    shapeBounds.makeEmpty();
    for ( size_t i = 0; i < npoints; ++i )
    {
        const MPoint &vi = vertices[i];
        Abc::V3f pi( vi.x, vi.y, vi.z );
        v3fVerts[i] = pi;
        shapeBounds.extendBy( Abc::V3d( vi.x, vi.y, vi.z ) );
    }
    if ( sampleIndex == 0 )
    {
        m_firstSampleSelfBounds = shapeBounds;
    }
    bounds.extendBy( shapeBounds );

    // Set the bounds sample.
    m_boundsProperty.set( bounds, iSS );

    // Stuff the positions into the mesh sample.
    abcPolyMeshSample.setPositions( Abc::V3fArraySample( v3fVerts ) );

    //-*************************************************************************
    // OTHER STUFF, FOR FIRST OR LATER VERTICES
    //-*************************************************************************
    std::vector<Abc::int32_t> abcIndices;
    std::vector<Abc::int32_t> abcCounts;
    std::vector<Abc::N3f> abcNormals;
    std::vector<Abc::V2f> abcUvs;

    //-*************************************************************************
    // GET MESH NORMALS & UVS
    //-*************************************************************************
    size_t nnormals = mesh.numNormals();
    MFloatVectorArray meshNorms;
    if ( nnormals > 0 )
    {
        mesh.getNormals( meshNorms, MSpace::kObject );
    }
    
    size_t nuvs = mesh.numUVs();
    MFloatArray meshU;
    MFloatArray meshV;
    if ( nuvs > 0 )
    {
        mesh.getUVs( meshU, meshV );
    }

    //-*************************************************************************
    // LOOP OVER FIRST OR SUBSEQUENT SAMPLES
    //-*************************************************************************
    if ( sampleIndex == 0 )
    {
        // FIRST SAMPLE

        // Loop over polys.
        size_t npolys = mesh.numPolygons();
        abcCounts.resize( npolys );

        Abc::int32_t faceIndex = 0;
        Abc::int32_t faceStartVertexIndex = 0;

        for ( MItMeshPolygon piter( m_dagPath );
              !piter.isDone(); piter.next(), ++faceIndex )
        {
            Abc::int32_t faceCount = piter.polygonVertexCount();
            abcCounts[faceIndex] = faceCount;
            faceStartVertexIndex += faceCount;

            for ( Abc::int32_t faceVertex = 0;
                  faceVertex < faceCount; ++faceVertex )
            {
                abcIndices.push_back( piter.vertexIndex( faceVertex ) );

                if ( nnormals > 0 )
                {
                    size_t normIndex = piter.normalIndex( faceVertex );
                    const MFloatVector &norm = meshNorms[normIndex];
                    Abc::N3f abcNorm( norm[0], norm[1], norm[2] );
                    abcNormals.push_back( abcNorm );
                }

                if ( nuvs > 0 )
                {
                    int uvIndex = 0;
                    piter.getUVIndex( faceVertex, uvIndex );
                    Abc::V2f abcUv( meshU[uvIndex], meshV[uvIndex] );
                    abcUvs.push_back( abcUv );
                }
            }
        }

        // We have now collected abcIndices, abcStarts, abcNormals, and abcUvs.
        // Put them into the sample.
        abcPolyMeshSample.setIndices( Abc::Int32ArraySample( abcIndices ) );
        abcPolyMeshSample.setCounts( Abc::Int32ArraySample( abcCounts ) );

        if ( nnormals > 0 && m_normals )
        {
            m_normals.set( Abc::N3fArraySample( abcNormals ), iSS );
        }
        if ( nuvs > 0 && m_sts )
        {
            m_sts.set( Abc::V2fArraySample( abcUvs ), iSS );
        }
    }
    else if ( ( nnormals > 0 && m_normals ) ||
              ( nuvs > 0 && m_sts ) )
    {
        // SUBSEQUENT SAMPLES
        // Just gathering normals and uvs.
        // (vertices handled above)
        
        // Loop over polys.
        Abc::int32_t faceIndex = 0;
        Abc::int32_t faceStartVertexIndex = 0;
        
        for ( MItMeshPolygon piter( m_dagPath );
              !piter.isDone(); piter.next(), ++faceIndex )
        {
            Abc::int32_t faceCount = piter.polygonVertexCount();
            for ( Abc::int32_t faceVertex = 0;
                  faceVertex < faceCount; ++faceVertex )
            {
                if ( nnormals > 0 )
                {
                    size_t normIndex = piter.normalIndex( faceVertex );
                    const MFloatVector &norm = meshNorms[normIndex];
                    Abc::N3f abcNorm( norm[0], norm[1], norm[2] );
                    abcNormals.push_back( abcNorm );
                }
                
                if ( nuvs > 0 )
                {
                    int uvIndex = 0;
                    piter.getUVIndex( faceVertex, uvIndex );
                    Abc::V2f abcUv( meshU[uvIndex], meshV[uvIndex] );
                    abcUvs.push_back( abcUv );
                }
            }
        }

        // We have now collected abcNormals, and abcUvs.
        // Put them into the sample.
        if ( nnormals > 0 && m_normals )
        {
            m_normals.set( Abc::N3fArraySample( abcNormals ), iSS );
        }
        if ( nuvs > 0 )
        {
            m_sts.set( Abc::V2fArraySample( abcUvs ), iSS );
        }
    }

    // Set the mesh sample.
    m_polyMesh.getSchema().set( abcPolyMeshSample, iSS );

    return bounds;
}
Example #13
0
 /**
  * Factor to convert from degrees to radians
  **********************************************************************/
 static inline double degree() throw() { return pi() / 180; }
Example #14
0
void IPCUninstallMcf::onProgress(uint64& prog)
{
	MCFCore::Misc::ProgressInfo pi(prog);
	onProgressEvent(pi);
}
bool PCB_EDIT_FRAME::AppendBoardFile( const wxString& aFullFileName, int aCtl )
{
    IO_MGR::PCB_FILE_T  pluginType = plugin_type( aFullFileName, aCtl );
    PLUGIN::RELEASER pi( IO_MGR::PluginFind( pluginType ) );

    // keep trace of existing items, in order to know what are the new items
    // (for undo command for instance)

    // Tracks are inserted, not append, so mark existing tracks to know what are
    // the new tracks
    for( TRACK* track = GetBoard()->m_Track; track; track = track->Next() )
        track->SetFlags( FLAG0 );

    // Other items are append to the item list, so keep trace to the
    // last existing item is enough
    MODULE* module = GetBoard()->m_Modules.GetLast();
    BOARD_ITEM* drawing = GetBoard()->m_Drawings.GetLast();
    int zonescount = GetBoard()->GetAreaCount();

    // Keep also the count of copper layers, because we can happen boards
    // with different copper layers counts,
    // and the enabled layers
    int initialCopperLayerCount = GetBoard()->GetCopperLayerCount();
    LSET initialEnabledLayers = GetBoard()->GetEnabledLayers();

    try
    {
        PROPERTIES  props;
        char        xbuf[30];
        char        ybuf[30];

        // EAGLE_PLUGIN can use this info to center the BOARD, but it does not yet.
        sprintf( xbuf, "%d", GetPageSizeIU().x );
        sprintf( ybuf, "%d", GetPageSizeIU().y );

        props["page_width"]  = xbuf;
        props["page_height"] = ybuf;

        GetDesignSettings().m_NetClasses.Clear();
        pi->Load( aFullFileName, GetBoard(), &props );
    }
    catch( const IO_ERROR& ioe )
    {
        for( TRACK* track = GetBoard()->m_Track; track; track = track->Next() )
            track->ClearFlags( FLAG0 );

        wxString msg = wxString::Format( _(
                "Error loading board.\n%s" ),
                GetChars( ioe.errorText )
                );
        DisplayError( this, msg );

        return false;
    }

    // Now prepare a block move command to place the new items, and
    // prepare the undo command.
    BLOCK_SELECTOR& blockmove = GetScreen()->m_BlockLocate;
    HandleBlockBegin( NULL, BLOCK_PRESELECT_MOVE, wxPoint( 0, 0) );
    PICKED_ITEMS_LIST& blockitemsList = blockmove.GetItems();
    PICKED_ITEMS_LIST undoListPicker;
    ITEM_PICKER picker( NULL, UR_NEW );

    EDA_RECT bbox;          // the new items bounding box, for block move
    bool bboxInit = true;   // true until the bounding box is initialized

    for( TRACK* track = GetBoard()->m_Track; track; track = track->Next() )
    {
        if( track->GetFlags() & FLAG0  )
        {
            track->ClearFlags( FLAG0 );
            continue;
        }

        track->SetFlags( IS_MOVED );
        picker.SetItem( track );
        undoListPicker.PushItem( picker );
        blockitemsList.PushItem( picker );

        if( bboxInit )
            bbox = track->GetBoundingBox();
        else
            bbox.Merge( track->GetBoundingBox() );

        bboxInit = false;
    }

    if( module )
        module = module->Next();
    else
        module = GetBoard()->m_Modules;

    for( ; module; module = module->Next() )
    {
        module->SetFlags( IS_MOVED );
        picker.SetItem( module );
        undoListPicker.PushItem( picker );
        blockitemsList.PushItem( picker );

        if( bboxInit )
            bbox = module->GetBoundingBox();
        else
            bbox.Merge( module->GetBoundingBox() );

        bboxInit = false;
    }

    if( drawing )
        drawing = drawing->Next();
    else
        drawing = GetBoard()->m_Drawings;

    for( ; drawing; drawing = drawing->Next() )
    {
        drawing->SetFlags( IS_MOVED );
        picker.SetItem( drawing );
        undoListPicker.PushItem( picker );
        blockitemsList.PushItem( picker );

        if( bboxInit )
            bbox = drawing->GetBoundingBox();
        else
            bbox.Merge( drawing->GetBoundingBox() );

        bboxInit = false;
    }

    for( ZONE_CONTAINER* zone = GetBoard()->GetArea( zonescount ); zone;
         zone = GetBoard()->GetArea( zonescount ) )
    {
        zone->SetFlags( IS_MOVED );
        picker.SetItem( zone );
        undoListPicker.PushItem( picker );
        blockitemsList.PushItem( picker );
        zonescount++;

        if( bboxInit )
            bbox = zone->GetBoundingBox();
        else
            bbox.Merge( zone->GetBoundingBox() );

        bboxInit = false;
    }

    SaveCopyInUndoList( undoListPicker, UR_NEW );

    // we should not ask PLUGINs to do these items:
    int copperLayerCount = GetBoard()->GetCopperLayerCount();

    if( copperLayerCount > initialCopperLayerCount )
        GetBoard()->SetCopperLayerCount( copperLayerCount );

    // Enable all used layers, and make them visible:
    LSET enabledLayers = GetBoard()->GetEnabledLayers();
    enabledLayers |= initialEnabledLayers;
    GetBoard()->SetEnabledLayers( enabledLayers );
    GetBoard()->SetVisibleLayers( enabledLayers );
    ReCreateLayerBox();
    ReFillLayerWidget();

    if( IsGalCanvasActive() )
        static_cast<PCB_DRAW_PANEL_GAL*>( GetGalCanvas() )->SyncLayersVisibility( GetBoard() );

    GetBoard()->BuildListOfNets();
    GetBoard()->SynchronizeNetsAndNetClasses();

    SetStatusText( wxEmptyString );
    BestZoom();

    // Finish block move command:
    wxPoint cpos = GetNearestGridPosition( bbox.Centre() );
    blockmove.SetOrigin( bbox.GetOrigin() );
    blockmove.SetSize( bbox.GetSize() );
    blockmove.SetLastCursorPosition( cpos );
    HandleBlockEnd( NULL );

    return true;
}
Example #16
0
EVP_PKEY *pki_evp::decryptKey() const
{
	unsigned char *p;
	const unsigned char *p1;
	int outl, decsize;
	unsigned char iv[EVP_MAX_IV_LENGTH];
	unsigned char ckey[EVP_MAX_KEY_LENGTH];

	EVP_PKEY *tmpkey;
	EVP_CIPHER_CTX ctx;
	const EVP_CIPHER *cipher = EVP_des_ede3_cbc();
	char ownPassBuf[MAX_PASS_LENGTH] = "";

	if (isPubKey()) {
		unsigned char *q;
		outl = i2d_PUBKEY(key, NULL);
		p = q = (unsigned char *)OPENSSL_malloc(outl);
		check_oom(q);
		i2d_PUBKEY(key, &p);
		p = q;
		tmpkey = d2i_PUBKEY(NULL, (const unsigned char**)&p, outl);
		OPENSSL_free(q);
		return tmpkey;
	}
	/* This key has its own password */
	if (ownPass == ptPrivate) {
		int ret;
		pass_info pi(XCA_TITLE, qApp->translate("MainWindow",
			"Please enter the password to decrypt the private key: '%1'").arg(getIntName()));
		ret = MainWindow::passRead(ownPassBuf, MAX_PASS_LENGTH, 0, &pi);
		if (ret < 0)
			throw errorEx(tr("Password input aborted"), class_name);
	} else if (ownPass == ptBogus) { // BOGUS pass
		ownPassBuf[0] = '\0';
	} else {
		memcpy(ownPassBuf, passwd, MAX_PASS_LENGTH);
		//printf("Orig password: '%s' len:%d\n", passwd, strlen(passwd));
		while (md5passwd(ownPassBuf) != passHash &&
			sha512passwd(ownPassBuf, passHash) != passHash)
		{
			int ret;
			//printf("Passhash= '%s', new hash= '%s', passwd= '%s'\n",
				//CCHAR(passHash), CCHAR(md5passwd(ownPassBuf)), ownPassBuf);
			pass_info p(XCA_TITLE, tr("Please enter the database password for decrypting the key '%1'").arg(getIntName()));
			ret = MainWindow::passRead(ownPassBuf, MAX_PASS_LENGTH, 0, &p);
			if (ret < 0)
				throw errorEx(tr("Password input aborted"), class_name);
		}
	}
	//printf("Using decrypt Pass: %s\n", ownPassBuf);
	p = (unsigned char *)OPENSSL_malloc(encKey.count());
	check_oom(p);
	pki_openssl_error();
	p1 = p;
	memset(iv, 0, EVP_MAX_IV_LENGTH);

	memcpy(iv, encKey.constData(), 8); /* recover the iv */
	/* generate the key */
	EVP_BytesToKey(cipher, EVP_sha1(), iv, (unsigned char *)ownPassBuf,
		strlen(ownPassBuf), 1, ckey,NULL);
	/* we use sha1 as message digest,
	 * because an md5 version of the password is
	 * stored in the database...
	 */
	EVP_CIPHER_CTX_init(&ctx);
	EVP_DecryptInit(&ctx, cipher, ckey, iv);
	EVP_DecryptUpdate(&ctx, p , &outl,
		(const unsigned char*)encKey.constData() +8, encKey.count() -8);

	decsize = outl;
	EVP_DecryptFinal(&ctx, p + decsize , &outl);
	decsize += outl;
	//printf("Decrypt decsize=%d, encKey_len=%d\n", decsize, encKey_len);
	pki_openssl_error();
	tmpkey = d2i_PrivateKey(key->type, NULL, &p1, decsize);
	pki_openssl_error();
	OPENSSL_free(p);
	EVP_CIPHER_CTX_cleanup(&ctx);
	pki_openssl_error();
	if (EVP_PKEY_type(tmpkey->type) == EVP_PKEY_RSA)
		RSA_blinding_on(tmpkey->pkey.rsa, NULL);
	return tmpkey;
}
Example #17
0
HANDLE	WINAPI	EXP_NAME(OpenPlugin)(int OpenFrom, INT_PTR Item) {
//	Options.Read();

	AutoUTF	cline;
	if (OpenFrom == OPEN_PLUGINSMENU) {
		FarPnl	pi(PANEL_ACTIVE);
		if (pi.IsOK()) {
			AutoUTF	buf(MAX_PATH_LEN, L'\0');
			fsf.GetCurrentDirectory(buf.capacity(), (PWSTR)buf.c_str());
			if (!buf.empty())
				::PathAddBackslash((PWSTR)buf.c_str());

			PluginPanelItem &PPI = pi[pi.CurrentItem()];
			buf += PPI.FindData.lpwszFileName;
			cline = buf;
		}
	} else if (OpenFrom == OPEN_COMMANDLINE) {
		cline = (PCWSTR)Item;
	}
	FarList	users;
	if (InitUsers(users)) {
		enum {
			HEIGHT = 14,
			WIDTH = 48,
		};
		InitDialogItemF	Items[] = {
			{DI_DOUBLEBOX, 3, 1, WIDTH - 4, HEIGHT - 2, 0, (PCWSTR)DlgTitle},
			{DI_TEXT,      5, 2, 0,  0,  0, (PCWSTR)MUsername},
			{DI_COMBOBOX,  5, 3, 42, 0,  DIF_SELECTONENTRY, L""},
			{DI_TEXT,      5, 4, 0,  0,  0, (PCWSTR)MPasword},
			{DI_PSWEDIT,   5, 5, 42, 0,  0, L""},
			{DI_CHECKBOX , 5, 6, 42, 0,  0, (PCWSTR)MRestricted},
			{DI_TEXT,      0, 7, 0,  0,  DIF_SEPARATOR, L""},
			{DI_TEXT,      5, 8, 0,  0,  0, (PCWSTR)MCommandLine},
			{DI_EDIT,      5, 9, 42, 0,  DIF_HISTORY, cline.c_str()},
			{DI_TEXT,      0,  HEIGHT - 4, 0,  0,  DIF_SEPARATOR,   L""},
			{DI_BUTTON,    0,  HEIGHT - 3, 0,  0,  DIF_CENTERGROUP, (PCWSTR)txtBtnOk},
			{DI_BUTTON,    0,  HEIGHT - 3, 0,  0,  DIF_CENTERGROUP, (PCWSTR)txtBtnCancel},
		};
		size_t	size = sizeofa(Items);
		FarDialogItem FarItems[size];
		InitDialogItemsF(Items, FarItems, size);
		FarItems[size - 2].DefaultButton = 1;
		FarItems[2].ListItems = &users;
		FarItems[8].History = L"runas.comline";

		FarDlg hDlg;
		if (hDlg.Init(psi.ModuleNumber, -1, -1, WIDTH, HEIGHT, L"Contents", FarItems, size)) {
			HRESULT	err = NO_ERROR;
			while (true) {
				int		ret = hDlg.Run();
				if (ret > 0 && Items[ret].Data == (PCWSTR)txtBtnOk) {
					AutoUTF	cmd(hDlg.Str(8));
					if (hDlg.Check(5)) {
						err = ExecRestricted(cmd.c_str());
					} else {
						AutoUTF	user(hDlg.Str(2));
						AutoUTF	pass(hDlg.Str(4));
						err = ExecAsUser(cmd.c_str(), user.c_str(), pass.c_str());
					}
					if (err == NO_ERROR) {
						break;
					} else {
						PCWSTR Msg[] = {GetMsg(MError), cmd.c_str(), L"", GetMsg(txtBtnOk), };
						::SetLastError(err);
						psi.Message(psi.ModuleNumber, FMSG_WARNING | FMSG_ERRORTYPE,
									L"Contents", Msg, sizeofa(Msg), 1);
					}
				} else {
					break;
				}
			}
		}
		FreeUsers(users);
	}
	return	INVALID_HANDLE_VALUE;
}
void CircleObject::setObjectArea(qreal area)
{
    qreal radius = qSqrt(area/pi());
    setObjectRadius(radius);
}
Example #19
0
const double Gaussian1D::width() const
{
    return sqrt(2.0 * pi()) * bandwidth_;
}
void CircleObject::setObjectCircumference(qreal circumference)
{
    qreal diameter = circumference/pi();
    setObjectDiameter(diameter);
}
Example #21
0
const double Gaussian::volume(const unsigned& d) const
{
    return pow(sqrt(2.0 * pi()) * bandwidth_, (double)d);
}
Example #22
0
//
// This method is currently under development
//
lbool Logic::simplifyTree(PTRef tr)
{
    vec<pi> queue;
    Map<PTRef,bool,PTRefHash> processed;
    queue.push(pi(tr));
    lbool last_val = l_Undef;
    while (queue.size() != 0) {
        // First find a node with all children processed.
        int i = queue.size()-1;
        if (processed.contains(queue[i].x)) {
            queue.pop();
            continue;
        }
        bool unprocessed_children = false;
        if (queue[i].done == false) {
#ifdef SIMPLIFY_DEBUG
            cerr << "looking at term num " << queue[i].x.x << endl;
#endif
            Pterm& t = getPterm(queue[i].x);
            for (int j = 0; j < t.size(); j++) {
                PTRef cr = t[j];
                if (!processed.contains(cr)) {
                    unprocessed_children = true;
                    queue.push(pi(cr));
#ifdef SIMPLIFY_DEBUG
                    cerr << "pushing child " << cr.x << endl;
#endif
                }
            }
            queue[i].done = true;
        }
        if (unprocessed_children) continue;
#ifdef SIMPLIFY_DEBUG
        cerr << "Found a node " << queue[i].x.x << endl;
        cerr << "Before simplification it looks like " << term_store.printTerm(queue[i].x) << endl;
#endif
        // (1) Check if my children (potentially simplified now) exist in
        //     term store and if so, replace them with the term store
        //     representative
        // (2) Simplify in place
        // (3) See if the simplifications resulted in me changing, and if so,
        //     look up from the table whether I'm already listed somewhere and add
        //     a mapping to the canonical representative, or create a new entry for
        //     me in the map.
        Pterm& t = getPterm(queue[i].x);
        // (1)
#ifdef SIMPLIFY_DEBUG
        if (t.size() > 0)
            cerr << "Now looking into the children of " << queue[i].x.x << endl;
        else
            cerr << "The node " << queue[i].x.x << " has no children" << endl;
#endif
        for (int e = 0; e < t.size(); e++) {
            PTRef cr = t[e];
#ifdef SIMPLIFY_DEBUG
            cerr << "child n. " << e << " is " << cr.x << endl;
#endif
            assert(cr != queue[i].x);
            Pterm& c = getPterm(cr);
            PTLKey k;
            k.sym = c.symb();
            for (int j = 0; j < c.size(); j++)
                k.args.push(c[j]);
            if (!isBooleanOperator(k.sym)) {
                assert(term_store.cplx_map.contains(k));
#ifdef SIMPLIFY_DEBUG
                cerr << cr.x << " is not a boolean operator ";
                cerr << "and it maps to " << term_store.cplx_map[k].x << endl;
#endif
                t[e] = term_store.cplx_map[k];
                assert(t[e] != queue[i].x);
            } else {
                assert(term_store.bool_map.contains(k));
#ifdef SIMPLIFY_DEBUG
                cerr << cr.x << " is a boolean operator"
                     << " and it maps to " << term_store.bool_map[k].x << endl;
#endif
                t[e] = term_store.bool_map[k];
                assert(t[e] != queue[i].x);
            }
        }
#ifdef SIMPLIFY_DEBUG
        cerr << "After processing the children ended up with node " << term_store.printTerm(queue[i].x, true) << endl;
#endif
        // (2) Simplify in place
        PTRef orig = queue[i].x; // We need to save the original type in case the term gets simplified
        simplify(queue[i].x);
#ifdef SIMPLIFY_DEBUG
        cerr << "-> which was now simplified to " << term_store.printTerm(queue[i].x, true) << endl;
//      I don't seem to remember why this should be true or false?
//        if (orig != queue[i].x) {
//            assert(isTrue(queue[i].x) || isFalse(queue[i].x));
//            assert(isAnd(orig) || isOr(orig) || isEquality(orig) || isNot(orig));
//        }
#endif
        processed.insert(orig, true);
        // Make sure my key is in term hash
#ifdef SIMPLIFY_DEBUG
        cerr << "Making sure " << orig.x << " is in term_store hash" << endl;
        cerr << "Pushing symb " << t.symb().x << " to hash key" << endl;
#endif
        PTLKey k;
        k.sym = t.symb();
        for (int j = 0; j < t.size(); j++) {
#ifdef SIMPLIFY_DEBUG
            cerr << "Pushing arg " << t[j].x << " to hash key" << endl;
#endif
            k.args.push(t[j]);
        }
        if (!isBooleanOperator(k.sym)) {
            if (!term_store.cplx_map.contains(k)) {
                term_store.cplx_map.insert(k, queue[i].x);
#ifdef SIMPLIFY_DEBUG
                cerr << "sym " << k.sym.x << " args <";
                for (int j = 0; j < k.args.size(); j++) {
                    cerr << k.args[j].x << " ";
                }
                cerr << "> maps to " << term_store.cplx_map[k].x << endl;
#endif
            }
            PTRef l = term_store.cplx_map[k];
            // This is being kept on record in case the root term gets simplified
            if (isTrue(l)) last_val = l_True;
            else if (isFalse(l)) last_val = l_False;
            else last_val = l_Undef;
        } else {
            if (!term_store.bool_map.contains(k)) {
                term_store.bool_map.insert(k, queue[i].x);
#ifdef SIMPLIFY_DEBUG
                cerr << "sym " << k.sym.x << " args ";
                for (int j = 0; j < k.args.size(); j++) {
                    cerr << k.args[j].x << " ";
                }
                cerr << "maps to " << term_store.bool_map[k].x << endl;
#endif
            }
            PTRef l = term_store.bool_map[k];
            // This is being kept on record in case the root term gets simplified
            if (isTrue(l)) last_val = l_True;
            else if (isFalse(l)) last_val = l_False;
            else last_val = l_Undef;
        }
        queue.pop();
    }
    return last_val;
}
/**
 *	Builds a list of commands for the right click on Editor Chunk Item operation.
 *
 *	@return Returns the list of commands.
 */
std::vector<std::string> PropertiesHelper::command()
{
	propMap_.clear();

	std::vector<std::string> links;
	int index = 0;
	for (int i=0; i < propCount(); i++)
	{
		DataDescription* pDD = pType()->property( i );
		if (!pDD->editable())
			continue;

		if ( isUserDataObjectLink(i) )
		{
			PyObjectPtr ob( propGetPy( i ), PyObjectPtr::STEAL_REFERENCE );
			
			std::string uniqueId = PyString_AsString( PyTuple_GetItem( ob.getObject(), 0 ) );
			if ( !uniqueId.empty() )
			{
				links.push_back( "#"+propName(i) );
				links.push_back( "#"+uniqueId );
				links.push_back( "Delete Link" );
				propMap_[index++] = PropertyIndex( i );
				links.push_back( "##" );
				links.push_back( "##" );
			}
		}
		else if ( isUserDataObjectLinkArray(i) )
		{
			PyObjectPtr ob( propGetPy( i ), PyObjectPtr::STEAL_REFERENCE );

			SequenceDataType* dataType =
				static_cast<SequenceDataType*>( pDD->dataType() );
			ArrayPropertiesHelper propArray;
			propArray.init( pItem(), &(dataType->getElemType()), ob.getObject());

			int numProps = propArray.propCount();
			if ( numProps > 0 )
			{
				links.push_back( "#"+propName(i) );
				links.push_back( "Delete All" );
				propMap_[index++] = PropertyIndex( i );
				links.push_back( "" );
				// Iterate through the array of links
				for(int j = 0; j < numProps; j++)
				{
					PyObjectPtr link( propArray.propGetPy( j ), PyObjectPtr::STEAL_REFERENCE );
					std::string uniqueId = PyString_AsString( PyTuple_GetItem( link.getObject(), 0 ) );
					if ( !uniqueId.empty() )
					{
						links.push_back( "#"+uniqueId );
						links.push_back( "Delete Link" );
						PropertyIndex pi( i );
						pi.append( j );
						propMap_[index++] = pi;
						links.push_back( "##" );
					}
				}
				links.push_back( "##" );
			}
		}
	}	
	return links;
}
void LIB_EDIT_FRAME::OnExportPart( wxCommandEvent& event )
{
    wxString msg, title;
    LIB_PART* part = getTargetPart();

    if( !part )
    {
        DisplayError( this, _( "There is no symbol selected to save." ) );
        return;
    }

    wxFileName fn;

    fn.SetName( part->GetName().Lower() );
    fn.SetExt( SchematicLibraryFileExtension );

    wxFileDialog dlg( this, _( "Export Symbol" ), m_mruPath, fn.GetFullName(),
                      SchematicLibraryFileWildcard(), wxFD_SAVE );

    if( dlg.ShowModal() == wxID_CANCEL )
        return;

    fn = dlg.GetPath();
    fn.MakeAbsolute();

    LIB_PART* old_part = NULL;

    SCH_PLUGIN::SCH_PLUGIN_RELEASER pi( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_LEGACY ) );

    if( fn.FileExists() )
    {
        try
        {
            LIB_ALIAS* alias = pi->LoadSymbol( fn.GetFullPath(), part->GetName() );

            if( alias )
                old_part = alias->GetPart();
        }
        catch( const IO_ERROR& ioe )
        {
            msg.Printf( _( "Error occurred attempting to load symbol library file \"%s\"" ),
                        fn.GetFullPath() );
            DisplayErrorMessage( this, msg, ioe.What() );
            return;
        }

        if( old_part )
        {
            msg.Printf( _( "Symbol \"%s\" already exists in \"%s\"." ),
                        part->GetName(),
                        fn.GetFullName() );

            KIDIALOG errorDlg( this, msg, _( "Confirmation" ), wxOK | wxCANCEL | wxICON_WARNING );
            errorDlg.SetOKLabel( _( "Overwrite" ) );
            errorDlg.DoNotShowCheckbox( __FILE__, __LINE__ );

            if( errorDlg.ShowModal() == wxID_CANCEL )
                return;
        }
    }

    if( fn.Exists() && !fn.IsDirWritable() )
    {
        msg.Printf( _( "Write permissions are required to save library \"%s\"." ), fn.GetFullPath() );
        DisplayError( this, msg );
        return;
    }

    try
    {
        if( !fn.FileExists() )
            pi->CreateSymbolLib( fn.GetFullPath() );

        pi->SaveSymbol( fn.GetFullPath(), new LIB_PART( *part ) );
    }
    catch( const IO_ERROR& ioe )
    {
        msg = _( "Failed to create symbol library file " ) + fn.GetFullPath();
        DisplayErrorMessage( this, msg, ioe.What() );
        msg.Printf( _( "Error creating symbol library \"%s\"" ), fn.GetFullName() );
        SetStatusText( msg );
        return;
    }

    m_mruPath = fn.GetPath();
    m_lastDrawItem = NULL;
    SetDrawItem( NULL );

    msg.Printf( _( "Symbol \"%s\" saved in library \"%s\"" ), part->GetName(), fn.GetFullPath() );
    SetStatusText( msg );

    // See if the user wants it added to a library table (global or project)
    SYMBOL_LIB_TABLE* libTable = selectSymLibTable( true );

    if( libTable )
    {
        if( !m_libMgr->AddLibrary( fn.GetFullPath(), libTable ) )
        {
            DisplayError( this, _( "Could not open the library file." ) );
            return;
        }

        bool globalTable = ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() );
        saveSymbolLibTables( globalTable, !globalTable );
    }
}
Example #25
0
void s1::fun2()
{
	pi();
	
	printf("%s \n", "儿子1fun2函数");
}
Example #26
0
void PrintFiles(FileList* SrcPanel)
{
	_ALGO(CleverSysLog clv(L"Alt-F5 (PrintFiles)"));
	string strPrinterName;
	DWORD Needed = 0, Returned;
	DWORD FileAttr;
	string strSelName;
	size_t DirsCount=0;
	size_t SelCount=SrcPanel->GetSelCount();

	if (!SelCount)
	{
		_ALGO(SysLog(L"Error: !SelCount"));
		return;
	}

	// проверка каталогов
	_ALGO(SysLog(L"Check for FILE_ATTRIBUTE_DIRECTORY"));
	SrcPanel->GetSelName(nullptr,FileAttr);

	while (SrcPanel->GetSelName(&strSelName,FileAttr))
	{
		if (TestParentFolderName(strSelName) || (FileAttr & FILE_ATTRIBUTE_DIRECTORY))
			DirsCount++;
	}

	if (DirsCount==SelCount)
		return;

	EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, nullptr, PRINTER_INFO_LEVEL, nullptr, 0, &Needed, &Returned);

	if (!Needed)
		return;

	block_ptr<PRINTER_INFO> pi(Needed);

	if (!EnumPrinters(PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS,nullptr,PRINTER_INFO_LEVEL,(LPBYTE)pi.get(),Needed,&Needed,&Returned))
	{
		Global->CatchError();
		Message(MSG_WARNING|MSG_ERRORTYPE,1,MSG(MPrintTitle),MSG(MCannotEnumeratePrinters),MSG(MOk));
		return;
	}

	{
		_ALGO(CleverSysLog clv2(L"Show Menu"));
		LangString strTitle;
		string strName;

		if (SelCount==1)
		{
			SrcPanel->GetSelName(nullptr,FileAttr);
			SrcPanel->GetSelName(&strName,FileAttr);
			strSelName = TruncStr(strName,50);
			strTitle = MPrintTo;
			strTitle << InsertQuote(strSelName);
		}
		else
		{
			_ALGO(SysLog(L"Correct: SelCount-=DirsCount"));
			SelCount-=DirsCount;
			strTitle = MPrintFilesTo;
			strTitle << SelCount;
		}

		VMenu2 PrinterList(strTitle,nullptr,0,ScrY-4);
		PrinterList.SetFlags(VMENU_WRAPMODE|VMENU_SHOWAMPERSAND);
		PrinterList.SetPosition(-1,-1,0,0);
		AddToPrintersMenu(&PrinterList,pi.get(),Returned);

		if (PrinterList.Run()<0)
		{
			_ALGO(SysLog(L"ESC"));
			return;
		}

		strPrinterName = NullToEmpty(static_cast<const wchar_t*>(PrinterList.GetUserData(nullptr, 0)));
	}

	HANDLE hPrinter;

	if (!OpenPrinter(UNSAFE_CSTR(strPrinterName), &hPrinter,nullptr))
	{
		Global->CatchError();
		Message(MSG_WARNING|MSG_ERRORTYPE,1,MSG(MPrintTitle),MSG(MCannotOpenPrinter),
		        strPrinterName.data(),MSG(MOk));
		_ALGO(SysLog(L"Error: Cannot Open Printer"));
		return;
	}

	{
		_ALGO(CleverSysLog clv3(L"Print selected Files"));
		SCOPED_ACTION(SaveScreen);

		auto PR_PrintMsg = [](){ Message(0, 0, MSG(MPrintTitle), MSG(MPreparingForPrinting)); };

		SCOPED_ACTION(TPreRedrawFuncGuard)(std::make_unique<PreRedrawItem>(PR_PrintMsg));
		SetCursorType(false, 0);
		PR_PrintMsg();
		auto hPlugin=SrcPanel->GetPluginHandle();
		int PluginMode=SrcPanel->GetMode()==PLUGIN_PANEL &&
		               !Global->CtrlObject->Plugins->UseFarCommand(hPlugin,PLUGIN_FARGETFILE);
		SrcPanel->GetSelName(nullptr,FileAttr);

		while (SrcPanel->GetSelName(&strSelName,FileAttr))
		{
			if (TestParentFolderName(strSelName) || (FileAttr & FILE_ATTRIBUTE_DIRECTORY))
				continue;

			int Success=FALSE;
			string FileName;
			string strTempDir, strTempName;

			if (PluginMode)
			{
				if (FarMkTempEx(strTempDir))
				{
					api::CreateDirectory(strTempDir,nullptr);
					auto ListItem = SrcPanel->GetLastSelectedItem();
					if (ListItem)
					{
						PluginPanelItem PanelItem;
						FileList::FileListToPluginItem(*ListItem, &PanelItem);

						if (Global->CtrlObject->Plugins->GetFile(hPlugin,&PanelItem,strTempDir,strTempName,OPM_SILENT))
							FileName = strTempName;
						else
							api::RemoveDirectory(strTempDir);

						FreePluginPanelItem(PanelItem);
					}
				}
			}
			else
				FileName = strSelName;

			api::File SrcFile;
			if(SrcFile.Open(FileName, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, nullptr, OPEN_EXISTING))
			{
				DOC_INFO_1 di1 = {UNSAFE_CSTR(FileName)};

				if (StartDocPrinter(hPrinter,1,(LPBYTE)&di1))
				{
					char Buffer[8192];
					DWORD Read,Written;
					Success=TRUE;

					while (SrcFile.Read(Buffer, sizeof(Buffer), Read) && Read > 0)
						if (!WritePrinter(hPrinter,Buffer,Read,&Written))
						{
							Global->CatchError();
							Success=FALSE;
							break;
						}

					EndDocPrinter(hPrinter);
				}
				SrcFile.Close();
			}

			if (!strTempName.empty())
			{
				DeleteFileWithFolder(strTempName);
			}

			if (Success)
				SrcPanel->ClearLastGetSelection();
			else
			{
				if (Message(MSG_WARNING|MSG_ERRORTYPE,2,MSG(MPrintTitle),MSG(MCannotPrint),
				            strSelName.data(),MSG(MSkip),MSG(MCancel)))
					break;
			}
		}

		ClosePrinter(hPrinter);
	}

	SrcPanel->Redraw();
}
Example #27
0
float Sphere::volume() const {
    return (float)pi() * (4.0f / 3.0f) * powf((float)radius, 3.0f);
}
Example #28
0
int main(int argc, char **argv)
{
    ros::init (argc, argv, "right_arm_pick_place");
    ros::AsyncSpinner spinner(1);
    spinner.start();

    ros::NodeHandle nh;

    Mesh_loader ml;
    Suturo_Manipulation_Planning_Scene_Interface pi(&nh);
    Grasp_Calculator calc(&pi);
    // Grasping grapser(&pi);

    std::vector<geometry_msgs::PoseStamped> poses;
    std::vector<geometry_msgs::PoseStamped> pre_poses;

    // moveit_msgs::CollisionObject co;
    // co.header.stamp = ros::Time::now();
    // co.header.frame_id = "/base_footprint";
    // co.id = "corny";

    // co.meshes.resize(1);
    // co.meshes[0] = ml.load_corny_msg();
    // co.mesh_poses.resize(1);
    // co.mesh_poses[0].position.x = 1;
    // co.mesh_poses[0].position.y = 0;
    // co.mesh_poses[0].position.z = 0;
    // co.mesh_poses[0].orientation.w = 1;
    // pi.addObject(co);
    // geometry_msgs::PoseStamped ps;
    // ps.header = co.header;
    // ps.pose = co.mesh_poses[0];
    // // pi.publishMarkerPoint(ps);

    // calc.calcMeshGraspPosition(co, poses, pre_poses, Gripper::R_GRIPPER_PALM_LENGTH);

    moveit_msgs::CollisionObject co;
    // pi.getObject("box.stl", co);
    co.header.stamp = ros::Time::now();
    co.header.frame_id = "/base_footprint";
    co.id = "pancake";

    co.meshes.resize(1);
    co.meshes[0] = ml.load_pancake_msg();
    co.mesh_poses.resize(1);
    co.mesh_poses[0].position.x = 1;
    co.mesh_poses[0].position.y = 0;
    co.mesh_poses[0].position.z = 0;
    co.mesh_poses[0].orientation.w = 1;
    pi.addObject(co);
    geometry_msgs::PoseStamped ps;
    ps.header = co.header;
    ps.pose = co.mesh_poses[0];
    calc.calcMeshGraspPosition(co, poses, pre_poses, Gripper::R_GRIPPER_PALM_LENGTH);

    // pi.check_group_object_collision("left_gripper", ps, co);

    // ROS_INFO_STREAM(ml.load_corny());
    // ROS_INFO_STREAM("\n\n");
    // ROS_INFO_STREAM(ml.load_pringles());

    // ros::Publisher pub_co = nh.advertise<moveit_msgs::CollisionObject>("collision_object", 10);
    // ros::WallDuration(1.0).sleep();
    // moveit_msgs::CollisionObject co;
    // co.header.stamp = ros::Time::now();
    // co.header.frame_id = "/base_footprint";
    // co.id = "corny";


    // co.meshes.resize(1);
    // co.meshes[0] = ml.load_corny_msg();
    // co.mesh_poses.resize(1);
    // co.mesh_poses[0].position.x = 2;
    // co.mesh_poses[0].position.y = 0;
    // co.mesh_poses[0].position.z = 2;
    // co.mesh_poses[0].orientation.w = 1;
    // co.operation = moveit_msgs::CollisionObject::REMOVE;
    // pub_co.publish(co);
    // ros::WallDuration(1.0).sleep();
    // co.operation = moveit_msgs::CollisionObject::ADD;
    // pub_co.publish(co);
    // ros::WallDuration(1.0).sleep();

    // shapes::Mesh *corny = ml.load_corny();
    // corny->computeTriangleNormals();
    // for (int i = 0; corny->triangle_count > i; i++){
    //     ROS_INFO_STREAM(" ");
    //     ROS_INFO_STREAM(corny->triangle_normals[i*3]);
    //     ROS_INFO_STREAM(corny->triangle_normals[(i*3) + 1]);
    //     ROS_INFO_STREAM(corny->triangle_normals[(i*3) + 2]);

    // }

    // Gripper g;

    // if (argc == 2){
    //  g.open_l_gripper();
    // } else if (argc == 3) {
    //  g.close_l_gripper();
    // }
    //~ geometry_msgs::PoseStamped p;
    //~ p.header.frame_id = "/base_footprint";
    //~ p.pose.position.x = 0.40;
    //~ p.pose.position.y = 0;
    //~ p.pose.position.z = 0.625;
    //~ p.pose.orientation = tf::createQuaternionMsgFromRollPitchYaw(0,0,0);

    // ros::Publisher pub_co = nh.advertise<moveit_msgs::CollisionObject>("collision_object", 10);
    // putObjects(pub_co);

    // Suturo_Manipulation_Planning_Scene_Interface pi(&nh);
    // pi.allowCollision("r_gripper_l_finger_link", "corny");
    // pi.allowCollision("r_gripper_l_finger_tip_link", "corny");
    // pi.allowCollision("r_gripper_motor_accelerometer_link", "corny");
    // pi.allowCollision("r_gripper_palm_link", "corny");
    // pi.allowCollision("r_gripper_r_finger_link", "corny");
    // pi.allowCollision("r_gripper_r_finger_tip_link", "corny");

    // pi.allowCollision("l_gripper_l_finger_link", "cafetfilter");
    // pi.allowCollision("l_gripper_l_finger_tip_link", "cafetfilter");
    // pi.allowCollision("l_gripper_motor_accelerometer_link", "cafetfilter");
    // pi.allowCollision("l_gripper_palm_link", "cafetfilter");
    // pi.allowCollision("l_gripper_r_finger_link", "cafetfilter");
    // pi.allowCollision("l_gripper_r_finger_tip_link", "cafetfilter");

    // moveit_msgs::PlanningScene ps;
    // ROS_INFO_STREAM(pi.getPlanningScene(ps));
    // ROS_INFO_STREAM(ps);
    // ps.robot_state.multi_dof_joint_state.joint_transforms[0].translation.x = 1;

    // geometry_msgs::PoseStamped targetPose;
    // targetPose.header.frame_id = "/odom_combined";
    // targetPose.pose.position.x = atof(argv[1]);
    // targetPose.pose.position.y = atof(argv[2]);
    // targetPose.pose.position.z = atof(argv[3]);
    // targetPose.pose.orientation.w = 1;

    // Suturo_Manipulation_Move_Robot moveRobot(&nh);
    // ROS_INFO_STREAM("collision: " << (moveRobot.checkFullCollision(targetPose)));

    //~ ros::Publisher pub_co = nh.advertise<moveit_msgs::CollisionObject>("collision_object", 10);
    //~ putObjects(pub_co);
    //~
    //~ Gripper g;
    //~
    //~ if (argc == 2){
    //~ g.open_l_gripper();
    //~ } else if (argc == 3) {
    //~ g.close_l_gripper();
    //~ }

    //~ move_group_interface::MoveGroup group("right_arm");
    //~ geometry_msgs::PoseStamped p;
    //~ p.header.frame_id = "/base_footprint";
    //~ p.pose.position.x = 0.40;
    //~ p.pose.position.y = 0;
    //~ p.pose.position.z = 0.625;
    //~ p.pose.orientation = tf::createQuaternionMsgFromRollPitchYaw(0,0,0);
    //~ group.setPoseTarget(p);
    //~ group.move();

    //     move_group_interface::MoveGroup group("left_gripper");
    // ROS_INFO_STREAM("gripper joints");
    //     std::vector<std::string> bla1 = group.getJoints();
    //     for (int i = 0; i < bla1.size(); i++) ROS_INFO_STREAM(bla1.at(i));

    // ROS_INFO_STREAM("------");
    //     std::vector<double> bla = group.getCurrentJointValues();

    //     for (int i = 0; i < bla.size(); i++) ROS_INFO_STREAM(bla.at(i));
    //~
    //~ openhand();
    //~
    //~ bla = group.getCurrentJointValues();
    //~ for (int i = 0; i < bla.size(); i++) ROS_INFO_STREAM(bla.at(i));
    //~

    //~ Suturo_Manipulation_Planning_Scene_Interface pi(&nh);

    //~ Grasping grasper(&pi);
    //~ grasper.drop(suturo_manipulation_msgs::RobotBodyPart::LEFT_ARM);
    //~ grasper.pick("dlink", suturo_manipulation_msgs::RobotBodyPart::RIGHT_ARM);
    //~ grasper.pick("dlink", suturo_manipulation_msgs::RobotBodyPart::RIGHT_ARM);
    //~ grasper.pick("corny", suturo_manipulation_msgs::RobotBodyPart::RIGHT_ARM);
    //~ ROS_INFO("done.");
    //~ grasper.pick("corny", suturo_manipulation_msgs::RobotBodyPart::LEFT_ARM);
    //~ ROS_INFO("done.");

    //~ move_group_interface::MoveGroup group("left_arm");
    //~ geometry_msgs::PoseStamped p;
    //~ p.header.frame_id = "/base_footprint";
    //~ p.pose.position.x = 0.5;
    //~ p.pose.position.y = 0.2;
    //~ p.pose.position.z = 1;
    //~ p.pose.orientation = tf::createQuaternionMsgFromRollPitchYaw(M_PI, 0, -M_PI_2);
    //~ group.setPoseTarget(p);

    //~ tf::Quaternion q;
    //~ double roll, pitch, yaw;
    //~ tf::quaternionMsgToTF(p.pose.orientation, q);
    //~ ROS_INFO_STREAM(p.pose.orientation);
    //~ tf::Matrix3x3(q).getRPY(roll, pitch, yaw);
    //~ ROS_INFO("RPY = (%lf, %lf, %lf)", roll, pitch, yaw);

    //~ if (!group.move()) return 0;
    //~ ROS_INFO("done.");

    //~ grasper.pick("corny", suturo_manipulation_msgs::RobotBodyPart::RIGHT_ARM);
    //~ ROS_INFO("done.");

    //~ ROS_INFO("done.");
    //~ grasper.pick("corny", suturo_manipulation_msgs::RobotBodyPart::LEFT_ARM);
    //~ grasper.drop(suturo_manipulation_msgs::RobotBodyPart::RIGHT_ARM);
    //~ grasper.drop(suturo_manipulation_msgs::RobotBodyPart::RIGHT_ARM);
    //~ grasper.drop("corny");
    //~ openhand();

    //~ moveit_msgs::PlanningScene ps;
    //~ pi.getPlanningScene(ps);
    //~ ROS_INFO_STREAM("ps: " << ps);

    //std::vector<moveit_msgs::AttachedCollisionObject> muh = pi.getAttachedObjects();
    //ROS_INFO_STREAM("objects " << muh.at(0));
    //~ grasper.drop("box2");

    //geometry_msgs::PoseStamped p;
    //p.header.frame_id = "/base_footprint";
    //p.pose.position.x = 0.65;
    //p.pose.position.y = -0.3;
    //p.pose.position.z = 0.821;
    //p.pose.orientation = tf::createQuaternionMsgFromRollPitchYaw(0, M_PI_2, M_PI_4);
    //grasper.l_arm_pick("box2");

    //move_group_interface::MoveGroup group("right_arm");
    //group.setPlanningTime(45.0);
    /*pick(group);*/

    /*geometry_msgs::PoseStamped p;
      p.header.frame_id = "/base_footprint";
      p.pose.position.x = 0.59;
      p.pose.position.y = 0;
      p.pose.position.z = 0.625;
      p.pose.orientation.x = 0;
      p.pose.orientation.y = 0;
      p.pose.orientation.z = 0;
      p.pose.orientation.w = 1;*/

    //group.setPoseTarget(p);
    //group.move();


    //move_group_interface::MoveGroup group("right_arm");
    //pick(group);
    //Gripper g;
    //pi.attachObject("box1", "r_wrist_roll_link", Gripper::get_r_gripper_links());
    //moveit_msgs::PlanningScene ps;
    //pi.getPlanningScene(ps);
    //std::vector<moveit_msgs::AttachedCollisionObject> muh = pi.getAttachedObjects();
    //ROS_INFO_STREAM("objects " << muh.at(0));


    //pi.detachObject("box1");
    //muh = pi.getAttachedObjects();
    //ROS_INFO_STREAM("objects " << muh.at(0));

    //ROS_INFO_STREAM("ps " << ps.robot_state);
    //ros::Publisher pub2 = nh.advertise<moveit_msgs::PlanningScene>("planning_scene", 10);
    //pub2.publish(ps);

    //ROS_INFO_STREAM("dsads  " << ps);

    // ROS_DEBUG_STREAM("finish");
    ROS_INFO_STREAM("finish");
    ros::waitForShutdown();
    return 0;
}
Example #29
0
// Encrypton and authentication procedure
int crypto_aead_encrypt(
unsigned char *c,unsigned long long *clen,
const unsigned char *m,unsigned long long mlen,
const unsigned char *ad,unsigned long long adlen,
const unsigned char *nsec,
const unsigned char *npub,
const unsigned char *k
)
{
 //...
 //... the code for the cipher implementation goes here,
 //... generating a ciphertext c[0],c[1],...,c[*clen-1]
 //... from a plaintext m[0],m[1],...,m[mlen-1]
 //... and associated data ad[0],ad[1],...,ad[adlen-1]
 //... and secret message number nsec[0],nsec[1],...
 //... and public message number npub[0],npub[1],...
 //... and secret key k[0],k[1],...
 //...

 // some 64-bit temp variables
 u_int64_t  t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13;
 // more 64-bit temp variables
 u_int64_t  x0, x1, x2, x3, y0, y1, y2, y3, z0, z1, z2, z3;
 // pointers to 64-bit variables
 u_int64_t  *c64, *m64, *ad64, *nsec64, *npub64, *k64;
 // counter ctr is a 64-bit variable in all variants of PiCipher
 u_int64_t  ctr = 0x0000000000000000ull;
 // an array for storing some temporal values for the Tag computation
 u_int64_t  tempTag[CRYPTO_TBYTES/W] = {0};
 // an array for the Common Internal State
 u_int64_t  CIS[IS_SIZE] = {0};
 // pointers that look at the used data arrays as arrays of bytes
 u_int8_t   *InternalState8, *CommonInternalState8, *tempTag8;
 // variables for dealing with various lengths of the plaintext and associated data
 int        LastMessageChunkLength, LastADChunkLength;
 // different iterator variables
 unsigned long long i, j, jj, ii, b, i1, j1, a;

 c64    = (u_int64_t *) c;
 m64    = (u_int64_t *) m;
 ad64   = (u_int64_t *) ad;
 nsec64 = (u_int64_t *) nsec;
 npub64 = (u_int64_t *) npub;
 k64    = (u_int64_t *) k;
 InternalState8       = (u_int8_t *) IS;
 CommonInternalState8 = (u_int8_t *) CIS;
 tempTag8             = (u_int8_t *) tempTag;

 // phase 1: Initialization
 for (i = 0; i < IS_SIZE; i++ ) {
	 IS[i] = 0;
 }
 // injection of the key
 for ( i = 0; i < CRYPTO_KEYBYTES; i++ ) {
	 InternalState8[i] = k[i];
 }
 // injection of the nonce (public message number - PMN)
 for ( j = 0; j < CRYPTO_NPUBBYTES; j++ ) {
	 InternalState8[i++] = npub[j];
 }
 // appending a single 1 to the concatenated value of the key and PMN
 InternalState8[i] = 0x01;

 // applying the permutation function pi
 pi();

 // initialization of the Common Internal State (CIS), common for all parallel invocations of pi() with different ctrs
 for ( i = 0; i < IS_SIZE; i++ ) {
	CIS[i] = IS[i];
 }

 // initialization of the ctr obtained from the first 64 bits of the capacity of CIS
 ctr = CIS[4];

 // phase 2: Processing the associated data
 b = 0;
 a = adlen/RATE;
 for ( j = 0; j < a; j ++ ) {
	 // IS for the triplex component is initialized by the CIS for every AD block
	for ( i = 0; i < IS_SIZE; i++ ) {
		IS[i] = CIS[i];
	}
	ctr ++;
	// Inject ctr + j in IS
	IS[0] = IS[0] ^ ctr;
	pi();
	// process the AD block
	// Inject the AD block
	for ( i = 0; i < N; i += 2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			IS[i*WORDS_CHUNK+i1] = IS[i*WORDS_CHUNK+i1] ^ ad64[b];
			b++;
		}
	}
	pi();
	// Collect the tag for this block
	// Sum of the tags componentwise, where the length of one component is W
	jj = 0;
	for ( i = 0; i < N; i+=2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			tempTag[jj] = tempTag[jj] + IS[i*WORDS_CHUNK+i1];
			jj++;
		}
	}
 }
 // if the last AD block is not the full block, we process it byte by byte
 LastADChunkLength = adlen % RATE;
 if ( LastADChunkLength ) {
	 b = b * W;
	 i1 = 0;
	 for ( i = 0; i < IS_SIZE; i++ ) {
		IS[i] = CIS[i];
	 }
	 ctr++;
	 IS[0] = IS[0] ^ ctr;
	 pi();
	 for ( i = 0; i < LastADChunkLength; i++ ) {
		 InternalState8[i1] = InternalState8[i1++] ^ ad[b+i];
		 if( i1 % (WORDS_CHUNK*W) == 0 ) i1 += WORDS_CHUNK*W;
	 }
	 // padding with 10*
	 InternalState8[LastADChunkLength] = InternalState8[LastADChunkLength] ^ 0x01;
	 pi();
	 //updating the tag
	 jj = 0;
	 for ( i = 0; i < N; i+=2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			tempTag[jj] = tempTag[jj] + IS[i*WORDS_CHUNK+i1];
			jj++;
		}
	 }
 }

 // updating the Common Internal State by injection of the tag (tempTag) obtained from the associated data
 jj = 0;
 for ( i = 0; i < N; i+=2 ) {
	for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
		IS[i*WORDS_CHUNK+i1] = CIS[i*WORDS_CHUNK+i1] ^ tempTag[jj];
		IS[(i+1)*WORDS_CHUNK+i1] = CIS[(i+1)*WORDS_CHUNK+i1];
		jj++;
	}
 }
 pi();
 for ( i = 0; i < IS_SIZE; i++ ) {
	CIS[i] = IS[i];
 }

 // phase 3: Processing the secret messge number
 if ( CRYPTO_NSECBYTES > 0 ) {
	for ( i = 0; i < IS_SIZE; i++ ) {
		IS[i] = CIS[i];
	}
	ctr++;
	IS[0] = IS[0] ^ ctr;
	pi();
	// encrypt the SMN
	// Inject the SMN
	b = 0;
	for ( i = 0; i < N; i+=2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			c64[b] = IS[i*WORDS_CHUNK+i1] = IS[i*WORDS_CHUNK+i1] ^ nsec64[b];
			b++;
		}
	}
	pi();

	// updating the Common Internal State from the encrypted SMN
	for ( i = 0; i < IS_SIZE; i++ ) {
		CIS[i] = IS[i];
	}
	// Collect the tag from this encryption and update the tempTag
	jj = 0;
	for ( i = 0; i < N; i+=2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			tempTag[jj] = tempTag[jj] + IS[i*WORDS_CHUNK+i1];
			jj++;
		}
	}
 }

 //phase 4: Processing the message
 b = 0;
 for ( j = 0; j < mlen/RATE ; j ++ ) {
	for ( i = 0; i < IS_SIZE; i++ ) {
		IS[i] = CIS[i];
	}
	ctr++;
	IS[0] = IS[0] ^ ctr;
	pi();
	// encrypt the message m
	// Inject a block of m
	for ( i = 0; i < N; i+=2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			c64[bSMN+b] = IS[i*WORDS_CHUNK+i1] = IS[i*WORDS_CHUNK+i1] ^ m64[b];
			b++;
		}
	}
	pi();
	// Collect the tag from this encryption and update the tempTag
	jj = 0;
	for ( i = 0; i < N; i += 2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			tempTag[jj] = tempTag[jj] + IS[i*WORDS_CHUNK+i1];
			jj++;
		}
	}
 }
 // if the last message block is not the full block, we process it byte by byte
 LastMessageChunkLength = mlen % RATE;
 if ( LastMessageChunkLength ) {
	 b = b * W;
	 i1 = 0;
	 for ( i = 0; i < IS_SIZE; i++ ) {
		IS[i] = CIS[i];
	 }
	 ctr++;
	 IS[0] = IS[0] ^ ctr;
	 pi();
	 for ( i = 0; i < LastMessageChunkLength; i++ ) {
		 c[CRYPTO_NSECBYTES+b+i] = InternalState8[i1] = InternalState8[i1++] ^ m[b+i];
		 if( i1 % (WORDS_CHUNK*W) == 0 ) i1 += WORDS_CHUNK*W;
	 }
	 // padding with 10*
	 InternalState8[LastMessageChunkLength] = InternalState8[LastMessageChunkLength] ^ 0x01;
	 pi();
	 // updating the tag
	 jj = 0;
	 for ( i = 0; i < N; i+=2 ) {
		for ( i1 = 0; i1 < WORDS_CHUNK; i1++ ) {
			tempTag[jj] = tempTag[jj] + IS[i*WORDS_CHUNK+i1];
			jj++;
		}
	 }
 }

 // concatenation of the tag T to the ciphertext c
 for ( jj = 0; jj < CRYPTO_TBYTES; jj++ ) {
	c[CRYPTO_NSECBYTES+mlen+jj] = tempTag8[jj];
 }

 //updating the lenght of the ciphertext
 *clen = mlen + CRYPTO_TBYTES + CRYPTO_NSECBYTES;

  return 0;
}
Example #30
0
	static void flip(MdlObject *o) {
		for (PolyIterator pi(o);!pi.End();pi.Next())
			 if (pi->isSelected)
				 pi->Flip ();
	}