Beispiel #1
0
Datei: ccm.c Projekt: Alpam/casan
long int
dtls_ccm_decrypt_message(rijndael_ctx *ctx, size_t M, size_t L,
        unsigned char nonce[DTLS_CCM_BLOCKSIZE],
        unsigned char *msg, size_t lm,
        const unsigned char *aad, size_t la) {

    size_t len;
    unsigned long counter_tmp;
    unsigned long counter = 1; /* \bug does not work correctly on ia32 when
                                  lm >= 2^16 */
    unsigned char A[DTLS_CCM_BLOCKSIZE]; /* A_i blocks for encryption input */
    unsigned char B[DTLS_CCM_BLOCKSIZE]; /* B_i blocks for CBC-MAC input */
    unsigned char S[DTLS_CCM_BLOCKSIZE]; /* S_i = encrypted A_i blocks */
    unsigned char X[DTLS_CCM_BLOCKSIZE]; /* X_i = encrypted B_i blocks */

    if (lm < M)
        goto error;

    len = lm;	      /* save original length */
    lm -= M;	      /* detract MAC size*/

    /* create the initial authentication block B0 */
    block0(M, L, la, lm, nonce, B);
    add_auth_data(ctx, aad, la, B, X);

    /* initialize block template */
    A[0] = L-1;

    /* copy the nonce */
    memcpy(A + 1, nonce, DTLS_CCM_BLOCKSIZE - L);

    while (lm >= DTLS_CCM_BLOCKSIZE) {
        /* decrypt */
        encrypt(ctx, L, counter, msg, DTLS_CCM_BLOCKSIZE, A, S);

        /* calculate MAC */
        mac(ctx, msg, DTLS_CCM_BLOCKSIZE, B, X);

        /* update local pointers */
        lm -= DTLS_CCM_BLOCKSIZE;
        msg += DTLS_CCM_BLOCKSIZE;
        counter++;
    }

    if (lm) {
        /* decrypt */
        encrypt(ctx, L, counter, msg, lm, A, S);

        /* Calculate MAC. Note that msg ends in the MAC so we must
         * construct B to contain X ^ msg for the first lm bytes (done in
         * mac() and X ^ 0 for the remaining DTLS_CCM_BLOCKSIZE - lm bytes
         * (i.e., we can use memcpy() here).
         */
        memcpy(B + lm, X + lm, DTLS_CCM_BLOCKSIZE - lm);
        mac(ctx, msg, lm, B, X);

        /* update local pointers */
        msg += lm;
    }

    /* calculate S_0 */
    SET_COUNTER(A, L, 0, counter_tmp);

#ifdef NOUVELLE_IMPLE_AES
    memcpy(S, A, DTLS_CCM_BLOCKSIZE);
    aes128_enc(S, ctx);
#endif

#ifdef ANCIENNE_IMPLE_AES
    rijndael_encrypt(ctx, A, S);
#endif

    memxor(msg, S, M);

    /* return length if MAC is valid, otherwise continue with error handling */
    if (equals(X, msg, M))
        return len - M;

error:
    return -1;
}
Beispiel #2
0
void CSCanAPThread::DaemonDeviceScan()
{
	//每隔一定时间,扫描指定的设备,获取ip
	std::string str_stalist = m_ssh.GetDeviceMAC();

	if(str_stalist.c_str() == std::string("Error"))
	{
		m_bIsConnect = false;
		m_ssh.ConnectAP();
		return;
	}
	else
	{
		m_bIsConnect = true;
	}

	//先分割获取MAC
	std::vector<std::string> vec_list;
	CUtil::split(str_stalist, vec_list, "\n");

	if (vec_list.size() < 2)
	{
		return;
	}

	//去掉无用信息
	vec_list.erase(vec_list.begin());
	vec_list.erase(vec_list.end() - 1);
	
	int i = 0;
	for (std::vector<std::string>::iterator iter = vec_list.begin(); iter != vec_list.end(); iter++)
	{
		if (i % 4 == 0)
		{
			//写入数据库
			CModel *pmodel = CSingleton<CModel>::instance();
			std::string mac((*iter), 0, 17);

			//获取deviceID
			int deviceID = pmodel->GetDeviceIDbyMAC(mac);

			if (deviceID > 0)
			{
				//获取APID
				int APID = pmodel->GetAPIDbyIP(m_strIP);

				Field definition_tbMonitor[] = 
				{
					Field(FIELD_KEY),
					Field("DeviceID", type_int),
					Field("APID", type_int),
					Field(DEFINITION_END),
				};
				Table tbMonitor(pmodel->MGetDatabase(), std::string("DirectionMonitor"), definition_tbMonitor);
				tbMonitor.open();
				Record record(tbMonitor.fields());
				record.setInteger("DeviceID", deviceID);
				record.setInteger("APID", APID);
				tbMonitor.addRecord(&record);
			}
		}
		i++;
	}
}
Beispiel #3
0
// get network interface info from file (should include all available interfaces)
std::vector<std::map<std::string,std::string> >
Responder::read_eth_info()
{
    const std::string eth_file(_eth_file);

    std::vector<std::map<std::string,std::string> > eths;
    try
    {
        ifstream eth_info(eth_file.c_str());
        if(!eth_info.is_open()){
            return eths;
        }
        const int len = 256;
        char cline[len];
        for(; !eth_info.eof() ;)
        {
            eth_info.getline(cline, len);
            std::string line(cline);
            if(line.find("## ETH Interface") != std::string::npos)
            {
                eth_info.getline(cline, len);
                std::string eth(cline);
//                cout << "interface=" << eth << endl;
                std::map<std::string,std::string> iface;
                iface["interface"] = eth;
                eths.push_back(iface);
            }
            const std::string ipstr("\tip ");
            if(line.find(ipstr) != std::string::npos)
            {
                std::string ip( line.replace(line.begin(), line.begin()+ipstr.length(), "") );
//                cout << "ip=" << ip << endl;
                eths.back()["addr"] = ip;
            }
            const std::string macstr("\tmac ");
            if(line.find(macstr) != std::string::npos)
            {
                std::string mac( line.replace(line.begin(), line.begin()+macstr.length(), "") );
//                cout << "mac=" << mac << endl;
                eths.back()["mac"] = mac;
            }
            const std::string vstr("\t\tvendor ");
            if(line.find(vstr) != std::string::npos)
            {
                std::string vendor( line.replace(line.begin(), line.begin()+vstr.length(), "") );
                std::string vid( vendor.substr(0,6) );
                vendor.replace(0, 7, "");
//                cout << "id=" << vid << endl;
//                cout << "vendor=" << vendor << endl;
                eths.back()["vendor"] = vendor;
                eths.back()["vendor_id"] = vid;
            }
            const std::string dstr("\t\tdevice ");
            if(line.find(dstr) != std::string::npos)
            {
                std::string device( line.replace(line.begin(), line.begin()+dstr.length(), "") );
                std::string did( device.substr(0,6) );
                device.replace(0, 7, "");
//                cout << "id=" << did << endl;
//                cout << "device=" << device << endl;
                eths.back()["device"] = device;
                eths.back()["device_id"] = did;
            }
        }

    }
    catch(...)
    {
        // nothing in yet
    }
    return eths;
}
Beispiel #4
0
Datei: ccm.c Projekt: Alpam/casan
long int
dtls_ccm_encrypt_message(rijndael_ctx *ctx, size_t M, size_t L,
        unsigned char nonce[DTLS_CCM_BLOCKSIZE],
        unsigned char *msg, size_t lm,
        const unsigned char *aad, size_t la) {
    size_t i, len;
    unsigned long counter_tmp;
    unsigned long counter = 1; /* \bug does not work correctly on ia32 when
                                  lm >= 2^16 */
    unsigned char A[DTLS_CCM_BLOCKSIZE]; /* A_i blocks for encryption input */
    unsigned char B[DTLS_CCM_BLOCKSIZE]; /* B_i blocks for CBC-MAC input */
    unsigned char S[DTLS_CCM_BLOCKSIZE]; /* S_i = encrypted A_i blocks */
    unsigned char X[DTLS_CCM_BLOCKSIZE]; /* X_i = encrypted B_i blocks */

    len = lm;			/* save original length */
    /* create the initial authentication block B0 */
    block0(M, L, la, lm, nonce, B);
    add_auth_data(ctx, aad, la, B, X);

    /* initialize block template */
    A[0] = L-1;

    /* copy the nonce */
    memcpy(A + 1, nonce, DTLS_CCM_BLOCKSIZE - L);

    while (lm >= DTLS_CCM_BLOCKSIZE) {
        /* calculate MAC */
        mac(ctx, msg, DTLS_CCM_BLOCKSIZE, B, X);

        /* encrypt */
        encrypt(ctx, L, counter, msg, DTLS_CCM_BLOCKSIZE, A, S);

        /* update local pointers */
        lm -= DTLS_CCM_BLOCKSIZE;
        msg += DTLS_CCM_BLOCKSIZE;
        counter++;
    }

    if (lm) {
        /* Calculate MAC. The remainder of B must be padded with zeroes, so
         * B is constructed to contain X ^ msg for the first lm bytes (done in
         * mac() and X ^ 0 for the remaining DTLS_CCM_BLOCKSIZE - lm bytes
         * (i.e., we can use memcpy() here).
         */
        memcpy(B + lm, X + lm, DTLS_CCM_BLOCKSIZE - lm);
        mac(ctx, msg, lm, B, X);

        /* encrypt */
        encrypt(ctx, L, counter, msg, lm, A, S);

        /* update local pointers */
        msg += lm;
    }

    /* calculate S_0 */
    SET_COUNTER(A, L, 0, counter_tmp);

#ifdef NOUVELLE_IMPLE_AES
    memcpy(S, A, DTLS_CCM_BLOCKSIZE);
    aes128_enc(S, ctx);
#endif

#ifdef ANCIENNE_IMPLE_AES
    rijndael_encrypt(ctx, A, S);
#endif

    for (i = 0; i < M; ++i)
        *msg++ = X[i] ^ S[i];

    return len + M;
}
int AtiendeCliente(int socket, struct sockaddr_in addr)
{

     char buffer[BUFFERSIZE];
     char aux[BUFFERSIZE];
     int bytecount;
     int fin=0;
     int code=0;         /* Código de salida por defecto */
     time_t t;
     struct tm *tmp;

     while (!fin)
       {

     memset(buffer, 0, BUFFERSIZE);
     if((bytecount = recv(socket, buffer, BUFFERSIZE, 0))== -1)
       error(5, "No puedo recibir información");
     

     //verificamos si lo que mandan es una ip y entonces la cambiamos por MAC
     if (strncmp(buffer, "IP", 2)==0)
     {
         printf("Se trata de in IPHONE\n");
         std::string comando(buffer);
         comando=comando.substr(3);
         comando="weon:"+GetMac(comando);
         
         printf("El comando dice:");
         printf(comando.c_str());
         
         comando.copy(buffer,comando.length(),0);         
     }
     ///////////////////////////////////////
     /* Evaluamos los comandos */
     /* El sistema de gestión de comandos es muy rudimentario, pero nos vale */
     /* Comando TIME - Da la hora */
     //weon:mac
     if (strncmp(buffer, "weon", 4)==0)
       {
         t = time(NULL);
         tmp = localtime(&t);
         //separo la mac address
         std::string mac(buffer);
         mac=mac.substr(5,17);
         
         
         //registro el inicio de sesion, talvez solo registro todos
         
         memset(buffer, 0, 7);
         strftime(buffer, BUFFERSIZE, "echo '%H|", tmp);
         std::string txt(buffer);
         txt.append(mac);
         txt.append("' >> /etc/weon/InciosSesion.txt");
         memset(buffer, 0, txt.length());
         txt.copy(buffer,txt.length(),0);
         system(buffer);
         printf(buffer);
         //coloco la regla que logea
         //se registrara todo, esta linea no es necesaria
         
         txt="iptables -A FORWARD -p tcp --dport 443 -m mac --mac-source ";
         txt.append(mac);
         txt.append(" -m state --state NEW -j LOG --log-prefix 'weon:");
         txt.append(mac);
         txt.append("' --log-level 4 ");
         memset(buffer, 0, BUFFERSIZE);
         txt.copy(buffer,txt.length(),0);
         system(buffer);
         printf(buffer);
         
         //coloco la regla que concede permisos
         //std::string txt;
         txt="/sbin/iptables -A FORWARD -m mac --mac-source ";
         txt.append(mac);
         txt.append(" -j ACCEPT");
         memset(buffer, 0,BUFFERSIZE);
         txt.copy(buffer,txt.length(),0);
         system(buffer); 
         printf(buffer);
         
         //regla que manda todo a squid
         txt="/sbin/iptables -t nat -I PREROUTING 2 -m mac --mac-source ";
         txt.append(mac);
         txt.append(" -p tcp --dport 80 -j DNAT --to-destination 192.168.1.250:3128");
         memset(buffer, 0,BUFFERSIZE);
         txt.copy(buffer,txt.length(),0);
         system(buffer); 
         printf(buffer);
         //esta regla deja saliro todo el trafico que no va al 80
         txt="/sbin/iptables -t nat -I PREROUTING 3 -m mac --mac-source ";
         txt.append(mac);
         txt.append(" -j ACCEPT");
         memset(buffer, 0,BUFFERSIZE);
         txt.copy(buffer,txt.length(),0);
         system(buffer); 
         printf(buffer);
         
         //regreso mesage de concedido
         txt="OK:"+mac;
         memset(buffer, 0, BUFFERSIZE);
         txt.copy(buffer,txt.length(),0);
         fin=1;
       }
     
     else if (strncmp(buffer, "check", 5)==0)
     {
         
         std::string cmd(buffer);
         cmd=cmd.substr(6);
         memset(buffer,0,BUFFERSIZE);
         cmd.copy(buffer,cmd.length(),0);
         system(buffer);
         fin=1;
     }
     /* Comando DATE - Da la fecha */
     else if (strncmp(buffer, "DATE", 4)==0)
       {
         memset(buffer, 0, BUFFERSIZE);

         t = time(NULL);
         tmp = localtime(&t);

         strftime(buffer, BUFFERSIZE, "Hoy es %d/%m/%Y\n", tmp);
       }
     /* Comando HOLA - Saluda y dice la IP */
     else if (strncmp(buffer, "HOLA", 4)==0)
       {
         memset(buffer, 0, BUFFERSIZE);
         sprintf(buffer, "Hola %s, ¿cómo estás?\n", inet_ntoa(addr.sin_addr));
       }
     /* Comando EXIT - Cierra la conexión actual */
     else if (strncmp(buffer, "E", 1)==0)
       {
         memset(buffer, 0, BUFFERSIZE);
         sprintf(buffer, "Hasta luego. Vuelve pronto %s\n", inet_ntoa(addr.sin_addr));
         fin=1;
       }
     /* Comando CERRAR - Cierra el servidor */
     else if (strncmp(buffer, "Q",1)==0)
       {
         memset(buffer, 0, BUFFERSIZE);
         sprintf(buffer, "Adiós. Cierro el servidor\n");
         fin=1;
         code=99;        /* Salir del programa */
       }
     else
       {     
         sprintf(aux, "ECHO: %s\n", buffer);
         strcpy(buffer, aux);
       }

     if((bytecount = send(socket, buffer, strlen(buffer), 0))== -1)
       error(6, "No puedo enviar información");
       }

     close(socket);
     return code;
}
Beispiel #6
0
/*
 * check: read logfile and check it
 */
void
check(void)
{
	FILE *finput;
	int   i;
	int   input;
	int   mfd;
	unsigned char  key[41];
	int   keylen;
	unsigned char  lastkey[21];
	int   lastkeylen;
	int   line;
	unsigned char  mkey1[21];
	int   mkey1len;
	unsigned char  mkey2[21];
	int   mkey2len;
	char  msg[MAXLINE];
	int   msglen;

	/* open logfile */
	if (actionf & ST_IN)
		input = STDIN_FILENO;
	else if ( (input = open(logfile, O_RDONLY, 0)) == -1) {
		perror(logfile);
		exit(-1);
	}

	mfd = 0;	/* shutup gcc */

	/* open macfile */
	if (macfile)
		if ( (mfd = open(macfile, O_RDONLY, 0)) == -1) {
			perror(macfile);
			exit(-1);
		}

	/* read initial key (as ascii string) and tranlate it to binary */
	if ( (i = open(key0file, O_RDONLY, 0)) == -1) {
		perror(key0file);
		exit(-1);
	}
	if ( (keylen = read(i, key, 40)) == -1) {
		perror(key0file);
		exit(-1);
	}
	if (!keylen) {
		if (actionf & QUIET)
			eexit(1, "1\n");
		else
			eexit(1, "(1) %s: %s\n", key0file, corrupted);
	}
	key[keylen] = 0;
	asc2bin(key, key);
	keylen >>= 1;
	close(i);

	/* read last key */
	if ( (i = open(keyfile, O_RDONLY, 0)) == -1) {
		perror(keyfile);
		exit(-1);
	}
	if ( (lastkeylen = read(i, lastkey, 20)) == -1) {
		perror(keyfile);
		exit(-1);
	}
	if (!lastkeylen) {
		if (actionf & QUIET)
			eexit(1, "1\n");
		else
			eexit(1, "(1) %s: %s\n", keyfile, corrupted);
	}
	close(i);

	/* test both key lenghts */
	if (lastkeylen != keylen) {
		if (actionf & QUIET)
			eexit(1, "1\n");
		else
			eexit(1, "(1) %s and/or %s %s\n", key0file, keyfile,
			    corrupted);
	}

	/* check it */
	line = 1;
	finput = NULL;
	while ( (msglen = readline(input, msg, MAXLINE, &finput)) > 0) {
		if (macfile) {
			if ( ((mkey1len = mac2(key, keylen,
			    (unsigned char *) msg, msglen, mkey1)) < 0) ||
			    ((mkey2len = read(mfd, mkey2,
			    mkey1len)) < 0) ) {
				perror(macfile);
				exit(-1);
			}
			if ((mkey2len != mkey1len) || memcmp(mkey2, mkey1,
			    mkey1len)) {
				if (actionf & QUIET)
					eexit(1, "%i\n", line);
				else
					eexit(1, "(%i) %s %s on line %i\n",
					    line, logfile, corrupted, line);
			}
			line++;
		}
		if ( (keylen = mac(method, key, keylen,
		    (unsigned char *) msg, msglen, key)) == -1) {
			perror("fatal");
			exit(-1);
		}
	}

	if (finput != NULL)
		fclose(finput);

	if (macfile != NULL)
		close(mfd);

	if (i < 0) {
		fprintf(stderr, "error reading logs form %s : %s\n",
		    (actionf & ST_IN) ? "standard input" : logfile,
		    strerror(errno));
		exit(-1);
	}

	if (memcmp(lastkey, key, keylen)) {
		if (actionf & QUIET) 
			eexit(1, "1\n");
		else
			eexit(1, "(1) %s %s\n", logfile, corrupted);
	}
	if (actionf & QUIET)
		eexit(0, "0\n");
	else
		eexit(0, "(0) %s file is ok\n", logfile);
}
Beispiel #7
0
/*----------------------------------------------------------------------
|   NPT_NetworkInterface::GetNetworkInterfaces
+---------------------------------------------------------------------*/
NPT_Result
NPT_NetworkInterface::GetNetworkInterfaces(NPT_List<NPT_NetworkInterface*>& interfaces)
{
    IP_ADAPTER_ADDRESSES* iface_list = NULL;
    ULONG                 size = sizeof(IP_ADAPTER_INFO);

    // get the interface table
    for(;;) {
        iface_list = (IP_ADAPTER_ADDRESSES*)malloc(size);
        DWORD result = GetAdaptersAddresses(AF_INET,
                                            0,
                                            NULL,
                                            iface_list, &size);
        if (result == NO_ERROR) {
            break;
        } else {
            // free and try again
            free(iface_list);
            if (result != ERROR_BUFFER_OVERFLOW) {
                return NPT_FAILURE;
            }
        }
    }

    // iterate over the interfaces
    for (IP_ADAPTER_ADDRESSES* iface = iface_list; iface; iface = iface->Next) {
        // skip this interface if it is not up
        if (iface->OperStatus != IfOperStatusUp) continue;

        // get the interface type and mac address
        NPT_MacAddress::Type mac_type;
        switch (iface->IfType) {
            case IF_TYPE_ETHERNET_CSMACD:   mac_type = NPT_MacAddress::TYPE_ETHERNET; break;
            case IF_TYPE_SOFTWARE_LOOPBACK: mac_type = NPT_MacAddress::TYPE_LOOPBACK; break;
            case IF_TYPE_PPP:               mac_type = NPT_MacAddress::TYPE_PPP;      break;
            default:                        mac_type = NPT_MacAddress::TYPE_UNKNOWN;  break;
        }
        NPT_MacAddress mac(mac_type, iface->PhysicalAddress, iface->PhysicalAddressLength);

        // compute interface flags
        NPT_Flags flags = 0;
        if (!(iface->Flags & IP_ADAPTER_NO_MULTICAST)) flags |= NPT_NETWORK_INTERFACE_FLAG_MULTICAST;
        if (iface->IfType == IF_TYPE_SOFTWARE_LOOPBACK) flags |= NPT_NETWORK_INTERFACE_FLAG_LOOPBACK;
        if (iface->IfType == IF_TYPE_PPP) flags |= NPT_NETWORK_INTERFACE_FLAG_POINT_TO_POINT;

        // compute the unicast address (only the first one is supported for now)
        NPT_IpAddress primary_address;
        if (iface->FirstUnicastAddress) {
            if (iface->FirstUnicastAddress->Address.lpSockaddr == NULL) continue;
            if (iface->FirstUnicastAddress->Address.iSockaddrLength != sizeof(SOCKADDR_IN)) continue;
            SOCKADDR_IN* address = (SOCKADDR_IN*)iface->FirstUnicastAddress->Address.lpSockaddr;
            if (address->sin_family != AF_INET) continue;
            primary_address.Set(ntohl(address->sin_addr.s_addr));
        }
        NPT_IpAddress broadcast_address; // not supported yet
        NPT_IpAddress netmask;           // not supported yet

        // convert the interface name to UTF-8
        // BUG in Wine: FriendlyName is NULL
        unsigned int iface_name_length = (unsigned int)iface->FriendlyName?wcslen(iface->FriendlyName):0;
        char* iface_name = new char[4*iface_name_length+1];
        int result = WideCharToMultiByte(
            CP_UTF8, 0, iface->FriendlyName, iface_name_length,
            iface_name, 4*iface_name_length+1,
            NULL, NULL);
        if (result > 0) {
            iface_name[result] = '\0';
        } else {
            iface_name[0] = '\0';
        }

        // create an interface descriptor
        NPT_NetworkInterface* iface_object = new NPT_NetworkInterface(iface_name, mac, flags);
        NPT_NetworkInterfaceAddress iface_address(
            primary_address,
            broadcast_address,
            NPT_IpAddress::Any,
            netmask);
        iface_object->AddAddress(iface_address);  
    
        // cleanup 
        delete[] iface_name;
         
        // add the interface to the list
        interfaces.Add(iface_object);   
    }

    free(iface_list);
    return NPT_SUCCESS;
}
Beispiel #8
0
Datei: 07B.c Projekt: neotaso/pp
int main(){
  int i;
  for(i=0;i<TIME;i++)mac(N);
  printf("%f\n",mac(N));
  return 0;
}
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
   )
{
	const unsigned char* in = c;
	unsigned char* out = m;
	unsigned long long remaining;
	unsigned int i;
	uint8_t buf[16] = { 0 };

	__m128i W, Wtmp;
	__m128i block, Lup, Ldown;
	__m128i Lup1, Lup2, Lup3, Lup4, Lup5, Lup6, Lup7, Lup8;
	__m128i Ldown1, Ldown2, Ldown3, Ldown4, Ldown5, Ldown6, Ldown7, Ldown8;
	__m128i block1, block2, block3, block4;
	__m128i block5, block6, block7, block8;
	__m128i checksum = { 0 };
	__m128i LL = { 0 };
	__m128i expkey[11];
	__m128i decexpkey[11];

	/* key schedule */
	AES_set_encrypt_key(k, expkey);
	AES_set_decrypt_key(expkey, decexpkey);

	if (clen < 16) {
		return -1;
	}
	/* Set output length */
	*mlen = remaining = clen - 16;

	LL = AES_encrypt(LL, expkey); /* LL = AES(0) */
	Lup = LL;
	Ldown = gf128_mul3(gf128_mul3(LL)); /* Ldown = 3^2*LL */

	/* mac AD + nonce */
	W = mac(ad, adlen, npub, LL, expkey);

	/* Decrypt 8 blocks parallel */
	Lup8 = Lup;
	Ldown8 = Ldown;
	while (remaining > 8*16) {
		Ldown1 = gf128_mul2(Ldown8);
		Ldown2 = gf128_mul2(Ldown1);
		Ldown3 = gf128_mul2(Ldown2);
		Ldown4 = gf128_mul2(Ldown3);
		Ldown5 = gf128_mul2(Ldown4);
		Ldown6 = gf128_mul2(Ldown5);
		Ldown7 = gf128_mul2(Ldown6);
		Ldown8 = gf128_mul2(Ldown7);

		block1 = byte_swap(_mm_loadu_si128((__m128i*)in));
		block2 = byte_swap(_mm_loadu_si128((__m128i*)in+1));
		block3 = byte_swap(_mm_loadu_si128((__m128i*)in+2));
		block4 = byte_swap(_mm_loadu_si128((__m128i*)in+3));
		block5 = byte_swap(_mm_loadu_si128((__m128i*)in+4));
		block6 = byte_swap(_mm_loadu_si128((__m128i*)in+5));
		block7 = byte_swap(_mm_loadu_si128((__m128i*)in+6));
		block8 = byte_swap(_mm_loadu_si128((__m128i*)in+7));

		block1 ^= Ldown1;
		block2 ^= Ldown2;
		block3 ^= Ldown3;
		block4 ^= Ldown4;
		block5 ^= Ldown5;
		block6 ^= Ldown6;
		block7 ^= Ldown7;
		block8 ^= Ldown8;

		AES_DECRYPT8(block1,block2,block3,block4,block5,block6,block7,block8, decexpkey);

		Lup1 = gf128_mul2(Lup8);
		Lup2 = gf128_mul2(Lup1);
		Lup3 = gf128_mul2(Lup2);
		Lup4 = gf128_mul2(Lup3);
		Lup5 = gf128_mul2(Lup4);
		Lup6 = gf128_mul2(Lup5);
		Lup7 = gf128_mul2(Lup6);
		Lup8 = gf128_mul2(Lup7);

		rho_inv(block1, W, Wtmp);
		rho_inv(block2, W, Wtmp);
		rho_inv(block3, W, Wtmp);
		rho_inv(block4, W, Wtmp);
		rho_inv(block5, W, Wtmp);
		rho_inv(block6, W, Wtmp);
		rho_inv(block7, W, Wtmp);
		rho_inv(block8, W, Wtmp);

		AES_DECRYPT8(block1,block2,block3,block4,block5,block6,block7,block8, decexpkey);

		block1 ^= Lup1;
		block2 ^= Lup2;
		block3 ^= Lup3;
		block4 ^= Lup4;
		block5 ^= Lup5;
		block6 ^= Lup6;
		block7 ^= Lup7;
		block8 ^= Lup8;

		checksum ^= block1 ^ block2 ^ block3 ^ block4;
		checksum ^= block5 ^ block6 ^ block7 ^ block8;

		_mm_storeu_si128((__m128i*)out, byte_swap(block1));
		_mm_storeu_si128((__m128i*)out+1, byte_swap(block2));
		_mm_storeu_si128((__m128i*)out+2, byte_swap(block3));
		_mm_storeu_si128((__m128i*)out+3, byte_swap(block4));
		_mm_storeu_si128((__m128i*)out+4, byte_swap(block5));
		_mm_storeu_si128((__m128i*)out+5, byte_swap(block6));
		_mm_storeu_si128((__m128i*)out+6, byte_swap(block7));
		_mm_storeu_si128((__m128i*)out+7, byte_swap(block8));

		in += 8*16;
		out += 8*16;
		remaining -= 8*16;
	}

	Lup = Lup8;
	Ldown = Ldown8;
	
	/* Decrypt */
	while (remaining > 16) {
		Lup = gf128_mul2(Lup);
		Ldown = gf128_mul2(Ldown);

		block = byte_swap(_mm_loadu_si128((__m128i*)in));
		block ^= Ldown;
		block = AES_decrypt(block, decexpkey);

		/* (X,W') = rho^-1(block, W) */
		rho_inv(block, W, Wtmp);

		block = AES_decrypt(block, decexpkey);
		block ^= Lup;
		checksum ^= block;

		_mm_storeu_si128((__m128i*)out, byte_swap(block));

		in += 16;
		out += 16;
		remaining -= 16;
	}

	Lup = gf128_mul7(Lup);
	Ldown = gf128_mul7(Ldown);
	if (remaining < 16) {
		Lup = gf128_mul7(Lup);
		Ldown = gf128_mul7(Ldown);
	}

	block = _mm_loadu_si128((__m128i*)in);
	block = byte_swap(block);
	block ^= Ldown;
	block = AES_decrypt(block, decexpkey);

	/* (X,W') = rho^-1(block, W) */
	rho_inv(block, W, Wtmp);

	block = AES_decrypt(block, decexpkey);
	block ^= Lup;
	/* block now contains M[l] = M[l+1] */

	checksum ^= block;
	/* checksum now contains M*[l] */
	in += 16;

	/* output last (maybe partial) plaintext block */
	_mm_storeu_si128((__m128i*)buf, byte_swap(checksum));
	memcpy(out, buf, remaining);

	/* work on M[l+1] */
	Lup = gf128_mul2(Lup);
	Ldown = gf128_mul2(Ldown);

	block ^= Lup;
	block = AES_encrypt(block, expkey);
	/* (Y,W') = rho(block, W) */
	rho(block, W, Wtmp);

	block = AES_encrypt(block, expkey);
	block ^= Ldown;
	/* block now contains C'[l+1] */

	_mm_storeu_si128((__m128i*)buf, byte_swap(block));
	if (memcmp(in, buf, remaining) != 0) {
		return -1;
	} 

	if (remaining < 16) {
		_mm_storeu_si128((__m128i*)buf, byte_swap(checksum));
		if (buf[remaining] != 0x80) {
			return -1;
		}
		for (i = remaining+1; i < 16; i++) {
			if (buf[i] != 0) {
				return -1;
			}
		}
	}

	return 0;
}
bool MessageAuthenticationCode::Verify(const byte *macIn)
{
	SecByteBlock mac(DigestSize());
	Final(mac);
	return memcmp(mac, macIn, DigestSize()) == 0;
}
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
     )
{
	const unsigned char* in = m;
	unsigned char* out = c;
	unsigned long long remaining = mlen;
	uint8_t buf[16] = { 0 };

	__m128i W, Wtmp;
	__m128i block, Lup, Ldown;
	__m128i Lup1, Lup2, Lup3, Lup4, Lup5, Lup6, Lup7, Lup8;
	__m128i Ldown1, Ldown2, Ldown3, Ldown4, Ldown5, Ldown6, Ldown7, Ldown8;
	__m128i block1, block2, block3, block4;
	__m128i block5, block6, block7, block8;
	__m128i checksum = { 0 };
	__m128i LL = { 0 };
	__m128i expkey[11];

	/* key schedule */
	AES_set_encrypt_key(k, expkey);

	/* set ouput length */
	*clen = mlen + 16;

	LL = AES_encrypt(LL, expkey); /* LL = AES(0) */
	Lup = LL;
	Ldown = gf128_mul3(gf128_mul3(LL)); /* Ldown = 3^2*LL */

	/* mac AD + nonce */
	W = mac(ad, adlen, npub, LL, expkey);

	Lup8 = Lup;
	Ldown8 = Ldown;
	while (remaining > 8*16) {
		Lup1 = gf128_mul2(Lup8);
		Lup2 = gf128_mul2(Lup1);
		Lup3 = gf128_mul2(Lup2);
		Lup4 = gf128_mul2(Lup3);
		Lup5 = gf128_mul2(Lup4);
		Lup6 = gf128_mul2(Lup5);
		Lup7 = gf128_mul2(Lup6);
		Lup8 = gf128_mul2(Lup7);

		block1 = byte_swap(_mm_loadu_si128((__m128i*)in));
		block2 = byte_swap(_mm_loadu_si128((__m128i*)in+1));
		block3 = byte_swap(_mm_loadu_si128((__m128i*)in+2));
		block4 = byte_swap(_mm_loadu_si128((__m128i*)in+3));
		block5 = byte_swap(_mm_loadu_si128((__m128i*)in+4));
		block6 = byte_swap(_mm_loadu_si128((__m128i*)in+5));
		block7 = byte_swap(_mm_loadu_si128((__m128i*)in+6));
		block8 = byte_swap(_mm_loadu_si128((__m128i*)in+7));

		checksum ^= block1 ^ block2 ^ block3 ^ block4;
		checksum ^= block5 ^ block6 ^ block7 ^ block8;

		block1 ^= Lup1;
		block2 ^= Lup2;
		block3 ^= Lup3;
		block4 ^= Lup4;
		block5 ^= Lup5;
		block6 ^= Lup6;
		block7 ^= Lup7;
		block8 ^= Lup8;

		AES_ENCRYPT8(block1,block2,block3,block4,block5,block6,block7,block8, expkey);

		Ldown1 = gf128_mul2(Ldown8);
		Ldown2 = gf128_mul2(Ldown1);
		Ldown3 = gf128_mul2(Ldown2);
		Ldown4 = gf128_mul2(Ldown3);
		Ldown5 = gf128_mul2(Ldown4);
		Ldown6 = gf128_mul2(Ldown5);
		Ldown7 = gf128_mul2(Ldown6);
		Ldown8 = gf128_mul2(Ldown7);

		rho(block1, W, Wtmp);
		rho(block2, W, Wtmp);
		rho(block3, W, Wtmp);
		rho(block4, W, Wtmp);
		rho(block5, W, Wtmp);
		rho(block6, W, Wtmp);
		rho(block7, W, Wtmp);
		rho(block8, W, Wtmp);

		AES_ENCRYPT8(block1,block2,block3,block4,block5,block6,block7,block8, expkey);

		block1 ^= Ldown1;
		block2 ^= Ldown2;
		block3 ^= Ldown3;
		block4 ^= Ldown4;
		block5 ^= Ldown5;
		block6 ^= Ldown6;
		block7 ^= Ldown7;
		block8 ^= Ldown8;

		_mm_storeu_si128((__m128i*)out, byte_swap(block1));
		_mm_storeu_si128((__m128i*)out+1, byte_swap(block2));
		_mm_storeu_si128((__m128i*)out+2, byte_swap(block3));
		_mm_storeu_si128((__m128i*)out+3, byte_swap(block4));
		_mm_storeu_si128((__m128i*)out+4, byte_swap(block5));
		_mm_storeu_si128((__m128i*)out+5, byte_swap(block6));
		_mm_storeu_si128((__m128i*)out+6, byte_swap(block7));
		_mm_storeu_si128((__m128i*)out+7, byte_swap(block8));

		in += 8*16;
		out += 8*16;
		remaining -= 8*16;
	}

	Lup = Lup8;
	Ldown = Ldown8;

	while (remaining > 16) {
		Lup = gf128_mul2(Lup);
		Ldown = gf128_mul2(Ldown);

		block = _mm_loadu_si128((__m128i*)in);
		block = byte_swap(block);
		checksum ^= block;
		block ^= Lup;
		block = AES_encrypt(block, expkey);

		/* (Y,W') = rho(block, W) */
		rho(block, W, Wtmp);

		block = AES_encrypt(block, expkey);
		block ^= Ldown;
		_mm_storeu_si128((__m128i*)out, byte_swap(block));

		in += 16;
		out += 16;
		remaining -= 16;
	}

	/* XOR checksum into last block (padded if necessary) */
	memcpy(buf, in, remaining);

	Lup = gf128_mul7(Lup);
	Ldown = gf128_mul7(Ldown);
	if (remaining < 16) {
		buf[remaining] = 0x80;
		Lup = gf128_mul7(Lup);
		Ldown = gf128_mul7(Ldown);
	}
	block = _mm_loadu_si128((__m128i*)buf);
	block = byte_swap(block);
	checksum ^= block;

	block = checksum ^ Lup;
	block = AES_encrypt(block, expkey);

	/* (Y,W') = rho(block, W) */
	rho(block, W, Wtmp);

	block = AES_encrypt(block, expkey);
	block ^= Ldown;
	_mm_storeu_si128((__m128i*)out, byte_swap(block));
	out += 16;

	/* could stop here if remaining == 0 */
	if (remaining == 0) return 0;

	/* Duplicate last block */
	Lup = gf128_mul2(Lup);
	Ldown = gf128_mul2(Ldown);

	block = checksum ^ Lup;
	block = AES_encrypt(block, expkey);

	/* (Y,W') = rho(block, W) */
	rho(block, W, Wtmp);

	block = AES_encrypt(block, expkey);
	block ^= Ldown;

	_mm_storeu_si128((__m128i*)buf, byte_swap(block));
	memcpy(out, buf, remaining);

	return 0;
}
Beispiel #12
0
static MAStreamConn& getStreamConn(MAHandle conn) {
	MAConn& mac(getConn(conn));
	MYASSERT(mac.type == eStreamConn, ERR_CONN_NOT_STREAM);
	return (MAStreamConn&)mac;
}
net_interface_imp::net_interface_imp()
{
    total_devs = 0;

    if (pcap_findalldevs(&all_devs, err_buf) == -1) // Retrieve the device list on the local machine.
    {
        log_imp_ref->post_log_msg(LOGGING_LEVEL_ERROR, "pcap_findalldevs error %s", err_buf);
    }
    else
    {
        for (dev = all_devs; dev; dev = dev->next)
        {
            // store the valid IPv4 addresses associated with the device
            std::vector<std::string> device_ip_addresses;
            pcap_addr_t * dev_addr;
            for (dev_addr = dev->addresses; dev_addr != NULL; dev_addr = dev_addr->next)
            {
                if (dev_addr->addr->sa_family == AF_INET && dev_addr->addr)
                {
                    char ip_str[INET_ADDRSTRLEN] = { 0 };
                    inet_ntop(AF_INET, &((struct sockaddr_in *)dev_addr->addr)->sin_addr, ip_str, INET_ADDRSTRLEN);
                    device_ip_addresses.push_back(std::string(ip_str));
                }
            }

            all_ip_addresses.push_back(device_ip_addresses);
            total_devs++;
        }

        /****************************** Find Adapter Info ***************************/
        IP_ADAPTER_INFO * AdapterInfo;
        ULONG AIS;
        DWORD status;
        AdapterInfo = (IP_ADAPTER_INFO *)calloc(total_devs, sizeof(IP_ADAPTER_INFO));
        AIS = sizeof(IP_ADAPTER_INFO) * total_devs;

        if (GetAdaptersInfo(AdapterInfo, &AIS) == ERROR_BUFFER_OVERFLOW)
        {
            free(AdapterInfo);
            AdapterInfo = (IP_ADAPTER_INFO *)calloc(1, AIS);

            if (AdapterInfo == NULL)
            {
                log_imp_ref->post_log_msg(LOGGING_LEVEL_ERROR, "Allocating memory needed to call GetAdaptersinfo.", dev->name);
                return;
            }

            status = GetAdaptersInfo(AdapterInfo, &AIS);
            if (status != ERROR_SUCCESS)
            {
                log_imp_ref->post_log_msg(LOGGING_LEVEL_ERROR, "GetAdaptersInfo call in net_interface_imp.cpp failed.", dev->name);
                free(AdapterInfo);
                return;
            }
        }

        PIP_ADAPTER_INFO pAdapterInfo = NULL;
        for (dev = all_devs; dev; dev = dev->next)
        {
            uint64_t dev_mac_addr = 0;
            for (pAdapterInfo = AdapterInfo; pAdapterInfo != NULL; pAdapterInfo = pAdapterInfo->Next)
            {
                if (strstr(dev->name, pAdapterInfo->AdapterName) != 0)
                {
                    utility::MacAddr mac(
                                         pAdapterInfo->Address[0], pAdapterInfo->Address[1],
                                         pAdapterInfo->Address[2], pAdapterInfo->Address[3],
                                         pAdapterInfo->Address[4], pAdapterInfo->Address[5]);
                    dev_mac_addr = mac.tovalue();
                    break;
                }
            }
            all_mac_addresses.push_back(dev_mac_addr);
        }
        free(AdapterInfo);
    }

    if (total_devs == 0)
    {
        log_imp_ref->post_log_msg(LOGGING_LEVEL_ERROR, "No interfaces found! Make sure WinPcap is installed.");
    }
    pcap_interface = nullptr;
}
Beispiel #14
0
void options::parse(int argc, char* argv[])
{
    addp::options::parse(argc, argv);

    if(_vm.count("action") == 0)
    {
        std::cerr << "No action given" << std::endl << std::endl;
        usage();
        std::exit(1);
    }

    /*
     *  discover [device]
     *  reboot <device> [passwd]
     *  config <device> <ip> <netmask> <gateway> [passwd]
     *  dhcp <device> <on|off> [passwd]
     */

    size_t min = 0;
    size_t max = 0;

    const std::string& action = this->action();

    if(action == "discover")
    {
        min = 0;
        max = 0;
    }
    else
    {
        // must have a specific device address for further actions
        if(boost::lexical_cast<addp::mac_address>(mac()) == addp::MAC_ADDR_BROADCAST)
        {
            std::cerr << "Please select a device's mac address" << std::endl << std::endl;
            usage();
            std::exit(1);
        }

        if(action == "reboot")
        {
            min = 0;
            max = 1;
        }
        else if(action == "config")
        {
            min = 3;
            max = 4;
        }
        else if(action == "dhcp")
        {
            min = 1;
            max = 2;
        }
        else
        {
            std::cerr << "Unknown action \"" << action << "\"" << std::endl << std::endl;
            usage();
            std::exit(1);
        }
    }

    size_t count = args().size();
    if(count < min || count > max)
    {
        usage();
        std::exit(1);
    }

    // optional password is always the last argument
    _password_index = max - 1;
}
Beispiel #15
0
vmxnet3::vmxnet3(hw::PCI_Device& d, const uint16_t mtu) :
    Link(Link_protocol{{this, &vmxnet3::transmit}, mac()}, bufstore_),
    m_pcidev(d), m_mtu(mtu), bufstore_{1024, buffer_size_for_mtu(mtu)}
{
  INFO("vmxnet3", "Driver initializing (rev=%#x)", d.rev_id());
  assert(d.rev_id() == REVISION_ID);

  // find and store capabilities
  d.parse_capabilities();
  // find BARs etc.
  d.probe_resources();

  if (d.msix_cap())
  {
    d.init_msix();
    uint8_t msix_vectors = d.get_msix_vectors();
    INFO2("[x] Device has %u MSI-X vectors", msix_vectors);
    assert(msix_vectors >= 3);
    if (msix_vectors > 2 + NUM_RX_QUEUES) msix_vectors = 2 + NUM_RX_QUEUES;

    for (int i = 0; i < msix_vectors; i++)
    {
      auto irq = Events::get().subscribe(nullptr);
      this->irqs.push_back(irq);
      d.setup_msix_vector(SMP::cpu_id(), IRQ_BASE + irq);
    }

    Events::get().subscribe(irqs[0], {this, &vmxnet3::msix_evt_handler});
    Events::get().subscribe(irqs[1], {this, &vmxnet3::msix_xmit_handler});
    for (int q = 0; q < NUM_RX_QUEUES; q++)
    Events::get().subscribe(irqs[2 + q], {this, &vmxnet3::msix_recv_handler});
  }
  else {
    assert(0 && "This driver does not support legacy IRQs");
  }

  // dma areas
  this->iobase = d.get_bar(PCI_BAR_VD);
  assert(this->iobase);
  this->ptbase = d.get_bar(PCI_BAR_PT);
  assert(this->ptbase);

  // verify and select version
  bool ok = check_version();
  assert(ok);

  // reset device
  ok = reset();
  assert(ok);

  // get mac address
  retrieve_hwaddr();

  // check link status
  auto link_spd = check_link();
  if (link_spd) {
    INFO2("Link up at %u Mbps", link_spd);
  }
  else {
    INFO2("LINK DOWN! :(");
    return;
  }

  // set MAC
  set_hwaddr(this->hw_addr);

  // initialize DMA areas
  this->dma = (vmxnet3_dma*) memalign(VMXNET3_DMA_ALIGN, sizeof(vmxnet3_dma));
  memset(this->dma, 0, sizeof(vmxnet3_dma));

  auto& queues = dma->queues;
  // setup tx queues
  queues.tx.cfg.desc_address = (uintptr_t) &dma->tx_desc;
  queues.tx.cfg.comp_address = (uintptr_t) &dma->tx_comp;
  queues.tx.cfg.num_desc     = vmxnet3::NUM_TX_DESC;
  queues.tx.cfg.num_comp     = VMXNET3_NUM_TX_COMP;
  queues.tx.cfg.intr_index   = 1;
  // temp rxq buffer storage
  memset(tx.buffers, 0, sizeof(tx.buffers));

  // setup rx queues
  for (int q = 0; q < NUM_RX_QUEUES; q++)
  {
    memset(rx[q].buffers, 0, sizeof(rx[q].buffers));
    rx[q].desc0 = &dma->rx0_desc[0];
    rx[q].desc1 = &dma->rx1_desc[0];
    rx[q].comp  = &dma->rx_comp[0];
    rx[q].index = q;

    auto& queue = queues.rx[q];
    queue.cfg.desc_address[0] = (uintptr_t) rx[q].desc0;
    queue.cfg.desc_address[1] = (uintptr_t) rx[q].desc1;
    queue.cfg.comp_address    = (uintptr_t) rx[q].comp;
    queue.cfg.num_desc[0]  = vmxnet3::NUM_RX_DESC;
    queue.cfg.num_desc[1]  = vmxnet3::NUM_RX_DESC;
    queue.cfg.num_comp     = VMXNET3_NUM_RX_COMP;
    queue.cfg.driver_data_len = sizeof(vmxnet3_rx_desc)
                          + 2 * sizeof(vmxnet3_rx_desc);
    queue.cfg.intr_index = 2 + q;
  }

  auto& shared = dma->shared;
  // setup shared physical area
  shared.magic = VMXNET3_REV1_MAGIC;
  shared.misc.guest_info.arch =
      (sizeof(void*) == 4) ? GOS_BITS_32_BITS : GOS_BITS_64_BITS;
  shared.misc.guest_info.type = GOS_TYPE_LINUX;
  shared.misc.version         = VMXNET3_VERSION_MAGIC;
  shared.misc.version_support     = 1;
  shared.misc.upt_version_support = 1;
  shared.misc.upt_features        = UPT1_F_RXVLAN;
  shared.misc.driver_data_address = (uintptr_t) &dma;
  shared.misc.queue_desc_address  = (uintptr_t) &dma->queues;
  shared.misc.driver_data_len     = sizeof(vmxnet3_dma);
  shared.misc.queue_desc_len      = sizeof(vmxnet3_queues);
  shared.misc.mtu = packet_len(); // 60-9000
  shared.misc.num_tx_queues  = 1;
  shared.misc.num_rx_queues  = NUM_RX_QUEUES;
  shared.interrupt.mask_mode = VMXNET3_IT_AUTO | (VMXNET3_IMM_AUTO << 2);
  shared.interrupt.num_intrs = 2 + NUM_RX_QUEUES;
  shared.interrupt.event_intr_index = 0;
  memset(shared.interrupt.moderation_level, UPT1_IML_ADAPTIVE, VMXNET3_MAX_INTRS);
  shared.interrupt.control   = 0x1; // disable all
  shared.rx_filter.mode =
      VMXNET3_RXM_UCAST | VMXNET3_RXM_BCAST | VMXNET3_RXM_ALL_MULTI;

  // location of shared area to device
  uintptr_t shabus = (uintptr_t) &shared;
  mmio_write32(this->iobase + 0x10, shabus); // shared low
  mmio_write32(this->iobase + 0x18, 0x0);    // shared high

  // activate device
  int status = command(VMXNET3_CMD_ACTIVATE_DEV);
  if (status) {
    assert(0 && "Failed to activate device");
  }

  // initialize and fill RX queue...
  for (int q = 0; q < NUM_RX_QUEUES; q++)
  {
    refill(rx[q]);
  }

  // deferred transmit
  this->deferred_irq = Events::get().subscribe(handle_deferred);

  // enable interrupts
  enable_intr(0);
  enable_intr(1);
  for (int q = 0; q < NUM_RX_QUEUES; q++)
      enable_intr(2 + q);
}
Beispiel #16
0
bool IntegrityCheckModule(const char *moduleFilename, const byte *expectedModuleMac, SecByteBlock *pActualMac, unsigned long *pMacFileLocation)
{
	std::auto_ptr<MessageAuthenticationCode> mac(NewIntegrityCheckingMAC());
	unsigned int macSize = mac->DigestSize();

	SecByteBlock tempMac;
	SecByteBlock &actualMac = pActualMac ? *pActualMac : tempMac;
	actualMac.resize(macSize);

	unsigned long tempLocation;
	unsigned long &macFileLocation = pMacFileLocation ? *pMacFileLocation : tempLocation;
	macFileLocation = 0;

	HashFilter verifier(*mac, new ArraySink(actualMac, actualMac.size()));
//	FileSink verifier("c:\\dt.tmp");
	FileStore file(moduleFilename);

#ifdef CRYPTOPP_WIN32_AVAILABLE
	// try to hash from memory first
	HMODULE h = GetModuleHandle(moduleFilename);
	const byte *memBase = (const byte *)h;
	IMAGE_DOS_HEADER *ph = (IMAGE_DOS_HEADER *)h;
	IMAGE_NT_HEADERS *phnt = (IMAGE_NT_HEADERS *)((byte *)h + ph->e_lfanew);
	IMAGE_SECTION_HEADER *phs = IMAGE_FIRST_SECTION(phnt);
	DWORD nSections = phnt->FileHeader.NumberOfSections;
	DWORD currentFilePos = 0;

	while (nSections--)
	{
		switch (phs->Characteristics)
		{
		default:
			break;
		case IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ:
		case IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ:
			unsigned int sectionSize = STDMIN(phs->SizeOfRawData, phs->Misc.VirtualSize);
			const byte *sectionMemStart = memBase + phs->VirtualAddress;
			unsigned int sectionFileStart = phs->PointerToRawData;
			unsigned int subSectionStart = 0, nextSubSectionStart;

			do
			{
				const byte *subSectionMemStart = sectionMemStart + subSectionStart;
				unsigned int subSectionFileStart = sectionFileStart + subSectionStart;
				unsigned int subSectionSize = sectionSize - subSectionStart;
				nextSubSectionStart = 0;

				unsigned int entriesToReadFromDisk[] = {IMAGE_DIRECTORY_ENTRY_IMPORT, IMAGE_DIRECTORY_ENTRY_IAT};
				for (unsigned int i=0; i<sizeof(entriesToReadFromDisk)/sizeof(entriesToReadFromDisk[0]); i++)
				{
					const IMAGE_DATA_DIRECTORY &entry = phnt->OptionalHeader.DataDirectory[entriesToReadFromDisk[i]];
					const byte *entryMemStart = memBase + entry.VirtualAddress;
					if (subSectionMemStart <= entryMemStart && entryMemStart < subSectionMemStart + subSectionSize)
					{
						subSectionSize = entryMemStart - subSectionMemStart;
						nextSubSectionStart = entryMemStart - sectionMemStart + entry.Size;
					}
				}

				file.TransferTo(verifier, subSectionFileStart - currentFilePos);
				if (subSectionMemStart <= expectedModuleMac && expectedModuleMac < subSectionMemStart + subSectionSize)
				{
					// skip over the MAC
					verifier.Put(subSectionMemStart, expectedModuleMac - subSectionMemStart);
					verifier.Put(expectedModuleMac + macSize, subSectionSize - macSize - (expectedModuleMac - subSectionMemStart));
					macFileLocation = subSectionFileStart + (expectedModuleMac - subSectionMemStart);
				}
				else
					verifier.Put(subSectionMemStart, subSectionSize);
				file.Skip(subSectionSize);
				currentFilePos = subSectionFileStart + subSectionSize;
				subSectionStart = nextSubSectionStart;
			} while (nextSubSectionStart != 0);
		}
		phs++;
	}
#endif
	file.TransferAllTo(verifier);

#ifdef CRYPTOPP_WIN32_AVAILABLE
	// if that fails (could be caused by debug breakpoints or DLL base relocation modifying image in memory),
	// hash from disk instead
	if (memcmp(expectedModuleMac, actualMac, macSize) != 0)
	{
		OutputDebugString("In memory integrity check failed. This may be caused by debug breakpoints or DLL relocation.\n");
		file.Initialize(MakeParameters("InputFileName", moduleFilename));
		verifier.Detach(new ArraySink(actualMac, actualMac.size()));
		if (macFileLocation)
		{
			file.TransferTo(verifier, macFileLocation);
			file.Skip(macSize);
		}
		file.TransferAllTo(verifier);
	}
#endif

	if (memcmp(expectedModuleMac, actualMac, macSize) == 0)
		return true;

#ifdef CRYPTOPP_WIN32_AVAILABLE
	std::string hexMac;
	HexEncoder(new StringSink(hexMac)).PutMessageEnd(actualMac, actualMac.size());
	OutputDebugString((moduleFilename + (" integrity check failed. Actual MAC is: " + hexMac) + "\n").c_str());
#endif
	return false;
}
////////////////////////////////////////////////////////////////////////////////
// Simulation::init_terminals                                                 //
//                                                                            //
// initializes terminals for a new iteration                                  //
////////////////////////////////////////////////////////////////////////////////
void Simulation::init_terminals(){

	adapt_struct adapt (sim_par.get_TxMode(), sim_par.get_AdaptMode(),
			sim_par.get_TxPowerMax(), sim_par.get_TxPowerMin(),
			sim_par.get_TxPowerStepUp(),sim_par.get_TxPowerStepDown(),
			sim_par.get_TargetPER(),sim_par.get_LAMaxSucceedCounter(),
			sim_par.get_LAFailLimit(), sim_par.get_UseRxMode());

	mac_struct mac(sim_par.get_RetryLimit(), sim_par.get_RTSThreshold(),
			sim_par.get_FragmentationThresh(), sim_par.get_QueueSize(),
			sim_par.get_set_BA_agg());

	PHY_struct phy(sim_par.get_NoiseVariance(), sim_par.get_CCASensitivity());

	traffic_struct tr_dl(sim_par.get_DataRateDL(), sim_par.get_PacketLength(),
			sim_par.get_ArrivalTime());

	traffic_struct tr_ul(sim_par.get_DataRateUL(), sim_par.get_PacketLength(),
			sim_par.get_ArrivalTime());

	timestamp tr_time = sim_par.get_TransientTime();

	for (unsigned i = 0; i < sim_par.get_NumberAPs(); i++) {
		AccessPoint* ap = new AccessPoint(sim_par.get_APPosition(i), &main_sch, ch,
				&randgent, &log, mac, phy, tr_time);
		term_vector.push_back(ap);

		if (log(log_type::setup))
			log << *ap << " created at position " << sim_par.get_APPosition(i)
			<< '\n' << endl;
	}


	double cell_radius = sim_par.get_Radius();

	// Array containing the amount of connections belonging to each AC
	unsigned ppArray[5] = {round(2*sim_par.get_ppAC_BK()*sim_par.get_NumberStas()),
					  	   round(2*sim_par.get_ppAC_BE()*sim_par.get_NumberStas()),
						   round(2*sim_par.get_ppAC_VI()*sim_par.get_NumberStas()),
						   round(2*sim_par.get_ppAC_VO()*sim_par.get_NumberStas()),
						   round(2*sim_par.get_ppLegacy()*sim_par.get_NumberStas())};
	unsigned sum = 0;
	for(int k = 0; k < 5; k++) {
		sum = sum + ppArray[k];
	}
	int diff = sum - 2*sim_par.get_NumberStas();
	if(diff > 0) {
		for(int k = 0; k < 5; k++) {
			while(ppArray[k] > 0 && diff > 0){
				ppArray[k]--;
				diff--;
			}
		}
	}
	if(diff < 0)	{
		ppArray[0] = (-1)*diff;
	}
	vector<int> noZe_ppArray;
	accCat MS_AC = AC_BK;
	accCat AP_AC = AC_BK;
	int idx = 0;

	for (unsigned i = 0; i < sim_par.get_NumberStas(); i++) {

		// Vector containing elements of ppArray that are non-zero
		noZe_ppArray.clear();
		for(int k = 0; k < 5; k++) {
			if(ppArray[k] != 0) noZe_ppArray.push_back(k);
		}
		// Choose one access category randomly
		if(noZe_ppArray.size() != 0) {
			idx = randgent.from_vec(noZe_ppArray);
			MS_AC = allACs[idx];
			ppArray[idx]--;
		}

		// if just one mobile station, then distance = cell radius
		Position pos(cell_radius,0);
		// else Stas are uniformly distributed
		if (sim_par.get_NumberStas() > 1) {
			do {
				pos = Position (randgent.uniform(-cell_radius,cell_radius),
						randgent.uniform(-cell_radius,cell_radius));
			} while(pos.distance() > cell_radius);
		}

		MobileStation* ms = new MobileStation(pos, &main_sch, ch, &randgent,
				&log, mac, phy, tr_time);
		term_vector.push_back(ms);

		double min_dist = HUGE_VAL;
		int min_index = -1;
		for (unsigned count = 0; count < sim_par.get_NumberAPs(); count++) {
			double dist = pos.distance(sim_par.get_APPosition(count));
			if (dist < min_dist) {
				min_dist = dist;
				min_index = count;
			}
		}

		// Vector containing elements of ppArray that are non-zero
		noZe_ppArray.clear();
		for(int k = 0; k < 5; k++) {
			if(ppArray[k] != 0) noZe_ppArray.push_back(k);
		}
		// Choose one access category randomly
		if(noZe_ppArray.size() != 0) {
			idx = randgent.from_vec(noZe_ppArray);
			AP_AC = allACs[idx];
			ppArray[idx]--;
		}

		// Connect mobile terminal to closest AP
		connect_two(term_vector[min_index], AP_AC, ms, MS_AC, ch, adapt, tr_dl, tr_ul);

		if (log(log_type::setup))
			log << *ms << " created at position " << pos << " with distance "
			<< min_dist << " m to " << *term_vector[min_index]
		    << "\nMobile station AC: "<< MS_AC << ". Access Point AC: "
			<< AP_AC << "." <<endl;
	}


	if (log(log_type::setup)) log_connections();
}
Beispiel #18
0
bool IntegrityCheckModule(const char *moduleFilename, const byte *expectedModuleMac, SecByteBlock *pActualMac, unsigned long *pMacFileLocation)
{
	std::auto_ptr<MessageAuthenticationCode> mac(NewIntegrityCheckingMAC());
	unsigned int macSize = mac->DigestSize();

	SecByteBlock tempMac;
	SecByteBlock &actualMac = pActualMac ? *pActualMac : tempMac;
	actualMac.resize(macSize);

	unsigned long tempLocation;
	unsigned long &macFileLocation = pMacFileLocation ? *pMacFileLocation : tempLocation;
	macFileLocation = 0;

	MeterFilter verifier(new HashFilter(*mac, new ArraySink(actualMac, actualMac.size())));
//	MeterFilter verifier(new FileSink("c:\\dt.tmp"));
	std::ifstream moduleStream;

#ifdef CRYPTOPP_WIN32_AVAILABLE
	HMODULE h;
	{
	char moduleFilenameBuf[MAX_PATH] = "";
	if (moduleFilename == NULL)
	{
#if (_MSC_VER >= 1400 && !defined(_STLPORT_VERSION))	// ifstream doesn't support wide filename on other compilers
		wchar_t wideModuleFilename[MAX_PATH];
		if (GetModuleFileNameW(s_hModule, wideModuleFilename, MAX_PATH) > 0)
		{
			moduleStream.open(wideModuleFilename, std::ios::in | std::ios::binary);
			h = GetModuleHandleW(wideModuleFilename);
		}
		else
#endif
		{
			GetModuleFileNameA(s_hModule, moduleFilenameBuf, MAX_PATH);
			moduleFilename = moduleFilenameBuf;
		}
	}
#endif
	if (moduleFilename != NULL)
	{
			moduleStream.open(moduleFilename, std::ios::in | std::ios::binary);
#ifdef CRYPTOPP_WIN32_AVAILABLE
			h = GetModuleHandleA(moduleFilename);
			moduleFilename = NULL;
	}
#endif
	}

	if (!moduleStream)
	{
#ifdef CRYPTOPP_WIN32_AVAILABLE
		OutputDebugString("Crypto++ DLL integrity check failed. Cannot open file for reading.");
#endif
		return false;
	}
	FileStore file(moduleStream);

#ifdef CRYPTOPP_WIN32_AVAILABLE
	// try to hash from memory first
	const byte *memBase = (const byte *)h;
	const IMAGE_DOS_HEADER *ph = (IMAGE_DOS_HEADER *)memBase;
	const IMAGE_NT_HEADERS *phnt = (IMAGE_NT_HEADERS *)(memBase + ph->e_lfanew);
	const IMAGE_SECTION_HEADER *phs = IMAGE_FIRST_SECTION(phnt);
	DWORD nSections = phnt->FileHeader.NumberOfSections;
	size_t currentFilePos = 0;

	size_t checksumPos = (byte *)&phnt->OptionalHeader.CheckSum - memBase;
	size_t checksumSize = sizeof(phnt->OptionalHeader.CheckSum);
	size_t certificateTableDirectoryPos = (byte *)&phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY] - memBase;
	size_t certificateTableDirectorySize = sizeof(phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY]);
	size_t certificateTablePos = phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].VirtualAddress;
	size_t certificateTableSize = phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].Size;

	verifier.AddRangeToSkip(0, checksumPos, checksumSize);
	verifier.AddRangeToSkip(0, certificateTableDirectoryPos, certificateTableDirectorySize);
	verifier.AddRangeToSkip(0, certificateTablePos, certificateTableSize);

	while (nSections--)
	{
		switch (phs->Characteristics)
		{
		default:
			break;
		case IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ:
		case IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ:
			unsigned int sectionSize = STDMIN(phs->SizeOfRawData, phs->Misc.VirtualSize);
			const byte *sectionMemStart = memBase + phs->VirtualAddress;
			unsigned int sectionFileStart = phs->PointerToRawData;
			size_t subSectionStart = 0, nextSubSectionStart;

			do
			{
				const byte *subSectionMemStart = sectionMemStart + subSectionStart;
				size_t subSectionFileStart = sectionFileStart + subSectionStart;
				size_t subSectionSize = sectionSize - subSectionStart;
				nextSubSectionStart = 0;

				unsigned int entriesToReadFromDisk[] = {IMAGE_DIRECTORY_ENTRY_IMPORT, IMAGE_DIRECTORY_ENTRY_IAT};
				for (unsigned int i=0; i<sizeof(entriesToReadFromDisk)/sizeof(entriesToReadFromDisk[0]); i++)
				{
					const IMAGE_DATA_DIRECTORY &entry = phnt->OptionalHeader.DataDirectory[entriesToReadFromDisk[i]];
					const byte *entryMemStart = memBase + entry.VirtualAddress;
					if (subSectionMemStart <= entryMemStart && entryMemStart < subSectionMemStart + subSectionSize)
					{
						subSectionSize = entryMemStart - subSectionMemStart;
						nextSubSectionStart = entryMemStart - sectionMemStart + entry.Size;
					}
				}

#if defined(_MSC_VER) && _MSC_VER >= 1400
				// first byte of _CRT_DEBUGGER_HOOK gets modified in memory by the debugger invisibly, so read it from file
				if (IsDebuggerPresent())
				{
					if (subSectionMemStart <= (byte *)&_CRT_DEBUGGER_HOOK && (byte *)&_CRT_DEBUGGER_HOOK < subSectionMemStart + subSectionSize)
					{
						subSectionSize = (byte *)&_CRT_DEBUGGER_HOOK - subSectionMemStart;
						nextSubSectionStart = (byte *)&_CRT_DEBUGGER_HOOK - sectionMemStart + 1;
					}
				}
#endif

				if (subSectionMemStart <= expectedModuleMac && expectedModuleMac < subSectionMemStart + subSectionSize)
				{
					// found stored MAC
					macFileLocation = (unsigned long)(subSectionFileStart + (expectedModuleMac - subSectionMemStart));
					verifier.AddRangeToSkip(0, macFileLocation, macSize);
				}

				file.TransferTo(verifier, subSectionFileStart - currentFilePos);
				verifier.Put(subSectionMemStart, subSectionSize);
				file.Skip(subSectionSize);
				currentFilePos = subSectionFileStart + subSectionSize;
				subSectionStart = nextSubSectionStart;
			} while (nextSubSectionStart != 0);
		}
		phs++;
	}
#endif
	file.TransferAllTo(verifier);

#ifdef CRYPTOPP_WIN32_AVAILABLE
	// if that fails (could be caused by debug breakpoints or DLL base relocation modifying image in memory),
	// hash from disk instead
	if (!VerifyBufsEqual(expectedModuleMac, actualMac, macSize))
	{
		OutputDebugString("In memory integrity check failed. This may be caused by debug breakpoints or DLL relocation.\n");
		moduleStream.clear();
		moduleStream.seekg(0);
		verifier.Initialize(MakeParameters(Name::OutputBuffer(), ByteArrayParameter(actualMac, (unsigned int)actualMac.size())));
//		verifier.Initialize(MakeParameters(Name::OutputFileName(), (const char *)"c:\\dt2.tmp"));
		verifier.AddRangeToSkip(0, checksumPos, checksumSize);
		verifier.AddRangeToSkip(0, certificateTableDirectoryPos, certificateTableDirectorySize);
		verifier.AddRangeToSkip(0, certificateTablePos, certificateTableSize);
		verifier.AddRangeToSkip(0, macFileLocation, macSize);
		FileStore(moduleStream).TransferAllTo(verifier);
	}
#endif

	if (VerifyBufsEqual(expectedModuleMac, actualMac, macSize))
		return true;

#ifdef CRYPTOPP_WIN32_AVAILABLE
	std::string hexMac;
	HexEncoder(new StringSink(hexMac)).PutMessageEnd(actualMac, actualMac.size());
	OutputDebugString((("Crypto++ DLL integrity check failed. Actual MAC is: " + hexMac) + "\n").c_str());
#endif
	return false;
}
void SmartMote::work(){
    while(1){
        /*  se l'ora corrente è di scansione                                    */
        if(!(RTCC.hours() % 6) && (RTCC.minutes() >= 0x00 && RTCC.minutes() <= 0x05)){
            AString data;
            AString message;
            AString answer;
            /*  abilito il core timer (la prima volta è già abilitato)          */
            System::wakeCoreTimer();
            /*  accendo il led verde                                            */
            turnOnGreen();
            /*  accendo la seriale                                              */
            openUART();
            /*  accendo l'i2c                                                   */
            openI2C();
            /*  prendo le misure                                                */
            data += mac();
            data += luminosity();
            data += ambientTempAndHum();
            data += groundTemp();
            data += groundHum();
            data += battey();
            /*  compongo la stringa                                             */
            message += _PHP_CHUNK1;
            /*  inserisco l'hostname                                            */
            message += getHost();
            /*  inserisco la seconda parte di richiesta http                    */
            message += _PHP_CHUNK2;
            /*  inserisco la lunghezza dei dati                                 */
            message += AString(static_cast<sint32>(data.size()));
            /*  inserisco la terza parte di richiesta http                      */
            message += _PHP_CHUNK3;
            /*  inserisco i dati                                                */
            message += data;

            /*  se fallisce l'inizializzazione dell'esp                         */
            if(!m_net.initialize()){
                /*  notifico l'errore                                           */
                error();
            }
            /*  se fallisce l'avvio del dhcp                                    */
            if(!m_net.setDhcp(true)){
                /*  notifico l'errore                                           */
                error();
            }
            /*  se fallisce la connessione alla rete                            */
            if(!m_net.joinAP(getSSID(), getKey())){
                /*  notifico l'errore                                           */
                error();
            }
            /*  se fallisce la connessione al server                            */
            if(!m_net.connectToHost(getHost(), 80)){
                /*  notifico l'errore                                           */
                error();
            }
            /*  invio i dati                                                    */
            m_net.send(message);
            /*  aspetto l'ok                                                    */
            m_net.waitForData(answer);
            /*  notifico l'ok o lerrore dell'invio                              */
            wasSuccess(answer);
            /*  lascio l'ap                                                     */
            m_net.leaveAP();
            /*  libero la memoria occupata dalle stringhe                       */
            message.clear();
            data.clear();
            answer.clear();
        }
        /*  calcolo del tempo di sleep per il wifi                              */
        m_net.sleep(getSleepTime());
        /*  punto la prossima sveglia                                           */
        setNextAlarm();
        /*  spengo il led verde                                                 */
        turnOffGreen();
        /*  spengo l'uart                                                       */
        closeUART();
        /*  chiudo l'i2c                                                        */
        closeI2C();
        /*  spengo il core timer                                                */
        System::stopCoreTimer();
        /*  vado a dormire                                                      */
        System::sleep();
            
    }
}
Beispiel #20
0
bool ValidateXMACC()
{
	typedef XMACC<MD5> XMACC_MD5;

	const byte keys[2][XMACC_MD5::KEYLENGTH]={
		{0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xaa,0xbb},
		{0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,0xfe,0xdc,0xba,0x98}};

	const word32 counters[2]={0xccddeeff, 0x76543210};

	const char *TestVals[7]={
		"",
		"a",
		"abc",
		"message digest",
		"abcdefghijklmnopqrstuvwxyz",
		"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
		"12345678901234567890123456789012345678901234567890123456789012345678901234567890"};

	const byte output[2][7][XMACC_MD5::DIGESTSIZE]={
		{{0xcc,0xdd,0xef,0x00,0xfa,0x89,0x54,0x92,0x86,0x32,0xda,0x2a,0x3f,0x29,0xc5,0x52,0xa0,0x0d,0x05,0x13},
		{0xcc,0xdd,0xef,0x01,0xae,0xdb,0x8b,0x7b,0x69,0x71,0xc7,0x91,0x71,0x48,0x9d,0x18,0xe7,0xdf,0x9d,0x5a},
		{0xcc,0xdd,0xef,0x02,0x5e,0x01,0x2e,0x2e,0x4b,0xc3,0x83,0x62,0xc2,0xf4,0xe6,0x18,0x1c,0x44,0xaf,0xca},
		{0xcc,0xdd,0xef,0x03,0x3e,0xa9,0xf1,0xe0,0x97,0x91,0xf8,0xe2,0xbe,0xe0,0xdf,0xf3,0x41,0x03,0xb3,0x5a},
		{0xcc,0xdd,0xef,0x04,0x2e,0x6a,0x8d,0xb9,0x72,0xe3,0xce,0x9f,0xf4,0x28,0x45,0xe7,0xbc,0x80,0xa9,0xc7},
		{0xcc,0xdd,0xef,0x05,0x1a,0xd5,0x40,0x78,0xfb,0x16,0x37,0xfc,0x7a,0x1d,0xce,0xb4,0x77,0x10,0xb2,0xa0},
		{0xcc,0xdd,0xef,0x06,0x13,0x2f,0x11,0x47,0xd7,0x1b,0xb5,0x52,0x36,0x51,0x26,0xb0,0x96,0xd7,0x60,0x81}},
		{{0x76,0x54,0x32,0x11,0xe9,0xcb,0x74,0x32,0x07,0x93,0xfe,0x01,0xdd,0x27,0xdb,0xde,0x6b,0x77,0xa4,0x56},
		{0x76,0x54,0x32,0x12,0xcd,0x55,0x87,0x5c,0xc0,0x35,0x85,0x99,0x44,0x02,0xa5,0x0b,0x8c,0xe7,0x2c,0x68},
		{0x76,0x54,0x32,0x13,0xac,0xfd,0x87,0x50,0xc3,0x8f,0xcd,0x58,0xaa,0xa5,0x7e,0x7a,0x25,0x63,0x26,0xd1},
		{0x76,0x54,0x32,0x14,0xe3,0x30,0xf5,0xdd,0x27,0x2b,0x76,0x22,0x7f,0xaa,0x90,0x73,0x6a,0x48,0xdb,0x00},
		{0x76,0x54,0x32,0x15,0xfc,0x57,0x00,0x20,0x7c,0x9d,0xf6,0x30,0x6f,0xbd,0x46,0x3e,0xfb,0x8a,0x2c,0x60},
		{0x76,0x54,0x32,0x16,0xfb,0x0f,0xd3,0xdf,0x4c,0x4b,0xc3,0x05,0x9d,0x63,0x1e,0xba,0x25,0x2b,0xbe,0x35},
		{0x76,0x54,0x32,0x17,0xc6,0xfe,0xe6,0x5f,0xb1,0x35,0x8a,0xf5,0x32,0x7a,0x80,0xbd,0xb8,0x72,0xee,0xae}}};

	byte digest[XMACC_MD5::DIGESTSIZE];
	bool pass=true, fail;

	cout << "\nXMACC/MD5 validation suite running...\n";

	for (int k=0; k<2; k++)
	{
		XMACC_MD5 mac(keys[k], counters[k]);
		cout << "\nKEY: ";
		for (int j=0;j<XMACC_MD5::KEYLENGTH;j++)
			cout << setw(2) << setfill('0') << hex << (int)keys[k][j];
		cout << "    COUNTER: 0x" << hex << counters[k] << endl << endl;
		for (int i=0;i<7;i++)
		{
			mac.Update((byte *)TestVals[i], strlen(TestVals[i]));
			mac.Final(digest);
			fail = memcmp(digest, output[k][i], XMACC_MD5::DIGESTSIZE)
				 || !mac.VerifyDigest(output[k][i], (byte *)TestVals[i], strlen(TestVals[i]));
			pass = pass && !fail;
			cout << (fail ? "FAILED   " : "passed   ");
			for (int j=0;j<XMACC_MD5::DIGESTSIZE;j++)
				cout << setw(2) << setfill('0') << hex << (int)digest[j];
			cout << "   \"" << TestVals[i] << '\"' << endl;
		}
	}

	return pass;
}
int main( int argc, char *argv[] )
{
	printf("%s\n",mac("192.168.48.2"));  
}