int main (int argc, char *argv[]) {
	Card deck[DECK_SIZE];
	Card starting_deck[DECK_SIZE];

	char in_message[MAX_MESSAGE_LENGTH];
	char out_message[MAX_MESSAGE_LENGTH];
	int mode = 0; //encrypt = 0, decrypt = 1

	if (argc != 1) {
		printf("usage: SolitareEncryption1\n");
		printf("SEKEY environment variable must be set to the key value\n");
		exit(1);
	}

	init_deck(starting_deck);
	while (1) {
		//set the deck to the key starting position
		memcpy(deck, starting_deck, sizeof(Card) * DECK_SIZE);
		print_deck(deck);
		if (!mode) {
			printf("Enter message to be encrypted (type '/help' for help):\n");
		} else {
			printf("Enter message to be decrypted (type '/help' for help):\n");
		}
		fflush(stdout);
		if (fgets(in_message, MAX_MESSAGE_LENGTH, stdin) == NULL) {
			printf("fgets failure\n");
			exit(1);
		}

		//get rid of the newline from fgets
		int i;
		for (i = 0; in_message[i] != '\0'; i++) {
			if (in_message[i] == '\n') {
				in_message[i] = '\0';
				break;
			}
		}
		if (!strcmp(in_message, "/quit")) {
			break;
		} else if (!strcmp(in_message, "/encrypt")) {
			mode = 0;
			printf("Encryption mode\n");
		} else if (!strcmp(in_message, "/decrypt")) {
			mode = 1;
			printf("Decryption mode\n");
		} else if (!strcmp(in_message, "/help")) {
			printf("/encrypt: switch to encryption mode\n"
				   "/decrypt: switch to decryption mode\n"
				   "/quit: quit program\n");
		} else {
			if (!mode) {
				printf("Unencrypted: %s\n", in_message);
				printf("Encrypted: %s\n",
						encrypt(deck, in_message, out_message));
			} else {
				printf("Encrypted: %s\n", in_message);
				printf("Decrypted: %s\n",
						decrypt(deck, in_message, out_message));
			}
		}
	}
	return 0;
}
Ejemplo n.º 2
0
static void process_discovery(uint8_t sock, Remote_Info *remote_info, WIZnet_Header *wiznet_header)
{
    uint16_t len;
    uint8_t buffer[sizeof(WIZnet_Header) + sizeof(WIZnet_Discovery_Mixed_Condition)];	// header + most biggest structure
    uint32_t ptr;
    WIZnet_Discovery_Reply reply;
    S2E_Packet *s2e_packet = get_S2E_Packet_pointer();
    uint8_t ip[4];
    uint16_t port;

    getsockopt(sock, SO_REMAINSIZE, &len);
    if(len != wiznet_header->length)
        return;

    switch(wiznet_header->op_code[0]) {
    case DISCOVERY_ALL:
        break;

    case DISCOVERY_PRODUCT_CODE:
    {
        WIZnet_Discovery_Product_Code product_code;
        recvfrom(sock, (uint8_t *)&product_code, sizeof(WIZnet_Discovery_Product_Code), ip, &port);

        if((wiznet_header->valid & 0x80))
            decrypt((wiznet_header->valid & 0x7F), (uint8_t *)&product_code, len);

        if(memcmp(product_code.product_code, s2e_packet->module_type, 3))
            return;
        break;
    }

    case DISCOVERY_MAC_ADDRESS:
    {
        WIZnet_Discovery_MAC_Address mac_address;
        recvfrom(sock, (uint8_t *)&mac_address, sizeof(WIZnet_Discovery_MAC_Address), ip, &port);

        if((wiznet_header->valid & 0x80))
            decrypt((wiznet_header->valid & 0x7F), (uint8_t *)&mac_address, len);

        if(   mac_address.start_mac_address[0] > s2e_packet->network_info_common.mac[0]
                || mac_address.start_mac_address[1] > s2e_packet->network_info_common.mac[1]
                || mac_address.start_mac_address[2] > s2e_packet->network_info_common.mac[2]
                || mac_address.start_mac_address[3] > s2e_packet->network_info_common.mac[3]
                || mac_address.start_mac_address[4] > s2e_packet->network_info_common.mac[4]
                || mac_address.start_mac_address[5] > s2e_packet->network_info_common.mac[5])
            return;
        if(   mac_address.end_mac_address[0] < s2e_packet->network_info_common.mac[0]
                || mac_address.end_mac_address[1] < s2e_packet->network_info_common.mac[1]
                || mac_address.end_mac_address[2] < s2e_packet->network_info_common.mac[2]
                || mac_address.end_mac_address[3] < s2e_packet->network_info_common.mac[3]
                || mac_address.end_mac_address[4] < s2e_packet->network_info_common.mac[4]
                || mac_address.end_mac_address[5] < s2e_packet->network_info_common.mac[5])
            return;
        break;
    }

    case DISCOVERY_ALIAS:
    {
        WIZnet_Discovery_Alias alias;
        recvfrom(sock, (uint8_t *)&alias, sizeof(WIZnet_Discovery_Alias), ip, &port);

        if((wiznet_header->valid & 0x80))
            decrypt((wiznet_header->valid & 0x7F), (uint8_t *)&alias, len);

        if(memcmp(alias.alias, s2e_packet->module_name, strlen((char *)alias.alias)))
            return;
        break;
    }

    case DISCOVERY_MIXED_COND:
    {
        WIZnet_Discovery_Mixed_Condition mixed_condition;
        recvfrom(sock, (uint8_t *)&mixed_condition, sizeof(WIZnet_Discovery_Mixed_Condition), ip, &port);

        if((wiznet_header->valid & 0x80))
            decrypt((wiznet_header->valid & 0x7F), (uint8_t *)&mixed_condition, len);

        break;
    }

    default:
        return;
    }

    // reply
    wiznet_header->length = sizeof(WIZnet_Discovery_Reply);
    wiznet_header->op_code[1] = WIZNET_REPLY;

    memcpy(reply.product_code, s2e_packet->module_type, 3);
    memcpy(reply.fw_version, s2e_packet->fw_ver, 3);
    memcpy(reply.mac_address, s2e_packet->network_info_common.mac, 6);

    if((wiznet_header->valid & 0x80))
        encrypt((wiznet_header->valid & 0x7F), (uint8_t *)&reply, sizeof(WIZnet_Discovery_Reply));

    ptr = 0;
    memcpy(buffer, wiznet_header, sizeof(WIZnet_Header));
    ptr += sizeof(WIZnet_Header);
    memcpy(buffer + ptr, (void *)&reply, sizeof(WIZnet_Discovery_Reply));
    ptr += sizeof(WIZnet_Discovery_Reply);

    if(wiznet_header->unicast == 0) {
        memset(remote_info->ip, 255, 4);
    }
    sendto(sock, buffer, ptr, remote_info->ip, remote_info->port);
}
Ejemplo n.º 3
0
    return stream
        << credential.m_serverUuid
        << credential.m_userName
        << credential.m_login
        << encrypt( credential.m_password );
}

QDataStream& operator >>( QDataStream& stream, ServerCredential& credential )
{
    QByteArray password;
    stream
        >> credential.m_serverUuid
        >> credential.m_userName
        >> credential.m_login
        >> password;
    credential.m_password = decrypt( password );
    return stream;
}

HttpCredential::HttpCredential()
{
}

HttpCredential::HttpCredential( const QString& hostName, const QString& login, const QString& password ) :
    m_hostName( hostName ),
    m_login( login ),
    m_password( password )
{
}

HttpCredential::~HttpCredential()
Ejemplo n.º 4
0
SafeString<char> ProtectedBuffer::toString(){
	SafeString<char> result(data.begin(), data.end());
	decrypt(const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(result.data())), result.size());
	return result;
}
Ejemplo n.º 5
0
int main(int argc, char**argv)
{
int n;
char sendline[10000];
char recvline[10000];
char key[32];
memset(key,'\0',32);
unsigned char decrypted[10000];

FILE *file;
//memset(recvline,'\0',10000);
//char user_input[1000];
file=fopen(argv[1],"r");
char *split=strtok(argv[1],".");
split=strtok(NULL,".");
if(file==0 || strcmp(split,"bank")) {
    printf("Error opening ATM initialization file\n");
    return 64;
}

fread(key,sizeof(key),32,file);
key[32]='\0';
//printf("bank file contents: %s\n",key);
HashTable *users = hash_table_create(100);
HashTable *balance = hash_table_create(100);
Bank *bank = bank_create();
//bank->users = list_create();
//bank->usr_key = hash_table_create(100);
//bank->usr_bal = hash_table_create(100);
printf("%s", prompt);
fflush(stdout);

while(1)
{
    memset(decrypted,'\0',10000);
    memset(recvline,'\0',10000);
    //memset(sendline,'\0',10000);
    fd_set fds;
    FD_ZERO(&fds);
    FD_SET(0, &fds);
    FD_SET(bank->sockfd, &fds);
    select(bank->sockfd+1, &fds, NULL, NULL, NULL);

    if(FD_ISSET(0, &fds)) {
        fgets(sendline, 10000,stdin);
        bank_process_local_command(bank, sendline, strlen(sendline),users,balance);
        printf("%s", prompt);
        fflush(stdout);
    } else if(FD_ISSET(bank->sockfd, &fds)) {
        ;
        //int flag = 0;

        n = bank_recv(bank, recvline, 10000);


        //int flag=decrypt(recvline,key,decrypted,n);

        if(!decrypt(recvline,key,decrypted,n)) { //this means that it has not been decrypted correctly so it will return a null packet
            unsigned char encrypted[10000];
            char packet[10000];
            sprintf(packet,"<%s>",NULL);
            int out_size =0;
            encrypt(packet,key,encrypted,&out_size);
            bank_send(bank, encrypted, out_size);
            printf("%s", prompt);
            fflush(stdout);
            continue;
        }

        //printf("%s\n",decrypted);
        char * message=strtok(decrypted,"\n");

        bank_process_remote_command(bank, message, n, users,key,balance);

    }

}
hash_table_free(balance);
hash_table_free(users); //never executes
bank_free(bank);
//fclose(file);

return EXIT_SUCCESS;
}
Ejemplo n.º 6
0
// Main method of HW5, mostly taking user input and running the correct prog
int main(int argc, char *argv[]) {

	// Look for correct command line arguments
	if(argc <= 1) {
		usage();
		return 0;
	} else {
		if(strcmp(argv[1], "tablecheck") == 0) {
			// Tablecheck prog should be run
			FILE* tablefile = NULL;
			for(int i=2; i<argc; i++) {
				if(strncmp(argv[i], "-t=", 3) == 0) {
					tablefile = fopen(argv[i]+3, "r");
					if(tablefile == NULL) {
						fprintf(stderr, "ERROR: invalid file '%s' for reading.\n", argv[i]+3);
						return 0;
					}
				}
			}
			if(tablefile) {
				tablecheck(tablefile);
				fclose(tablefile);
			} else {
				usage("tablecheck");
			}
		}
		else if(strcmp(argv[1], "encrypt") == 0) {
			// Encrypt prog should be run
			char *key = NULL;
			FILE* tablefile = NULL;
			for(int i=2; i<argc; i++) {
				if(strncmp(argv[i], "-k=", 3) == 0) {
					key = argv[i]+3;
				}
				else if(strncmp(argv[i], "-t=", 3) == 0) {
					tablefile = fopen(argv[i]+3, "r");
					if(tablefile == NULL) {
						fprintf(stderr, "ERROR: invalid file '%s' for reading.\n", argv[i]+3);
						return 0;
					}
				}
			}
			if(key && tablefile) {
				if(argv[argc-1][0] != '-') {
					// Take input from file
					FILE* fin = NULL;
					fin = fopen(argv[argc-1], "r");
					if(fin == NULL) {
						fprintf(stderr, "ERROR: invalid file '%s' for reading.\n", argv[argc-1]);
						return 0;
					}
					encrypt(key, tablefile, fin);
					fclose(fin);
				} else {
					// Take input from cmd line
					encrypt(key, tablefile, stdin);
				}
				fclose(tablefile);
			} else {
				usage("encrypt");
			}
		}
		else if(strcmp(argv[1], "decrypt") == 0) {
			// Decrypt prog should be run
			char *key = NULL;
			FILE* tablefile = NULL;
			for(int i=2; i<argc; i++) {
				if(strncmp(argv[i], "-k=", 3) == 0) {
					key = argv[i]+3;
				}
				else if(strncmp(argv[i], "-t=", 3) == 0) {
					tablefile = fopen(argv[i]+3, "r");
					if(tablefile == NULL) {
						fprintf(stderr, "ERROR: invalid file '%s' for reading.\n", argv[i]+3);
						return 0;
					}
				}
			}
			if(key && tablefile) {
				if(argv[argc-1][0] != '-') {
					// Take input from file
					FILE* fin = NULL;
					fin = fopen(argv[argc-1], "r");
					if(fin == NULL) {
						fprintf(stderr, "ERROR: invalid file '%s' for reading.\n", argv[argc-1]);
						return 0;
					}
					decrypt(key, tablefile, fin);
					fclose(fin);
				} else {
					// Take input from cmd line
					decrypt(key, tablefile, stdin);
				}
				fclose(tablefile);
			} else {
				usage("decrypt");
			}
		}
		else if(strcmp(argv[1], "encrypt3") == 0) {
			// Encrypt3 prog should be run
			char *key3 = NULL;
			FILE* tablefile = NULL;
			for(int i=2; i<argc; i++) {
				if(strncmp(argv[i], "-k=", 3) == 0) {
					key3 = argv[i]+3;
				}
				else if(strncmp(argv[i], "-t=", 3) == 0) {
					tablefile = fopen(argv[i]+3, "r");
					if(tablefile == NULL) {
						fprintf(stderr, "ERROR: invalid file '%s' for reading.\n", argv[i]+3);
						return 0;
					}
				}
			}
			if(key3 && tablefile) {
				if(argv[argc-1][0] != '-') {
					// Take input from file
					FILE* fin = NULL;
					fin = fopen(argv[argc-1], "r");
					if(fin == NULL) {
						fprintf(stderr, "ERROR: invalid file '%s' for reading.\n", argv[argc-1]);
						return 0;
					}
					encrypt3(key3, tablefile, fin);
					fclose(fin);
				} else {
					// Take input from cmd line
					encrypt3(key3, tablefile, stdin);
				}
				fclose(tablefile);
			} else {
				usage("encrypt3");
			}
		}
		else if(strcmp(argv[1], "decrypt3") == 0) {
			// Decrypt3 prog should be run
			char *key3 = NULL;
			FILE* tablefile = NULL;
			for(int i=2; i<argc; i++) {
				if(strncmp(argv[i], "-k=", 3) == 0) {
					key3 = argv[i]+3;
				}
				else if(strncmp(argv[i], "-t=", 3) == 0) {
					tablefile = fopen(argv[i]+3, "r");
					if(tablefile == NULL) {
						fprintf(stderr, "ERROR: invalid file '%s' for reading.\n", argv[i]+3);
						return 0;
					}
				}
			}
			if(key3 && tablefile) {
				if(argv[argc-1][0] != '-') {
					// Take input from file
					FILE* fin = NULL;
					fin = fopen(argv[argc-1], "r");
					if(fin == NULL) {
						fprintf(stderr, "ERROR: invalid file '%s' for reading.\n", argv[argc-1]);
						return 0;
					}
					decrypt3(key3, tablefile, fin);
					fclose(fin);
				} else {
					// Take input from cmd line
					decrypt3(key3, tablefile, stdin);
				}
				fclose(tablefile);
			} else {
				usage("decrypt3");
			}
		}
		else {
			// Failed input
			usage();
		}
	}
	
	return 0;
}
Ejemplo n.º 7
0
int
main(int argc, char **argv)
{
	const char *pubkeyfile = NULL, *seckeyfile = NULL, *msgfile = NULL,
	    *xfile = NULL;
	char xfilebuf[1024];
	const char *ident = NULL;
	int ch;
	int embedded = 0;
	int quiet = 0;
	int v1compat = 0;
	const char *password = NULL;
	opt_binary binary = { 0 };
	enum {
		NONE,
		DECRYPT,
		ENCRYPT,
		GENERATE,
		SIGN,
		VERIFY
	} verb = NONE;

	while ((ch = getopt(argc, argv, "1CDEGSVbei:m:np:qs:x:")) != -1) {
		switch (ch) {
		case '1':
			v1compat = 1;
			break;
		case 'D':
			if (verb)
				usage(NULL);
			verb = DECRYPT;
			break;
		case 'E':
			if (verb)
				usage(NULL);
			verb = ENCRYPT;
			break;
		case 'G':
			if (verb)
				usage(NULL);
			verb = GENERATE;
			break;
		case 'S':
			if (verb)
				usage(NULL);
			verb = SIGN;
			break;
		case 'V':
			if (verb)
				usage(NULL);
			verb = VERIFY;
			break;
		case 'b':
			binary.v = 1;
			break;
		case 'e':
			embedded = 1;
			break;
		case 'i':
			ident = optarg;
			break;
		case 'm':
			msgfile = optarg;
			break;
		case 'n':
			password = "";
			break;
		case 'p':
			pubkeyfile = optarg;
			break;
		case 'q':
			quiet = 1;
			break;
		case 's':
			seckeyfile = optarg;
			break;
		case 'x':
			xfile = optarg;
			break;
		default:
			usage(NULL);
			break;
		}
	}
	argc -= optind;
	argv += optind;

	if (argc != 0)
		usage(NULL);

	switch (verb) {
	case ENCRYPT:
	case DECRYPT:
		if (!msgfile)
			usage("You must specify a message-file");
		if (!xfile) {
			if (strcmp(msgfile, "-") == 0)
				usage("must specify encfile with - message");
			if (snprintf(xfilebuf, sizeof(xfilebuf), "%s.enc",
			    msgfile) >= sizeof(xfilebuf))
				errx(1, "path too long");
			xfile = xfilebuf;
		}
		break;
	case SIGN:
	case VERIFY:
		if (!xfile && msgfile) {
			if (strcmp(msgfile, "-") == 0)
				usage("must specify sigfile with - message");
			if (snprintf(xfilebuf, sizeof(xfilebuf), "%s.sig",
			    msgfile) >= sizeof(xfilebuf))
				errx(1, "path too long");
			xfile = xfilebuf;
		}
		break;
	default:
		break;
	}

	switch (verb) {
	case DECRYPT:
		decrypt(pubkeyfile, seckeyfile, msgfile, xfile);
		break;
	case ENCRYPT:
		if (seckeyfile && (!pubkeyfile && !ident))
			usage("specify a pubkey or ident");
		if (pubkeyfile || ident) {
			if (v1compat)
				v1pubencrypt(pubkeyfile, ident, seckeyfile, msgfile, xfile, binary);
			else
				pubencrypt(pubkeyfile, ident, seckeyfile, msgfile, xfile, binary);
		} else
			symencrypt(msgfile, xfile, binary);
		break;
	case GENERATE:
		if (!ident && !(ident= getenv("USER")))
			ident = "unknown";

		/* can specify none, but not only one */
		if ((!pubkeyfile && seckeyfile) ||
		    (!seckeyfile && pubkeyfile))
			usage("must specify pubkey and seckey");
		/* if none, create ~/.reop */
		if (!pubkeyfile && !seckeyfile) {
			char buf[1024];
			const char *home;

			if (!(home = getenv("HOME")))
				errx(1, "can't find HOME");
			snprintf(buf, sizeof(buf), "%s/.reop", home);
			if (mkdir(buf, 0700) == -1 && errno != EEXIST)
				err(1, "Unable to create ~/.reop");
		}
		generate(pubkeyfile, seckeyfile, ident, password);
		break;
	case SIGN:
		if (!msgfile)
			usage("must specify message");
		signfile(seckeyfile, msgfile, xfile, embedded);
		break;
	case VERIFY:
		if (!msgfile && !xfile)
			usage("must specify message or sigfile");
		if (msgfile)
			verifysimple(pubkeyfile, msgfile, xfile, quiet);
		else
			verifyembedded(pubkeyfile, xfile, quiet);
		break;
	default:
		usage(NULL);
		break;
	}

	return 0;
}
Ejemplo n.º 8
0
 Coin<FIELD> decrypt(const AddrPair<FIELD>& addr) const {
     return decrypt(addr.secretAddr(), addr.publicAddr());
 }
Ejemplo n.º 9
0
int traiter_recu (char * requete_recu)
{
	unsigned char requete_decrypt[sizeof(requete_recu)];
	puts("YIHI");
	decrypt(requete_recu, requete_decrypt, strlen(requete_recu));
	printf("JAI RECU -> %s\n", requete_recu);
	printf("DECRYPT -> %s\n", requete_decrypt);

	char *type = malloc (sizeof (char*) * 256);
	char *donnee = malloc (sizeof (char*) * 256);
	char * save_ptr;

	type = strtok_r(requete_decrypt, "*", &save_ptr);

	int j = 0;

	/*while (*save_ptr != '\0')	
	{
		donnee[j] = *(save_ptr++);
		j++;
	}*/

	//if (type[0] == 'R') printf("DONNEE de la reponse -> %s\n", donnee);


	switch(type[0])
	{
		case 'R' :
				  while (*save_ptr != '\0')	
				  {
					donnee[j] = *(save_ptr++);
					j++;
				  }
				printf("DONNEE de la reponse -> %s\n", donnee);
				break;

		case '1' :
				;

				char *status_requete = malloc (sizeof (char*) * 1024);
				char *test = malloc (sizeof (char*) * 1024);
				char *nom = recup_valeur("nom");
				printf("NOM -> %s\n", nom);
				//char *status = recup_valeur("status");
				printf("RECUP_STATUS -> %s\n", recup_valeur("status"));
				status_requete = strtok_r(NULL, "*", &save_ptr);
				test = strtok_r(NULL, "*", &save_ptr);
				//printf("TEST -> %s\n", test);
				printf("STATUS -> %s\n", status_requete);
				
				if( strcmp(recup_valeur("status"), status_requete) == 0)
				{
					puts("Correspond");
					unsigned char a_envoyer[sizeof (char *) * 1024];
					sprintf(a_envoyer, "1*%s*%s", nom, recup_valeur("status"));
					unsigned char a_envoyer_crypt[sizeof(a_envoyer)];
					crypt(a_envoyer, a_envoyer_crypt, strlen(a_envoyer));
					envoi_requete(a_envoyer_crypt);
				}
				else
				{
					puts("NOP");
					unsigned char a_envoyer[sizeof (char *) * 1024];
					sprintf(a_envoyer, "1*none");
					unsigned char a_envoyer_crypt[sizeof(a_envoyer)];
					crypt(a_envoyer, a_envoyer_crypt, strlen(a_envoyer));
					envoi_requete(a_envoyer_crypt);	
				}
				break;

	}
	return 0;

}
Ejemplo n.º 10
0
 void decrypt(const char* in, std::size_t len, uint8_t* out)
 {
     decrypt(reinterpret_cast<const uint8_t*>(in), len, out);
 }
Ejemplo n.º 11
0
int main(int argc, char *argv[])
{
        FILE *rsapub_key_fp;
        unsigned char *cam128_key, *cam128_iv;
        unsigned char *cipher_of_secret_text, *cipher_of_signed_key, *signed_key, *secret_text, *clobbered_key;
        EVP_PKEY *rsapub_key;
        unsigned char *rc4_40_key;
        const EVP_CIPHER *cam128_cfb8, *rc4_40;
        const EVP_MD *sha;
        EVP_MD_CTX sha_ctx;
        int cam128_cfb8_keylen, cam128_cfb8_ivlen, rc4_40_keylen, signed_key_size;
        int ret, count;
        long cipher_of_signed_key_size, clobbered_key_size, cipher_of_secret_text_size,  secret_text_size;

        // get the parameters for CAMELLIA128_cfb8
        cam128_cfb8 = EVP_camellia_128_cfb8();
        cam128_cfb8_keylen = EVP_CIPHER_key_length(cam128_cfb8);
        cam128_cfb8_ivlen = EVP_CIPHER_iv_length(cam128_cfb8);

        // get the parameters for RC4_40
        rc4_40 = EVP_rc4_40();
        rc4_40_keylen = EVP_CIPHER_key_length(rc4_40);

        // get the parameters for sha
        sha = EVP_sha();

        // read the s67766-clobbered-key.bin and store the key and iv for CAMELLIA128-cfb8
        cam128_key = malloc(cam128_cfb8_keylen);
        cam128_iv = malloc(cam128_cfb8_ivlen);

        clobbered_key_size = read_file(clobbered_key_file, &clobbered_key);
        if(clobbered_key_size != cam128_cfb8_keylen+cam128_cfb8_ivlen)
        {
                printf("reading file %s returned not enough Bytes: %ld, instead of: %d\n", clobbered_key_file, clobbered_key_size, cam128_cfb8_keylen+cam128_cfb8_ivlen);
                perror("");
        }
        memcpy(cam128_key, clobbered_key, cam128_cfb8_keylen);
        memcpy(cam128_iv, clobbered_key+cam128_cfb8_keylen, cam128_cfb8_ivlen);

        // read the s67766-cipher-of-signed-key.bin
        cipher_of_signed_key_size = read_file(cipher_of_signed_key_file, &cipher_of_signed_key);

        // read the public key from rsapub.pem
        rsapub_key_fp = fopen(rsapub_key_file, "r");
        if (!rsapub_key_fp)
        {
                printf("opening file %s returned error\n", rsapub_key_file);
                perror("");
        }

        rsapub_key = PEM_read_PUBKEY(rsapub_key_fp, NULL, NULL, NULL);
        if (!rsapub_key)
        {
                printf("PEM_read_PUBKEY returned error for RSA\n");
        }

        if(fclose(rsapub_key_fp) != 0)
        {
                printf("closing file %s returned error\n", rsapub_key_file);
                perror("");
        }

        // restore the clobbered key with bruteforce
        signed_key = malloc(cipher_of_signed_key_size);
        for(count = 0; count<=255; count++)
        {
                memset(cam128_key, count, 1);

                //decrypt the cipher with guessed key
                signed_key_size =  decrypt(cam128_cfb8, &signed_key, cipher_of_signed_key, cipher_of_signed_key_size, cam128_key, cam128_iv);
                if(signed_key_size==-1)
                {
                        return -1;
                }

                if(EVP_VerifyInit(&sha_ctx, sha) == 0)
                {
                        printf("EVP_VerifyInit returned error for SHA\n");
                }
                if(EVP_VerifyUpdate(&sha_ctx, signed_key, rc4_40_keylen) == 0)
                {
                        printf("EVP_VerifyUpdate returned error for SHA\n");
                }
                ret = EVP_VerifyFinal(&sha_ctx, signed_key+rc4_40_keylen, signed_key_size-rc4_40_keylen, rsapub_key);
                switch(ret)
                {
                        case -1:
                                printf("EVP_VerifyFinal returned error for SHA\n");
                                break;
                        case 0:
                                break;
                        case 1:
                                count = 255;
                                break;
                }
        }
        // extract the key for RC-4 40
        rc4_40_key = malloc(rc4_40_keylen);
        memcpy(rc4_40_key, signed_key, rc4_40_keylen);

        // read the s67766-cipher-of-secret-text.bin
        cipher_of_secret_text_size = read_file(cipher_of_secret_text_file, &cipher_of_secret_text);

        // decrypt s67766-cipher-of-secret-text.bin
        secret_text = malloc(cipher_of_secret_text_size);
        secret_text_size = 0;

        secret_text_size =  decrypt(rc4_40, &secret_text, cipher_of_secret_text, cipher_of_secret_text_size, rc4_40_key, NULL);

        // write the s67766-plain.bin
        if(write_file(plain_file, secret_text, secret_text_size)==-1)
        {
                return -1;
        }

        return 0;
}
Ejemplo n.º 12
0
 void decrypt(const char* in, std::size_t len, char* out)
 {
     decrypt(in, len, reinterpret_cast<byte*>(out));
 }
Ejemplo n.º 13
0
int main() {
	srand((unsigned)time(NULL));
	int i;
	EC_KEY* key;
	//key = EC_KEY_new_by_curve_name(415);
	key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
	const EC_GROUP *group = EC_KEY_get0_group(key);
	if (EC_KEY_generate_key(key)==0) {
		printf("Error generate key\n");
		return -1;
	}
	unsigned char pk_b[33];
	const EC_POINT *pub = EC_KEY_get0_public_key(key);
	if (EC_POINT_point2oct(group, pub, POINT_CONVERSION_COMPRESSED, pk_b, 33, 0)!=33) {
		printf("Error 2\n");
		return -1;
	}
	unsigned char h1[16],h2[16];

	printf("\x02");
	for (i=0;i<16;i++) {
		h1[i]=rand()%256;
		printf("%c",h1[i]);
	}
	for (i=0;i<33;i++)
		printf("%c",pk_b[i]);
	fflush(stdout);
	//get h2
	for (i=0;i<16;i++) 
		h2[i]=rand()%256;
	for (i=0;i<16;i++)
		scanf("%c",&h2[i]);
		
	//get peerpk_b
	unsigned char peerpk_b[33]={2 , 30 , 25 , 50 , 17 , 242 , 232 , 55 , 157 , 18 , 106 , 115 , 214 , 193 , 192 , 39 , 207 , 226 , 184 , 216 , 244 , 147 , 111 , 188 , 125 , 230 , 38 , 125 , 231 , 50 , 56 , 152 , 148 };
	for (i=0;i<33;i++)
		scanf("%c",&peerpk_b[i]);
	
	EC_POINT *peerpk = EC_POINT_new(group);
	if (EC_POINT_oct2point(group, peerpk, peerpk_b, 33, 0)==0) {
		printf("Error 3\n");
		return -1;
	}
	unsigned char skey[33];
	if (ECDH_compute_key(skey, 32,  peerpk, key, NULL)==0) {
		printf("Error 4\n");
		return -1;
	}


	SHA512_CTX shactx;	
	unsigned char hash[SHA512_DIGEST_LENGTH];
	SHA512_Init(&shactx);
	SHA512_Update(&shactx, h2, 16);
	SHA512_Update(&shactx, skey, 32);
	SHA512_Update(&shactx, h1, 16);
	SHA512_Final(hash, &shactx);

	for (i=0;i<64;i++)
		printf("%02x",hash[i]);	
	fflush(stdout);

	struct cipher c;
	c.recvfd=0;
	c.sendfd=1;
	for (i=0;i<16;i++)
		c.sendkey[i]=hash[i];
	for (i=0;i<4;i++)
		c.sendiv[i]=hash[32+i];
	for (i=0;i<16;i++)
		c.recvkey[i]=hash[16+i];
	for (i=0;i<4;i++)
		c.recviv[i]=hash[36+i];
	c.sendcnt=0;
	c.recvcnt=0;

	unsigned char d[1000];
	unsigned char oiv[8];
	int op;
	char dlen;

	while (true) {
		scanf("%d",&op);
		scanf("%c",&dlen);
		scanf("%c",&dlen);
		for (i=0;i<dlen;i++)
			scanf("%c",&d[i]);
		if (op==1) {
			for (i=0;i<8;i++)
				oiv[i]=rand()%256;
			encrypt(c,d,dlen,oiv);
			c.recvcnt+=1;
		} else if (op==2) {
			for (i=0;i<8;i++)
				scanf("%c",&oiv[i]);
			decrypt(c,d,dlen,oiv, NULL);
			c.sendcnt+=1;
		}
		fflush(stdout);
	}
	
	return 0;
}
Ejemplo n.º 14
0
//-----------------------------------------------------
//
//-----------------------------------------------------
bool initLDAP(IPropertyTree * ldapProps)
{
    StringAttr serverType( ldapProps->queryProp("@serverType") );
    if (!serverType.length())
    {
        fprintf(stderr, "\nERROR: serverType not set in LDAPServer component");
        return false;
    }

    StringBuffer hpccUser;
    StringBuffer hpccPwd;
    ldapProps->getProp("@systemUser", hpccUser);
    ldapProps->getProp("@systemPassword", hpccPwd);
    if (0==hpccUser.length() || 0==hpccPwd.length())
    {
        fprintf(stderr, "\nERROR: HPCC systemUser credentials not found in configuration");
        return false;
    }

    StringBuffer ldapAddress;
    ldapProps->getProp("@ldapAddress", ldapAddress);

    //Get LDAP admin creds from user
    char buff[100];
    fprintf(stdout, "\nEnter the '%s' LDAP Admin User name on '%s'...",serverType.get(),ldapAddress.str());
    do
    {
        char * line = fgets(buff, sizeof(buff), stdin);
        if (!line)
            return false;
    }
    while (buff[0] == (char)'\n');

    if (buff[strlen(buff)-1] == '\n')
        buff[strlen(buff)-1] = (char)NULL;
    StringAttr ldapUser(buff);

    fprintf(stdout, "Enter the LDAP Admin user '%s' password...",ldapUser.get());
    char * line = fgets(buff, sizeof(buff), stdin);
    if (!line)
        return false;

    if (buff[strlen(buff)-1] == '\n')
        buff[strlen(buff)-1] = (char)NULL;
    StringAttr ldapPwd(buff);
    if (0==ldapUser.length() || 0==ldapPwd.length())
    {
        fprintf(stderr, "\nERROR: Invalid LDAP Admin account credentials entered");
        return false;
    }

    fprintf(stdout, "\nReady to initialize HPCC LDAP Environment, using the following settings");
    fprintf(stdout, "\n\tLDAP Server     : %s", ldapAddress.str());
    fprintf(stdout, "\n\tLDAP Type       : %s", serverType.get());
    fprintf(stdout, "\n\tHPCC Admin User : %s", hpccUser.str());
    fprintf(stdout, "\nProceed?  y/n ");
    for (;;)
    {
        int c = getchar();
        if (c == 'y' || c == 'Y')
            break;
        else if (c == 'n' || c == 'N')
            return true;
    }

    if (stricmp(serverType.get(),"ActiveDirectory"))
        ldapProps->setProp("@systemBasedn", "");

    //Replace system user with LDAP Admin credentials
    ldapProps->setProp("@systemUser", ldapUser);
    ldapProps->setProp("@systemCommonName", ldapUser);
    StringBuffer sb;
    encrypt(sb,ldapPwd);
    ldapProps->setProp("@systemPassword", sb.str());

    //Create security manager. This creates the required OUs
    Owned<ISecManager> secMgr;
    try
    {
        secMgr.setown(newLdapSecManager("initldap", *LINK(ldapProps)));
    }
    catch(IException *e)
    {
        StringBuffer buff;
        e->errorMessage(buff);
        e->Release();
        fprintf(stderr, "\nERROR: Unable to create security manager : %s", buff.str());
        return false;
    }

    //Create HPCC Admin user
    Owned<ISecUser> user = secMgr->createUser(hpccUser.str());
    StringBuffer pwd;
    decrypt(pwd, hpccPwd.str());
    user->credentials().setPassword(pwd.str());
    try { secMgr->addUser(*user.get()); }
    catch(...) {}//user may already exist, so just move on

    //Add HPCC admin user to Administrators group
    CLdapSecManager* ldapSecMgr = dynamic_cast<CLdapSecManager*>(secMgr.get());
    if (!ldapSecMgr)
    {
        fprintf(stderr, "\nERROR: Unable to access CLdapSecManager object");
        return false;
    }
    StringAttr adminGroup;
    bool isActiveDir = true;
    if (0 == stricmp(serverType.get(),"ActiveDirectory"))
        adminGroup.set("Administrators");
    else
        adminGroup.set("Directory Administrators");
    try { ldapSecMgr->changeUserGroup("add", hpccUser.str(), adminGroup); }
    catch(...) {}//user may already be in group so just move on

    fprintf(stdout, "\n\nLDAP Initialization successful\n");
    return true;
}
Ejemplo n.º 15
0
bool CMyPlug::importTerrainData(iSceneData * pSceneData, const std::string& strFilename)
{
	pSceneData->clear();
	if (pSceneData->resize(253,253))
	{
		// EncTerrain
		IOReadBase* pRead = IOReadBase::autoOpen(strFilename);
		if (pRead)
		{
			if (MAP_FILE_SIZE==pRead->GetSize())
			{
				char buffer[MAP_FILE_SIZE];
				pRead->Read(buffer,MAP_FILE_SIZE);
				decrypt(buffer,MAP_FILE_SIZE);
				char* p = buffer;
				unsigned short uMuFlgMap = *((unsigned short*)p);
				p+=2;
				for (int y=0; y<253; ++y)
				{
					for (int x=0; x<253; ++x)
					{
						pSceneData->setCellTileID(x,y,*p,0);
						p++;
					}
					p+=3;
				}
				p+=256*3;
				for (int y=0; y<253; ++y)
				{
					for (int x=0; x<253; ++x)
					{
						pSceneData->setCellTileID(x,y,*p,1);
						p++;
					}
					p+=3;
				}
				p+=256*3;
				for (int y=0; y<254; ++y)
				{
					for (int x=0; x<254; ++x)
					{
						pSceneData->setVertexColor(x,y,Color32(*p,255,255,255));
						p++;
					}
					p+=2;
				}
			}
			IOReadBase::autoClose(pRead);
		}
		// EncTerrain.att
		pRead = IOReadBase::autoOpen(ChangeExtension(strFilename,".att"));
		if (pRead)
		{
			if (ATT_FILE_129KB_SIZE==pRead->GetSize())
			{
				char buffer[ATT_FILE_129KB_SIZE];
				pRead->Read(buffer,ATT_FILE_129KB_SIZE);
				decrypt(buffer,ATT_FILE_129KB_SIZE);
				decrypt2(buffer,ATT_FILE_129KB_SIZE);
				char* p = buffer;
				unsigned long uMuFlgAtt = *((unsigned long*)p);
				p+=4;
				for (int y=0; y<253; ++y)
				{
					for (int x=0; x<253; ++x)
					{
						pSceneData->setCellAttribute(x,y,*p);
						p+=2;
					}
					p+=6;
				}
			}
			else if (ATT_FILE_65KB_SIZE==pRead->GetSize())
			{
				char buffer[ATT_FILE_65KB_SIZE];
				pRead->Read(buffer,ATT_FILE_65KB_SIZE);
				decrypt(buffer,ATT_FILE_65KB_SIZE);
				decrypt2(buffer,ATT_FILE_65KB_SIZE);
				char* p = buffer;
				unsigned long uMuFlgAtt = *((unsigned long*)p);
				p+=4;
				for (int y=0; y<253; ++y)
				{
					for (int x=0; x<253; ++x)
					{
						pSceneData->setCellAttribute(x,y,*p);
						p++;
					}
					p+=3;
				}
			}
			IOReadBase::autoClose(pRead);
		}
		// TerrainHeight
		std::string strHeightFilename = GetParentPath(strFilename)+"TerrainHeight.ozb";
		pRead = IOReadBase::autoOpen(strHeightFilename);
		if (pRead)
		{
			if (HEIGHT_HEAD_SIZE+HEIGHT_BUFFER_SIZE<=pRead->GetSize())
			{
				pRead->Move(HEIGHT_HEAD_SIZE);
				for (int y=0; y<254; ++y)
				{
					pRead->Move(2);
					for (int x=0; x<254; ++x)
					{
						unsigned char uVal;
						pRead->Read(&uVal,1);
						pSceneData->setVertexHeight(x,y,uVal*0.015f);
					}
				}
			}
			IOReadBase::autoClose(pRead);
		}
	}
	return true;
}
Ejemplo n.º 16
0
/* used to be handleServerMsg()                                  */
void IrcParser::processNetworkIncoming(NetworkDataEvent *e)
{
    CoreNetwork *net = qobject_cast<CoreNetwork *>(e->network());
    if (!net) {
        qWarning() << "Received network event without valid network pointer!";
        return;
    }

    // note that the IRC server is still alive
    net->resetPingTimeout();

    QByteArray msg = e->data();
    if (msg.isEmpty()) {
        qWarning() << "Received empty string from server!";
        return;
    }

    // Now we split the raw message into its various parts...
    QString prefix;
    QByteArray trailing;
    QString cmd, target;

    // First, check for a trailing parameter introduced by " :", since this might screw up splitting the msg
    // NOTE: This assumes that this is true in raw encoding, but well, hopefully there are no servers running in japanese on protocol level...
    int idx = msg.indexOf(" :");
    if (idx >= 0) {
        if (msg.length() > idx + 2)
            trailing = msg.mid(idx + 2);
        msg = msg.left(idx);
    }
    // OK, now it is safe to split...
    QList<QByteArray> params = msg.split(' ');

    // This could still contain empty elements due to (faulty?) ircds sending multiple spaces in a row
    // Also, QByteArray is not nearly as convenient to work with as QString for such things :)
    QList<QByteArray>::iterator iter = params.begin();
    while (iter != params.end()) {
        if (iter->isEmpty())
            iter = params.erase(iter);
        else
            ++iter;
    }

    if (!trailing.isEmpty())
        params << trailing;
    if (params.count() < 1) {
        qWarning() << "Received invalid string from server!";
        return;
    }

    QString foo = net->serverDecode(params.takeFirst());

    // a colon as the first chars indicates the existence of a prefix
    if (foo[0] == ':') {
        foo.remove(0, 1);
        prefix = foo;
        if (params.count() < 1) {
            qWarning() << "Received invalid string from server!";
            return;
        }
        foo = net->serverDecode(params.takeFirst());
    }

    // next string without a whitespace is the command
    cmd = foo.trimmed();

    QList<Event *> events;
    EventManager::EventType type = EventManager::Invalid;

    uint num = cmd.toUInt();
    if (num > 0) {
        // numeric reply
        if (params.count() == 0) {
            qWarning() << "Message received from server violates RFC and is ignored!" << msg;
            return;
        }
        // numeric replies have the target as first param (RFC 2812 - 2.4). this is usually our own nick. Remove this!
        target = net->serverDecode(params.takeFirst());
        type = EventManager::IrcEventNumeric;
    }
    else {
        // any other irc command
        QString typeName = QLatin1String("IrcEvent") + cmd.at(0).toUpper() + cmd.mid(1).toLower();
        type = eventManager()->eventTypeByName(typeName);
        if (type == EventManager::Invalid) {
            type = eventManager()->eventTypeByName("IrcEventUnknown");
            Q_ASSERT(type != EventManager::Invalid);
        }
        target = QString();
    }

    // Almost always, all params are server-encoded. There's a few exceptions, let's catch them here!
    // Possibly not the best option, we might want something more generic? Maybe yet another layer of
    // unencoded events with event handlers for the exceptions...
    // Also, PRIVMSG and NOTICE need some special handling, we put this in here as well, so we get out
    // nice pre-parsed events that the CTCP handler can consume.

    QStringList decParams;
    bool defaultHandling = true; // whether to automatically copy the remaining params and send the event

    switch (type) {
    case EventManager::IrcEventPrivmsg:
        defaultHandling = false; // this might create a list of events

        if (checkParamCount(cmd, params, 1)) {
            QString senderNick = nickFromMask(prefix);
            QByteArray msg = params.count() < 2 ? QByteArray() : params.at(1);

            QStringList targets = net->serverDecode(params.at(0)).split(',', QString::SkipEmptyParts);
            QStringList::const_iterator targetIter;
            for (targetIter = targets.constBegin(); targetIter != targets.constEnd(); ++targetIter) {
                QString target = net->isChannelName(*targetIter) ? *targetIter : senderNick;

                msg = decrypt(net, target, msg);

                events << new IrcEventRawMessage(EventManager::IrcEventRawPrivmsg, net, msg, prefix, target, e->timestamp());
            }
        }
        break;

    case EventManager::IrcEventNotice:
        defaultHandling = false;

        if (checkParamCount(cmd, params, 2)) {
            QStringList targets = net->serverDecode(params.at(0)).split(',', QString::SkipEmptyParts);
            QStringList::const_iterator targetIter;
            for (targetIter = targets.constBegin(); targetIter != targets.constEnd(); ++targetIter) {
                QString target = *targetIter;

                // special treatment for welcome messages like:
                // :[email protected] NOTICE egst :[#apache] Welcome, this is #apache. Please read the in-channel topic message. This channel is being logged by IRSeekBot. If you have any question please see http://blog.freenode.net/?p=68
                if (!net->isChannelName(target)) {
                    QString decMsg = net->serverDecode(params.at(1));
                    QRegExp welcomeRegExp("^\\[([^\\]]+)\\] ");
                    if (welcomeRegExp.indexIn(decMsg) != -1) {
                        QString channelname = welcomeRegExp.cap(1);
                        decMsg = decMsg.mid(welcomeRegExp.matchedLength());
                        CoreIrcChannel *chan = static_cast<CoreIrcChannel *>(net->ircChannel(channelname)); // we only have CoreIrcChannels in the core, so this cast is safe
                        if (chan && !chan->receivedWelcomeMsg()) {
                            chan->setReceivedWelcomeMsg();
                            events << new MessageEvent(Message::Notice, net, decMsg, prefix, channelname, Message::None, e->timestamp());
                            continue;
                        }
                    }
                }

                if (prefix.isEmpty() || target == "AUTH") {
                    target = QString();
                }
                else {
                    if (!target.isEmpty() && net->prefixes().contains(target.at(0)))
                        target = target.mid(1);
                    if (!net->isChannelName(target))
                        target = nickFromMask(prefix);
                }

#ifdef HAVE_QCA2
                // Handle DH1080 key exchange
                if (params[1].startsWith("DH1080_INIT") && !net->isChannelName(target)) {
                    events << new KeyEvent(EventManager::KeyEvent, net, prefix, target, KeyEvent::Init, params[1].mid(12));
                } else if (params[1].startsWith("DH1080_FINISH") && !net->isChannelName(target)) {
                    events << new KeyEvent(EventManager::KeyEvent, net, prefix, target, KeyEvent::Finish, params[1].mid(14));
                } else
#endif
                    events << new IrcEventRawMessage(EventManager::IrcEventRawNotice, net, params[1], prefix, target, e->timestamp());
            }
        }
        break;

    // the following events need only special casing for param decoding
    case EventManager::IrcEventKick:
        if (params.count() >= 3) { // we have a reason
            decParams << net->serverDecode(params.at(0)) << net->serverDecode(params.at(1));
            decParams << net->channelDecode(decParams.first(), params.at(2)); // kick reason
        }
        break;

    case EventManager::IrcEventPart:
        if (params.count() >= 2) {
            QString channel = net->serverDecode(params.at(0));
            decParams << channel;
            decParams << net->userDecode(nickFromMask(prefix), params.at(1));
        }
        break;

    case EventManager::IrcEventQuit:
        if (params.count() >= 1) {
            decParams << net->userDecode(nickFromMask(prefix), params.at(0));
        }
        break;

    case EventManager::IrcEventTopic:
        if (params.count() >= 1) {
            QString channel = net->serverDecode(params.at(0));
            decParams << channel;
            decParams << (params.count() >= 2 ? net->channelDecode(channel, decrypt(net, channel, params.at(1), true)) : QString());
        }
        break;

    case EventManager::IrcEventNumeric:
        switch (num) {
        case 301: /* RPL_AWAY */
            if (params.count() >= 2) {
                QString nick = net->serverDecode(params.at(0));
                decParams << nick;
                decParams << net->userDecode(nick, params.at(1));
            }
            break;

        case 332: /* RPL_TOPIC */
            if (params.count() >= 2) {
                QString channel = net->serverDecode(params.at(0));
                decParams << channel;
                decParams << net->channelDecode(channel, decrypt(net, channel, params.at(1), true));
            }
            break;

        case 333: /* Topic set by... */
            if (params.count() >= 3) {
                QString channel = net->serverDecode(params.at(0));
                decParams << channel << net->serverDecode(params.at(1));
                decParams << net->channelDecode(channel, params.at(2));
            }
            break;
        }

    default:
        break;
    }

    if (defaultHandling && type != EventManager::Invalid) {
        for (int i = decParams.count(); i < params.count(); i++)
            decParams << net->serverDecode(params.at(i));

        // We want to trim the last param just in case, except for PRIVMSG and NOTICE
        // ... but those happen to be the only ones not using defaultHandling anyway
        if (!decParams.isEmpty() && decParams.last().endsWith(' '))
            decParams.append(decParams.takeLast().trimmed());

        IrcEvent *event;
        if (type == EventManager::IrcEventNumeric)
            event = new IrcEventNumeric(num, net, prefix, target);
        else
            event = new IrcEvent(type, net, prefix);
        event->setParams(decParams);
        event->setTimestamp(e->timestamp());
        events << event;
    }

    foreach(Event *event, events) {
        emit newEvent(event);
    }
Ejemplo n.º 17
0
void
decrypt_file (const gchar *input_file_path, const gchar *pwd)
{
    GError *err = NULL;

    goffset file_size = get_file_size (input_file_path);
    if (file_size == -1) {
        return;
    }
    if (file_size < (goffset) (sizeof (Metadata) + SHA512_DIGEST_SIZE)) {
        g_printerr ("The selected file is not encrypted.\n");
        return;
    }

    GFile *in_file = g_file_new_for_path (input_file_path);
    GFileInputStream *in_stream = g_file_read (in_file, NULL, &err);
    if (err != NULL) {
        g_printerr ("%s\n", err->message);
        // TODO
        return;
    }

    gchar *output_file_path;
    if (!g_str_has_suffix (input_file_path, ".enc")) {
        g_printerr ("The selected file may not be encrypted\n");
        output_file_path = g_strconcat (input_file_path, ".decrypted", NULL);
    }
    else {
        output_file_path = g_strndup (input_file_path, (gsize) g_utf8_strlen (input_file_path, -1) - 4); // remove .enc
    }
    GFile *out_file = g_file_new_for_path (output_file_path);
    GFileOutputStream *out_stream = g_file_append_to (out_file, G_FILE_CREATE_REPLACE_DESTINATION, NULL, &err);
    if (err != NULL) {
        g_printerr ("%s\n", err->message);
        // TODO
        return;
    }

    Metadata *header_metadata = g_new0 (Metadata, 1);
    CryptoKeys *decryption_keys = g_new0 (CryptoKeys, 1);

    gssize rw_len = g_input_stream_read (G_INPUT_STREAM (in_stream), header_metadata, sizeof (Metadata), NULL, &err);
    if (rw_len == -1) {
        g_printerr ("%s\n", err->message);
        // TODO
        return;
    }

    guchar *original_hmac = g_malloc (SHA512_DIGEST_SIZE);
    if (!g_seekable_seek (G_SEEKABLE (in_stream), file_size - SHA512_DIGEST_SIZE, G_SEEK_SET, NULL, &err)) {
        g_printerr ("Couldn't set the position, exiting...\n");
        //TODO
        return;
    }
    rw_len = g_input_stream_read (G_INPUT_STREAM (in_stream), original_hmac, SHA512_DIGEST_SIZE, NULL, &err);
    if (rw_len == -1) {
        g_printerr ("%s\n", err->message);
        // TODO
        return;
    }

    if (!g_seekable_seek (G_SEEKABLE (in_stream), 0, G_SEEK_SET, NULL, &err)) {
        g_printerr ("Couldn't set the position, exiting...\n");
        //TODO
        return;
    }
    GFile *file_encrypted_data = get_g_file_with_encrypted_data (in_stream, file_size);
    if (file_encrypted_data == NULL) {
        // TODO
        return;
    }

    if (!setup_keys (pwd, gcry_cipher_get_algo_keylen (header_metadata->algo), header_metadata, decryption_keys)) {
        g_printerr ("Error during key derivation or during memory allocation\n");
        //TODO
        return;
    }

    if (!compare_hmac (decryption_keys->hmac_key, original_hmac, file_encrypted_data)) {
        g_printerr ("HMAC differs from the one stored inside the file.\nEither the password is wrong or the file has been corrupted.\n");
        // TODO
        return;
    }

    decrypt (header_metadata, decryption_keys, file_encrypted_data, file_size - sizeof (Metadata) - SHA512_DIGEST_SIZE, out_stream);

    g_unlink (g_file_get_path (file_encrypted_data));
    // TODO remove encrypted file? Give option to the user

    multiple_unref (5, (gpointer) &file_encrypted_data,
                    (gpointer) &in_stream,
                    (gpointer) &out_stream,
                    (gpointer) &in_file,
                    (gpointer) &out_file);

    multiple_gcry_free (3, (gpointer) &decryption_keys->crypto_key,
                        (gpointer) &decryption_keys->derived_key,
                        (gpointer) &decryption_keys->hmac_key);

    multiple_free (4, (gpointer) &header_metadata,
                   (gpointer) &output_file_path,
                   (gpointer) &original_hmac,
                   (gpointer) &decryption_keys);
}
Ejemplo n.º 18
0
    bool matches(InputStream &stream)
    {
      unsigned char header[12];

      return stream.read(0, header, sizeof header) && decrypt(header);
    }
int main()
{
int listen_sock, conn_sock;
int server_len, client_len;
struct sockaddr_in server_address;
struct sockaddr_in client_address;

listen_sock = socket(AF_INET, SOCK_STREAM, 0);
if (listen_sock == -1)
 {
    printf("khong tao duoc socket\n");
    return 0;
 }
 printf("Tao socket thanh cong\n");

server_address.sin_family = AF_INET;
inet_aton("127.0.0.1",&server_address.sin_addr);
server_address.sin_port = htons(5500);
server_len = sizeof(server_address);

if(bind(listen_sock, (struct sockaddr *)&server_address,server_len)<0)
{
	printf("bind failed.\n");
    return 0;
}
printf("bind done\n");
int check = listen(listen_sock,10);
if (check == -1)
 {
 printf("error connect");
 return 0;
 }
printf("waiting connect ...\n");
while(1) {
		client_len = sizeof(client_address);
		conn_sock = accept(listen_sock,(struct sockaddr *)&client_address, &client_len);
		if(conn_sock==-1){
			printf("error connect\n");
			return 1;
		}else{
			printf("Accept new connection\n");
		}
		if(fork() == 0){
			close(listen_sock);

			int sentBytes,revedBytes,i;
			//char buff[1024];
			int chose;
			while(1){
					revedBytes = recv(conn_sock,buff,1024,0);
					if(revedBytes < 0) break;
					if(strcmp(buff,"S")==0) chose = 1;
					else if(strcmp(buff,"M")==0) chose =2;
					else if(strcmp(buff,"exit")==0) chose = 3;									
					switch(chose){
					case 1:
						printf("Menu1 \n");
						while(1){
						    	revedBytes = recv(conn_sock,buff,1024,0);
						        buff[revedBytes]='\0';
						        if(strcmp(buff,"Q")==0) break;
						        printf("string send by client : %s\n",buff);
						        for(i=0;buff[i]!=NULL;i++)
	   	 						m[i]=buff[i]; 
								n=p*q; 
            					t=(p-1)*(q-1); 
           						 ce();
           						 encrypt();
           							 //decrypt();
           						 for (i = 0; i < strlen(buff); i++)
          							{				
	 								buff[i]=en[i];
					       			}
					    			sentBytes=send(conn_sock,buff,1024,0);
						    		}
								printf("exit menu1 \n");
						break;
					case 2:
						printf("\n Menu2");
						while(1){
						    	revedBytes = recv(conn_sock,buff,1024,0);
						        buff[revedBytes]='\0';
						        if(strcmp(buff,"Q")==0) break;
						        printf("string send by client : %s\n",buff);
						        n=p*q; 
           			 			t=(p-1)*(q-1); 
            					for(i=0;buff[i]!=NULL;i++)
            						en[i]=buff[i] ;
            					ce();decrypt();
           				 		for (i = 0; m[i]!=-1; i++)
            					{
            						buff[i]=(char)m[i];
           			 			}
           			 			buff[i]='\0';
           			 			printf("%s\n",buff);
            					sentBytes=send(conn_sock,buff,1024,0);
						}
						printf("exit menu2 \n");
					break;
					case 3: 
					close(conn_sock);
					break;
					default:
					break;
				}
			}
			close(conn_sock);
			exit(1);
		}
		signal(SIGCHLD,sig_chld);
	}
return 1;
}
Ejemplo n.º 20
0
unsigned char * AesFileEnc::key ( )
{
	FILE* keystore;
	keystore = fopen(this->keystore_path, "r");
	unsigned char *iv = this->iv(32);
	unsigned char* key = new unsigned char[32];
	const char *prompt;
	prompt = getpass("Your password to keystore: " );
	unsigned char* sha;
   sha = SHA256(reinterpret_cast<const unsigned char*>(prompt), 32, NULL); //uwaga
   //printf("SHA %s aaa",(char *)sha);
	delete prompt;
	

  ERR_load_crypto_strings();
  OpenSSL_add_all_algorithms();
  OPENSSL_config(NULL);
  
	if(keystore == NULL)
	{
		keystore = fopen(this->keystore_path, "w+");
		std::cout<<this->keystore_path;
		srand(time(0));
		int j;
		char *buffer;
		buffer = new char;
		for(int i = 0 ; i<32; i++)
		{
			j = (int)(rand() / (RAND_MAX + 1.0) * 16);		
			sprintf(buffer,"%x",j);
			key[i] = *buffer;
		}
		 delete(buffer);

  unsigned char ciphertext[512];

  int ciphertext_len;

  ciphertext_len = this->encrypt (key, 32, sha, iv,
                            ciphertext);
	fprintf(keystore, "%s" ,(const char *)ciphertext);	
	//printf("KLUCZ zapisywany:%s KKK   %i" ,(const char *)ciphertext, ciphertext_len);	
}
else{

  unsigned char * decryptedtext = new unsigned char[512];
  unsigned char* keycipher = new unsigned char[512];
  int ciphertext_len = 0;
  int buff;
  while((buff = getc(keystore))!= EOF)
	{
		keycipher[ciphertext_len] = (unsigned char)buff;
		ciphertext_len++;
	}
	ciphertext_len--;
  //fscanf(keystore, "%512c", keycipher);
  int decryptedtext_len;
	//printf("KLUCZ wczytany:%s KKK   %i" ,(const char *)keycipher, ciphertext_len);	


  decryptedtext_len = decrypt(keycipher, ciphertext_len, sha, iv,
    decryptedtext);
  key = ( unsigned char *)decryptedtext;
}

  unsigned char* KEY;
  KEY = new unsigned char[this->keyLength];
  KEY[this->keyLength] = '\0';
  printf("%s        PIES \n",KEY);
  for(int i =0; i<this->keyLength; i++)
	{KEY[i] = key[i];}

  //delete(key);
  //delete(sha);
    	//std::cout << "tutajkhjghjfghyt" <<std::endl;
  fclose(keystore);
  //std::cout<<this->keyLength <<std::endl;
   //printf("KLUCZ %s",KEY);
  std::cout << (const char *)KEY<<"PIES"<<std::endl;
    std::cout <<key<<"PIES"<<std::endl;
   EVP_cleanup();
  ERR_free_strings();
  return KEY;
	}
Ejemplo n.º 21
0
void Rijndael::decrypt(unsigned char* block, int &length){
	if (block == NULL){
		return;
	}
	unsigned char** _last_cipher_text;
	unsigned char** _next_cipher_text;
	if (_mode != ECB){	//allocates temp mem to save last chain block
		_next_cipher_text = new unsigned char* [4];
		_last_cipher_text = new unsigned char* [4];
		for (int i = 0; i < 4; i++){
			_last_cipher_text[i] = new unsigned char [4];
			_next_cipher_text[i] = new unsigned char [4];
		}
	}
	int blocks = length / (_block_char_size);
	if (length % _block_char_size != 0){
		blocks++;
	}	
	unsigned char* _temp_shifted_block = new unsigned char [16];	// do inverse matrix, so pointers for char** are in position
	unsigned char** _temp_block = new unsigned char* [4];
	for (int b = 0; b < blocks; b++){
		for (int i = 0; i < 4; i++){
			memcpy(_temp_shifted_block+i*4, block+i+0+b*16, 1);
			memcpy(_temp_shifted_block+i*4+1, block+i+4+b*16, 1);
			memcpy(_temp_shifted_block+i*4+2, block+i+8+b*16, 1);
			memcpy(_temp_shifted_block+i*4+3, block+i+12+b*16, 1);
		}
		for (int i = 0; i < 4; i++){
			_temp_block[i] = &_temp_shifted_block[i*4];
		}
		switch (_mode){		// pre block mode
			case ECB:
				break;
			case CBC:
				for (int i = 0; i < 4; i++){
					memcpy(_last_cipher_text[i], _next_cipher_text[i], 4);
					memcpy(_next_cipher_text[i], _temp_block[i], 4);
				}
				break;
			case CFB:
			case OFB:
				if (b != 0){
					for (int i = 0; i < 4; i++){
						memcpy(_next_cipher_text[i], _temp_block[i], 4);
						memcpy(_temp_block[i], _last_cipher_text[i], 4);
					}
				}
				else{
					for (int i = 0; i < 4; i++){
						memcpy(_next_cipher_text[i], _temp_block[i], 4);
						memcpy(_temp_block[i], _iv[i], 4);
					}
				}
				break;
		}
		switch (_mode){		// decrypt or encrypt
			case ECB:
			case CBC:
				decrypt(_temp_block);
				break;
			case CFB:
			case OFB:
				encrypt(_temp_block);
				break;
		}
		switch (_mode){		// pos block mode
			case ECB:
				break;
			case CBC:
				if (b != 0){
					xorBlock(_temp_block, _last_cipher_text);			
				}
				else{
					xorBlock(_temp_block, _iv);
				}
				break;
			case CFB:
				xorBlock(_temp_block, _next_cipher_text);
				for (int i = 0; i < 4; i++){
					memcpy(_last_cipher_text[i], _next_cipher_text[i], 4);
				}
				break;
			case OFB:				
				for (int i = 0; i < 4; i++){
					memcpy(_last_cipher_text[i], _temp_block[i], 4);
				}
				xorBlock(_temp_block, _next_cipher_text);
				break;
		}
		for (int i = 0; i < 4; i++){
			memcpy(block+i*4+b*16, _temp_shifted_block+i+0, 1);
			memcpy(block+i*4+1+b*16, _temp_shifted_block+i+4, 1);
			memcpy(block+i*4+2+b*16, _temp_shifted_block+i+8, 1);
			memcpy(block+i*4+3+b*16, _temp_shifted_block+i+12, 1);
		}
	}
	if (_mode != ECB){
		for (int i = 0; i < 4; i++){
			delete[] _last_cipher_text[i];
			delete[] _next_cipher_text[i];
		}
		delete[] _next_cipher_text;
		delete[] _last_cipher_text;
	}
//	removePadding(block, length, blocks);
	delete[] _temp_block;
	delete[] _temp_shifted_block;
}
Ejemplo n.º 22
0
void pipedecryption(FILE *input, int CoreNumber){

int ProcessCount = 0;
fd_set rfds;
fd_set wfds;
// we are only using the number of cores - because we restrict one to the parent
int ProcessTotal = CoreNumber-1;
int ProcessArr[ProcessTotal];
FD_ZERO(&rfds);
FD_ZERO(&wfds);
// timeval is used for the SELECT function
struct timeval tv;
tv.tv_sec = 100;
tv.tv_usec = 0; 
 
int EncryptionDirectoryPipe[ProcessTotal][2];
int ProcessReadyPipe[ProcessTotal][2];
int ProcessStatus = 1;
int RRcount = 0;
char* directory[2050];
int directorysize;
time_t ltime;



for(int i = 0; i < ProcessTotal; i++){
        // create the pipes. Include error handling if it fails.
        if(pipe(EncryptionDirectoryPipe[i])||pipe(ProcessReadyPipe[i]))
        {
            printf("[%s] Parent #%i failed to pipe. Exiting.\n",CurrTime(ltime), getpid());
            exit(-1);
        }
 
        int ChildID = fork();
        if (ChildID){           // parent process
        FD_SET(ProcessReadyPipe[i][1],&wfds);
        FD_SET(EncryptionDirectoryPipe[i][1],&wfds);
        FD_SET(ProcessReadyPipe[i][0],&rfds);
        // close the writing end of the pipe, we willl be reading from the child for its status
        close(ProcessReadyPipe[i][1]);
        // close reading end, we will be writing to the child processes
        close(EncryptionDirectoryPipe[i][0]);
        // add the child into the ProcessArr to keep track of processes created
        ProcessArr[i] = ChildID;
}
 
 
        else if (ChildID == 0){         // child process
        // close appropriate ends of the pipe for the child process
        close(ProcessReadyPipe[i][0]);
        close(EncryptionDirectoryPipe[i][1]);

        while(1){
        // read from the pipe the length of the incoming msg into dirsize. If its null, the pipe is empty, 
        // so finish the loop with a break.
        int dirsize = 0;
        int readstatus = read(EncryptionDirectoryPipe[i][0], &dirsize,sizeof(int));
        if (readstatus==0){
                break;}
        // get the incoming msg using the size dirsize given in the privious msg
        // create character array with null termination, then zero it out
        char directorybuffer[dirsize+1];
        bzero(&directorybuffer, dirsize+1);
        read(EncryptionDirectoryPipe[i][0], directorybuffer,dirsize);
        // parse the directory into input and output pointers respectfully
        char *inouttemp = strtok(directorybuffer, " ");
        char *input = inouttemp;
        inouttemp = strtok(NULL, " ");
        char *output = inouttemp;
        output = strtok(output, "\n");
        // run decryption
        printf("[%s] Child Process ID #%i will decrypt %s. \n",CurrTime(ltime),getpid(),input);
        if(decrypt(input,output) > 0)
        printf("[%s] Process ID #%i decrypted %s successfully. \n",CurrTime(ltime),getpid(),input);
        if
        // Case for FCFS: send msg to parent saying its ready.
        write(ProcessReadyPipe[i][1],&ProcessStatus,sizeof(ProcessStatus));
        }
        // Process is done all jobs. Close its writing pipe.
        printf("closing all work, jobs are done \n");
        close(ProcessReadyPipe[i][1]);
        exit(0);
        }
        else{
Ejemplo n.º 23
0
SafeVector<uint8_t> ProtectedBuffer::toBuffer(){
	SafeVector<uint8_t> result(data.begin(), data.end());
	decrypt(result.data(), result.size());
	return result;
}
Ejemplo n.º 24
0
 void main()
 {
  encrypt();
  decrypt();
  getch();
 }
Ejemplo n.º 25
0
static void process_firmware_upload_init(uint8_t sock, Remote_Info *remote_info, WIZnet_Header *wiznet_header)
{
    S2E_Packet *value = get_S2E_Packet_pointer();
    struct __network_info_common tmp;
    uint16_t len;
    WIZnet_Firmware_Upload_Init firmware_upload;
    uint8_t buffer[sizeof(WIZnet_Header) + sizeof(WIZnet_Firmware_Upload_Done_Reply)];
    uint32_t ptr;
    WIZnet_Firmware_Upload_Init_Reply reply;
    Firmware_Upload_Info firmware_upload_info;
    S2E_Packet *s2e_packet = get_S2E_Packet_pointer();
    uint8_t ip[4];
    uint16_t port;

    getsockopt(sock, SO_REMAINSIZE, &len);
    if(len != wiznet_header->length)
        return;

    recvfrom(sock, (uint8_t *)&firmware_upload, sizeof(WIZnet_Firmware_Upload_Init), ip, &port);

    if(wiznet_header->op_code[0] != FIRMWARE_UPLOAD_INIT)
        return;

    if((wiznet_header->valid & 0x80))
        decrypt((wiznet_header->valid & 0x7F), (uint8_t *)&firmware_upload, len);

    if(memcmp(firmware_upload.dst_mac_address, s2e_packet->network_info_common.mac, 6))
        return;

    if(strcmp((char *)firmware_upload.set_pw, (char *)s2e_packet->options.pw_setting))
        return;

    /* Storee Current Network Information (For DHCP) */
    memcpy(&tmp, &(value->network_info_common), sizeof(struct __network_info_common));
    load_S2E_Packet_from_storage();
    memcpy(&(value->network_info_common), &tmp, sizeof(struct __network_info_common));
    save_S2E_Packet_to_storage();

    //write the TFTP server ip, port, filename and etc. to storage
    memcpy(&firmware_upload_info.wiznet_header                , wiznet_header                            , sizeof(WIZnet_Header));
    memcpy(&firmware_upload_info.configtool_info              , remote_info                              , sizeof(Remote_Info));
    memcpy(firmware_upload_info.tftp_info.ip                  , (uint8_t *) (firmware_upload.server_ip)  , sizeof(uint8_t)*4);
    memcpy((uint8_t *)&(firmware_upload_info.tftp_info.port)  , (uint8_t *)&(firmware_upload.server_port), sizeof(uint8_t)*2);
    memcpy(firmware_upload_info.filename                      , (uint8_t *) (firmware_upload.file_name)  , sizeof(uint8_t)*50);
    write_storage(0, &firmware_upload_info, sizeof(Firmware_Upload_Info));

    // reply
    wiznet_header->length = sizeof(WIZnet_Firmware_Upload_Init_Reply);
    wiznet_header->op_code[1] = WIZNET_REPLY;

    memcpy(reply.src_mac_address, s2e_packet->network_info_common.mac, 6);

    if((wiznet_header->valid & 0x80))
        encrypt((wiznet_header->valid & 0x7F), (uint8_t *)&reply, sizeof(WIZnet_Firmware_Upload_Init_Reply));

    ptr = 0;
    memcpy(buffer, wiznet_header, sizeof(WIZnet_Header));
    ptr += sizeof(WIZnet_Header);
    memcpy(buffer + ptr, (void *)&reply, sizeof(WIZnet_Firmware_Upload_Init_Reply));
    ptr += sizeof(WIZnet_Firmware_Upload_Init_Reply);

    if(wiznet_header->unicast == 0) {
        memset(remote_info->ip, 255, 4);
    }
    sendto(sock, buffer, ptr, remote_info->ip, remote_info->port);

    // Reboot to bootloader
    NVIC_SystemReset();
}
Ejemplo n.º 26
0
    SecAccessFlags getPermissions(const char *key,const char *obj,IUserDescriptor *udesc,unsigned auditflags,const char * reqSignature, CDateTime * reqUTCTimestamp)
    {
        if (!ldapsecurity||((getLDAPflags()&DLF_ENABLED)==0)) 
            return SecAccess_Full;
        StringBuffer username;
        StringBuffer password;
        if (udesc) 
        {
            udesc->getUserName(username);
            udesc->getPassword(password);
        }
        else
        {
            WARNLOG("NULL UserDescriptor in daldap.cpp getPermissions('%s')",key ? key : "NULL");
        }

        if (0 == username.length())
        {
            username.append(filesdefaultuser);
            decrypt(password, filesdefaultpassword);
        }

        Owned<ISecUser> user = ldapsecurity->createUser(username);
        user->credentials().setPassword(password);

        bool authenticated = false;

        //Check that the digital signature provided by the caller (signature of
        //caller's "scope;username;timeStamp") matches what we expect it to be
        if (!isEmptyString(reqSignature))
        {
            if (nullptr == pDSM)
                pDSM = queryDigitalSignatureManagerInstanceFromEnv();
            if (pDSM && pDSM->isDigiVerifierConfigured())
            {
                StringBuffer requestTimestamp;
                reqUTCTimestamp->getString(requestTimestamp, false);//extract timestamp string from Dali request

                CDateTime now;
                now.setNow();
                if (now.compare(*reqUTCTimestamp) < 0)//timestamp from the future?
                {
                    ERRLOG("LDAP: getPermissions(%s) scope=%s user=%s Request digital signature timestamp %s from the future",key?key:"NULL",obj?obj:"NULL",username.str(), requestTimestamp.str());
                    return SecAccess_None;//deny
                }

                CDateTime expiry;
                expiry.set(now);
                expiry.adjustTime(requestSignatureExpiryMinutes);//compute expiration timestamp

                if (expiry.compare(*reqUTCTimestamp) < 0)//timestamp too far in the past?
                {
                    ERRLOG("LDAP: getPermissions(%s) scope=%s user=%s Expired request digital signature timestamp %s",key?key:"NULL",obj?obj:"NULL",username.str(), requestTimestamp.str());
                    return SecAccess_None;//deny
                }

                VStringBuffer expectedStr("%s;%s;%s", obj, username.str(), requestTimestamp.str());
                StringBuffer b64Signature(reqSignature);// signature of scope;user;timestamp

                if (!pDSM->digiVerify(expectedStr, b64Signature))//does the digital signature match what we expect?
                {
                    ERRLOG("LDAP: getPermissions(%s) scope=%s user=%s fails digital signature verification",key?key:"NULL",obj?obj:"NULL",username.str());
                    return SecAccess_None;//deny
                }

                authenticated = true;//Digital signature verified
            }
            else
                ERRLOG("LDAP: getPermissions(%s) scope=%s user=%s digital signature support not available",key?key:"NULL",obj?obj:"NULL",username.str());
        }

        if (!authenticated && !ldapsecurity->authenticateUser(*user, NULL))
        {
            ERRLOG("LDAP: getPermissions(%s) scope=%s user=%s fails LDAP authentication",key?key:"NULL",obj?obj:"NULL",username.str());
            return SecAccess_None;//deny
        }

        bool filescope = stricmp(key,"Scope")==0;
        bool wuscope = stricmp(key,"workunit")==0;

        if (filescope || wuscope) {
            SecAccessFlags perm = SecAccess_None;
            unsigned start = msTick();
            if (filescope)
                perm=ldapsecurity->authorizeFileScope(*user, obj);
            else if (wuscope)
                perm=ldapsecurity->authorizeWorkunitScope(*user, obj);
            if (perm == SecAccess_Unavailable)
                perm = SecAccess_None;

            unsigned taken = msTick()-start;
#ifndef _DEBUG
            if (taken>100) 
#endif
            {
                PROGLOG("LDAP: getPermissions(%s) scope=%s user=%s returns %d in %d ms",key?key:"NULL",obj?obj:"NULL",username.str(),perm,taken);
            }
            if (auditflags&DALI_LDAP_AUDIT_REPORT) {
                StringBuffer auditstr;
                if ((auditflags&DALI_LDAP_READ_WANTED)&&!HASREADPERMISSION(perm)) 
                    auditstr.append("Lookup Access Denied");
                else if ((auditflags&DALI_LDAP_WRITE_WANTED)&&!HASWRITEPERMISSION(perm)) 
                    auditstr.append("Create Access Denied");
                if (auditstr.length()) {
                    auditstr.append(":\n\tProcess:\tdaserver");
                    auditstr.appendf("\n\tUser:\t%s",username.str());
                    auditstr.appendf("\n\tScope:\t%s\n",obj?obj:"");
                    SYSLOG(AUDIT_TYPE_ACCESS_FAILURE,auditstr.str());
                }
            }
            return perm;
        }
        return SecAccess_Full;
    }
Ejemplo n.º 27
0
Archivo: part02.cpp Proyecto: t274/274
/* Main */
int main(void) {
    // Initialise Arduino functionality
    init();
  
    // Attach USB for applicable processors
    #ifdef USBCON
         USBDevice.attach();
    #endif
    
    /* SETUP */
    int prime = 19211;
    int generator = 6;
    uint16_t private_key = prime + 1;
    
    /* Generates private key, sometimes takes a while */
    while(private_key >= prime){
        private_key = generate_private();
    }
    
    Serial.begin(9600);
    int public_key_A = pow_mod(generator, private_key, prime);
    Serial.print("Public key A: "); Serial.println(public_key_A);
    int public_key_B = enter_public();
    Serial.print("Public key B: "); Serial.println(public_key_B);
    int shared_key = pow_mod(public_key_B, private_key, prime);
    Serial.print("The shared key is: "); Serial.println(shared_key);

    
    /* LOOP */
    Serial3.begin(9600); // Serial3: communication with other board
    int incoming_byte = 0;
    int my_PC_byte = 0;
    while(true){
        
        //grab byte from other Arduino
        incoming_byte = Serial3.read();
        if(incoming_byte != -1){
            //decrypt byte
            int decrypted_byte = decrypt(incoming_byte, shared_key);
            if(decrypted_byte == 10 || decrypted_byte == 13){
                Serial.write('\n'); //character code line feed
                Serial.write('\r'); //carriage return
            }
            else {
                Serial.write(decrypted_byte);
            }
        }
        
        //grab byte from PC
        my_PC_byte = Serial.read();
        if(my_PC_byte != -1){
            //encrypt byte
            char byte_to_send = encrypt(my_PC_byte, shared_key);
            Serial.write((char)my_PC_byte);
            Serial3.write((char)byte_to_send);
        }
    }
    Serial.end();
    Serial3.end();

    return 0;
}
Ejemplo n.º 28
0
int main(int argc, char* argv[])
{
		rsa_packet packet;
		int i;
		bool cipher_done = 0;
		Command cmd;
		timeval hard_time;
	
    int sceMiVersion = SceMi::Version( SCEMI_VERSION_STRING );
    SceMiParameters params("scemi.params");
    SceMi *sceMi = SceMi::Init(sceMiVersion, &params);
    	
    // Initialize the crypto library
    crypto_init();

    // Initialize the SceMi inport
    InportProxyT<Command> inport ("", "scemi_rsaxactor_req_inport", sceMi);

    // Initialize the SceMi outport
    OutportQueueT<BIG_INT> outport ("", "scemi_rsaxactor_resp_outport", sceMi);

    ResetXactor reset("", "scemi", sceMi);
    ShutdownXactor shutdown("", "scemi_shutdown", sceMi);

    // Service SceMi requests
    SceMiServiceThread *scemi_service_thread = new SceMiServiceThread (sceMi);

    reset.reset();
	
    char *test_texts[] = { "deadbeef"
                         , "badf00d"
                         , "0ff1ce"
                         , "cafe"
                         , "defaced"
                         , "aeb45a0ee831ad6e538f9c59300290db92696abbaa06a0b1df6ca317239292160d81f220c99bd788cce66cc41033e2c3eddb"
                         , "46f4ef8bf4cf769bc5ab709267981dbb44801f9c419e99a2fc7639baaf6de6741cee37af64d5d50c87402713505cb51a88fb"
                         , "4d889e31f9a92bd62df29e16047beb747fc92e3eceebab44d399b386825d1f55294f6d854e56d0f9a7b610c67b2ae7b5e5bd36"
                         , "8ecbff22d54c29902bda135826fd302787742d4ce7a064f73c4ecca822235035fbdf1350bb7d9abcb4f54eb3257f2c96798d2e"
                         , "853493ee4fd1fe0cde743cba9b180bff20bd457c152e258b9e3b478bd25fa60a6766b8d36a95885c2c47aaa63f22ff93ebea08"
                         , "050e383b35f7688879a54ef463961533f040f943467b6a5617fdf88000c91c662d0688ddd5144f12c49106d8d81a5e04ff5ca2"
                         , "f355db88fb426ebea4a551ad129d4fcb243b903411e638a08a81e22bfe250937f1194caea4d1f312f06ecfa906d79e8c948a0d"
                         , "11d1e35094599325a2122f2f919a64e4d4ace48812f192ea7c11410c539707149c5d335f921f132d11795bcc1ebbf4a20b65e9"
                         , "7b101a938d50b8dc88780235f226bc1c6650df830c3290565e12d6b9c347c06b1fb0b6fb2e648019c8526e2d4adc4dc766dba5"
                         , "7305d1b0e93f54de5fa19eb1089fa6fbc566f8479cd381ca5894492c3078d23ef3d7a1923b9a96ffb7bf2b727fc28c6d522e54"
                         , "4228043134c88aed152a8cd0d9aef45f742e6d12511d0ecbfbf34ea593998c499f19c6315e8779184ab58dd8e731a25d410d61"
                         , "c04bb261996776e003d70116c3d7d56c6e2375f349983d478416f6600edeec1dbc286d4a57445be4ded180dcb7e157b35a8a4f"
                         , "eac2be8a8e3ef31a292c4faafa9c8a63acf1e4046672c5379215f6f145ce2062ace5587f3ea226f628178426062dd9ff81186c"
                         , "c3387e260634be9995b52c1f7114cf23d01cce8ef598cc8e5364db272aee60d06e626a2a67964d7391d5ed5c7193ab36eba81e"
                         , "ac84645df2aaca9dee4d03e8b900007905f9bfe93bbef391ea7b57513948ec88b252add18db987b0ff886e1c7d25152f7dc1af"
                         , "7176de621be4b8d4f5060b6ae0ab188d2c33f3aeddaddbe639cd89a8ca5784a8cdb0135108eb7f35020556795764c71536b49e"
                         , "1a3f9f30e4c3d5d244c1d9e6cfb8f4dd47f686efb74e99de63358750e6f0622b24afc212a472bf9a93b0d39e79ff4a71ee57c6"
                         , "68a9101d17cadfa1d89353a1d12d878dede2630904fbd8bf08ee36ccaa3c2b1759415ec3fe54bfa9f1034c5a20d01673fa06f6"
                         , "31206814135169d02ec6893064bcaab54d9a2cc44fedc5e16dba2d97adca09fd6838af21e06def28a3815dccae369ce1e2f4af"
                         , "f536b2e57395c6421008095dc6832282d8083ac466debc88f5979e8ada0e0b4820754f0325de29d77c46eada3683bb5be3fd10"
                         };
    for (int tests = 0; tests < 20; tests++) {
      char *public_key, *private_key;
      printf("Generating keypair in software...");
      generate_key(&packet, &public_key, &private_key);
      
      #ifdef DEFINE
        printf("Raw data dump\n Modulus length: %zi\n", packet.mod_len);
        for(i = 0; i < packet.mod_len; i++) {
          printf("%02X", packet.mod[i]);
        }
        
        printf("\nPrivate exponent length: %zi\n", packet.priv_len);
        for(i = 0; i < packet.priv_len; i++) {
          printf("%02X", packet.priv_exp[i]);
        }
        
          printf("\nPublic exponent length: %zi\n", packet.pub_len);
        for(i = 0; i < packet.pub_len; i++) {
          printf("%02X", packet.pub_exp[i]);
        }
      #endif

      printf("Public Key:\n%s\n", public_key);
      printf("Private Key:\n%s\n", private_key);
    
      char *plaintext = test_texts[tests];
      printf("Plain Text:\n%s\n\n", plaintext);
    
      char *ciphertext;
      ciphertext = encrypt(&packet, public_key, plaintext);
      printf("Software-calculated cipher Text:\n%s\n", ciphertext);
    
          printf("\nCiphertext length: %zi\n", packet.cipher_len);
        for(i = 0; i < packet.cipher_len; i++) {
          printf("%02X", packet.ciphertext[i]);
        }		  
    
    
      char *decrypted;
      decrypted = decrypt(private_key, ciphertext);
      printf("\nSoftware-decrypted plain Text:\n%s\n\n", decrypted);
    
      /*char *signature;
      signature = sign(private_key, plaintext);
      printf("Software signature:\n%s\n", signature);
      
      if (verify(public_key, plaintext, signature)) {
        printf("Software signature GOOD!\n");
      } else {
        printf("Software signature BAD!\n");
      }*/
      
      printf("Sending to FPGA..\n");

      
      // Pack the command for transport to FPGA
      // Command is specified in Command.h, run build and look in tbinclude
      // Assuming mod_len >= priv_len/pub_len/len(ciphertext)
      for(i = 0; i < packet.mod_len; i++) {
        cmd.m_modulus = packet.mod[packet.mod_len - i - 1];
        
        // Send the data for decryption
        if(i < packet.priv_len) {
          cmd.m_exponent = packet.priv_exp[packet.priv_len - i - 1];
        } else {
          cmd.m_exponent = 0;
        }
        
        // Since the exponent is short, pack it backwards
        if(i < packet.cipher_len) {
          cmd.m_data = packet.ciphertext[packet.cipher_len - i - 1];
        } else {
          cmd.m_data = 0;
        }
        
        //printf("Sending message %i, mod: %X coeff: %X data:%X\n", i, cmd.m_data.get(), cmd.m_exponent.get(), cmd.m_data.get());
        inport.sendMessage(cmd);
      }
        
      printf("Sending padding, 1 packet");
      cmd.m_modulus = 0;
      cmd.m_exponent = 0;
      cmd.m_data = 0;
      timer_start(&hard_time);
      inport.sendMessage(cmd);
        
      printf("Getting result..");
      
      std::cout << "Result: " << outport.getMessage() << std::endl;
      timer_poll("FPGA wall time: %d.%06d    seconds\n", &hard_time);
    }

    std::cout << "shutting down..." << std::endl;
    shutdown.blocking_send_finish();
    scemi_service_thread->stop();
    scemi_service_thread->join();
    SceMi::Shutdown(sceMi);
    std::cout << "finished" << std::endl;

    return 0;
}
Ejemplo n.º 29
0
int main(int argc, char **argv)
{
	int encrypt_opt = 0;
	int decrypt_opt = 0;
	int input_opt = 0;
	int output_opt = 0;
	char *input_filename = NULL;
	char *output_filename = NULL;
 
	int input_fd;
	int output_fd;
	off_t file_len;
	char *p;
	char buf[sizeof(image_header_t) + 3];
	image_header_t *header;
 
	while (1) {
		static struct option long_options[] = {
			{"encrypt", no_argument,       0, 'e'},
			{"decrypt", no_argument,       0, 'd'},
			{"input",   required_argument, 0, 'i'},
			{"output",  required_argument, 0, 'o'},
			{0,         0,                 0, 0  }
		};
		int option_index = 0;
		int c = getopt_long(argc, argv, "dei:o:",
		                long_options, &option_index);
		if (c == -1)
			break;
 
		switch (c) {
		case 'd':
			decrypt_opt++;
			if (decrypt_opt > 1) {
				fprintf(stderr, "%s: decrypt may only be specified once\n",
				        argv[0]);
				show_usage(argv[0]);
			}
			break;
 
		case 'e':
			encrypt_opt++;
			if (encrypt_opt > 1) {
				fprintf(stderr, "%s: encrypt may only be specified once\n",
				        argv[0]);
				show_usage(argv[0]);
			}
			break;
 
		case 'i':
			input_opt++;
			if (input_opt > 1) {
				fprintf(stderr, "%s: only one input file may be specified\n",
				        argv[0]);
				show_usage(argv[0]);
			}
			if (strcmp("-", optarg) != 0) {
				input_filename = optarg;
			}
			break;
 
		case 'o':
			output_opt++;
			if (output_opt > 1) {
				fprintf(stderr, "%s: only one output file may be specified\n",
				        argv[0]);
				show_usage(argv[0]);
			}
			if (strcmp("-", optarg) != 0) {
				output_filename = optarg;
			}
			break;
 
		case '?':
			exit(-1);
 
		default:
			abort();
		}
	}
 
	if (decrypt_opt && encrypt_opt) {
		fprintf(stderr, "%s: decrypt and encrypt may not be used together\n",
		        argv[0]);
		show_usage(argv[0]);
	}
 
	if (!decrypt_opt && !encrypt_opt) {
		fprintf(stderr, "%s: neither decrypt or encrypt were specified\n",
		        argv[0]);
		show_usage(argv[0]);
	}
 
	temp_fd = fileno(tmpfile());
	if (temp_fd < 0) {
		fprintf(stderr, "Can't create temporary file\n");
		exit(EXIT_FAILURE);
	}
 
	atexit(exit_cleanup);
	DES_set_key_unchecked((const_DES_cblock *)DES_KEY, &schedule);
 
	if (input_filename) {
		input_fd = open(input_filename, O_RDONLY);
		if (input_fd < 0) {
			fprintf(stderr, "Can't open %s for reading: %s\n", input_filename,
			        strerror(errno));
			exit(EXIT_FAILURE);
		}
		copy_file(input_fd, temp_fd);
		close(input_fd);
	}
	else {
		copy_file(STDIN_FILENO, temp_fd);
	}
 
	file_len = lseek(temp_fd, 0, SEEK_CUR);
	if (file_len < 64) {
		fprintf(stderr, "Not enough data\n");
		exit(EXIT_FAILURE);
	}
 
	p = mmap(0, file_len, PROT_READ|PROT_WRITE, MAP_SHARED, temp_fd, 0);
	if (p == MAP_FAILED) {
		fprintf(stderr, "mmap failed: %s\n", strerror(errno));
		exit(EXIT_FAILURE);
	}	
 
	if (encrypt_opt) {
		header = (image_header_t *)p;
		off_t len = min(file_len,
		                ntohl(header->ih_size) + sizeof(image_header_t));
		if (ntohl(header->ih_magic) != IH_MAGIC) {
			fprintf(stderr, "Header magic incorrect: "
			        "expected 0x%08X, got 0x%08X\n",
			        IH_MAGIC, ntohl(header->ih_magic));
			munmap(p, file_len);
			exit(EXIT_FAILURE);
		}
		encrypt(p, len);
		munmap(p, file_len);
		if (len != file_len) {
			if (ftruncate(temp_fd, len) < 0) {
				fprintf(stderr, "ftruncate failed: %s\n", strerror(errno));
				exit(EXIT_FAILURE);
			}
		}		
	}
 
	if (decrypt_opt) {
		off_t header_len = min(file_len, sizeof(image_header_t) + 3);
		memcpy(buf, p, header_len);
		decrypt(buf, header_len);
		header = (image_header_t *)buf;
		if (ntohl(header->ih_magic) != IH_MAGIC) {
			fprintf(stderr, "Header magic incorrect: "
			        "expected 0x%08X, got 0x%08X\n",
			        IH_MAGIC, ntohl(header->ih_magic));
			exit(EXIT_FAILURE);
		}
		decrypt(p, file_len);
		munmap(p, file_len);
	}
 
	lseek(temp_fd, 0, SEEK_SET);
	if (output_filename) {
		output_fd = creat(output_filename, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
		if (output_fd < 0) {
			fprintf(stderr, "Can't open %s for writing: %s\n",
			        output_filename, strerror(errno));
			exit(EXIT_FAILURE);
		}
		copy_file(temp_fd, output_fd);
		close(output_fd);
	}
	else {
		copy_file(temp_fd, STDOUT_FILENO);
	}
 
	exit(EXIT_SUCCESS);
	return 0;
}
Ejemplo n.º 30
0
static int dosignencode(int dosign, int doencode, int dodecode,
                        FILE *fpin, FILE *fpout,
                        int argc, char **argv)
{
    struct mimestack *boundary_stack=0;
    int iseof=0;

    while (!iseof)
    {
        static const char ct_s[]="content-type:";
        struct header *h=read_headers(&boundary_stack, &iseof, fpin,
                                      fpout, dodecode ? 0:1),
                         *hct;

        if (iseof && !h)
            continue;	/* Artifact */

        hct=find_header(h, ct_s);

        /*
        ** If this is a multipart MIME section, we can keep on
        ** truckin'.
        **
        */

        if (hct)
        {
            struct mime_header *mh=
                parse_mime_header(hct->header+
                                  (sizeof(ct_s)-1));

            const char *bv;

            if (strcasecmp(mh->header_name, "multipart/x-mimegpg")
                    == 0)
            {
                /* Punt */

                char *buf=malloc(strlen(hct->header)+100);
                const char *p;

                if (!buf)
                {
                    free_mime_header(mh);
                    free_header(h);
                    perror("malloc");
                    exit(1);
                }
                strcpy(buf, "Content-Type: multipart/mixed");
                p=strchr(hct->header, ';');
                strcat(buf, p ? p:"");
                free(hct->header);
                hct->header=buf;

                mh=parse_mime_header(hct->header+
                                     sizeof(ct_s)-1);
            }

            if (strncasecmp(mh->header_name, "multipart/", 10)==0
                    && (bv=get_mime_attr(mh, "boundary")) != 0

                    && (doencode & ENCODE_ENCAPSULATE) == 0
               )
            {
                struct header *p;

                push_mimestack(&boundary_stack, bv);

                if (dodecode)
                {
                    if (strcasecmp(mh->header_name,
                                   "multipart/signed")==0
                            && (dodecode & DECODE_CHECKSIGN)
                            && isgpg(mh))
                    {
                        print_noncontent_headers(h,
                                                 fpout
                                                );
                        free_mime_header(mh);
                        checksign(&boundary_stack,
                                  &iseof,
                                  h, fpin, fpout,
                                  argc, argv);
                        free_header(h);
                        continue;
                    }

                    if (strcasecmp(mh->header_name,
                                   "multipart/encrypted")
                            ==0
                            && (dodecode & DECODE_UNENCRYPT)
                            && isgpg(mh))
                    {
                        print_noncontent_headers(h,
                                                 fpout
                                                );
                        free_mime_header(mh);
                        decrypt(&boundary_stack,
                                &iseof,
                                h,
                                fpin, fpout,
                                argc, argv);
                        free_header(h);
                        continue;
                    }
                }

                for (p=h; p; p=p->next)
                {
                    fprintf(fpout, "%s", p->header);
                }

                putc('\n', fpout);
                free_header(h);
                free_mime_header(mh);

                find_boundary(&boundary_stack, &iseof, fpin,
                              fpout, dodecode ? 0:1);
                continue;
            }
            free_mime_header(mh);
        }

        if (dodecode)
        {
            struct header *p;
            int is_message_rfc822=0;

            for (p=h; p; p=p->next)
            {
                fprintf(fpout, "%s", p->header);
            }
            putc('\n', fpout);

            /*
            ** If this is a message/rfc822 attachment, we can
            ** resume reading the next set of headers.
            */

            hct=find_header(h, ct_s);
            if (hct)
            {
                struct mime_header *mh=
                    parse_mime_header(hct->header+
                                      (sizeof(ct_s)-1));

                if (strcasecmp(mh->header_name,
                               "message/rfc822") == 0)
                    is_message_rfc822=1;
                free_mime_header(mh);
            }
            free_header(h);

            if (!is_message_rfc822)
                find_boundary(&boundary_stack, &iseof,
                              fpin, fpout, 0);
            continue;
        }

        if (doencode)
            dogpgencrypt(&boundary_stack, h, &iseof,
                         fpin, fpout, argc, argv, dosign);
        else
            dogpgsign(&boundary_stack, h, &iseof,
                      fpin, fpout, argc, argv);
        free_header(h);
    }

    if (ferror(fpout))
        return (1);
    return (0);
}