QByteArray CppDiffieHellman::ProveSharedSecret(const QByteArray &remote_pub) const { // For modular arithmetic in our DH group CryptoPP::Integer modulus = _dh_params.GetGroupParameters().GetModulus(); CryptoPP::Integer generator = _dh_params.GetGroupParameters().GetGenerator(); // Arithmetic modulo N CryptoPP::ModularArithmetic mod_arith(modulus); // Arithmetic modulo phi(N) = N-1 CryptoPP::ModularArithmetic mod_arith_phi(modulus-1); CppHash hash; CppDiffieHellman rand_key; // A random value v in the group Z_q QByteArray value_bytes = rand_key.GetPrivateComponent(); CppIntegerData value(value_bytes); // g -- the group generator QByteArray gen = CppIntegerData(generator).GetByteArray(); // g^a -- where a is the prover's secret QByteArray prover_pub = GetPublicComponent(); // g^b -- where b is the other guy's secret QByteArray other_pub = remote_pub; // g^(ab) -- Where a is the prover's secret QByteArray dh_secret = GetSharedSecret(other_pub); // t_1 = g^v CryptoPP::Integer commit_1_int = mod_arith.Exponentiate(generator, value.GetCryptoInteger()); QByteArray commit_1 = CppIntegerData(commit_1_int).GetByteArray(); // t_2 = (g^b)^v -- Where b is the other guy's secret QByteArray commit_2 = rand_key.GetSharedSecret(other_pub); // c = HASH(g, g^a, g^b, g^ab, t_1, t_2) QByteArray challenge_bytes = hash.ComputeHash(gen + prover_pub + other_pub + dh_secret + commit_1 + commit_2); CppIntegerData challenge_data(challenge_bytes); CryptoPP::Integer challenge = challenge_data.GetCryptoInteger(); // a = prover secret CryptoPP::Integer prover_priv = CppIntegerData(GetPrivateComponent()).GetCryptoInteger(); // prod = c*a mod n CryptoPP::Integer product_ca = mod_arith_phi.Multiply(challenge, prover_priv); // r = v - ca mod n CryptoPP::Integer response = mod_arith_phi.Subtract(value.GetCryptoInteger(), product_ca); CppIntegerData response_data(response); // TEST CryptoPP::Integer commit_1p = mod_arith.CascadeExponentiate(generator, response, CppIntegerData(prover_pub).GetCryptoInteger(), challenge); // Get encoded version of data QByteArray challenge_enc = challenge_data.GetByteArray(); QByteArray response_enc = response_data.GetByteArray(); // The header is 3 4-byte lengths QByteArray header(ZeroKnowledgeProofHeaderSize, 0); int len_dh_secret = dh_secret.count(); int len_challenge = challenge_enc.count(); int len_response = response_enc.count(); Utils::Serialization::WriteInt(len_dh_secret, header, 0); Utils::Serialization::WriteInt(len_challenge, header, 4); Utils::Serialization::WriteInt(len_response, header, 8); // We return (dh_secret, challenge, response) return header + dh_secret + challenge_enc + response_enc; }
int main(int argc, char*argv[]) { char* test = (char *) malloc(500*sizeof(char)); json_error_t error; json_t *root; json_t *data; json_t *j_type; json_t *j_data; json_t *phone; const char *type; const char *customer_phone; int server_sockfd, client_sockfd; int server_len, client_len; struct sockaddr_in server_address; struct sockaddr_in client_address; server_sockfd = socket(PF_INET, SOCK_STREAM, 0); server_address.sin_family = PF_INET; // server_address.sin_addr.s_addr = inet_addr("127.0.0.1"); server_address.sin_addr.s_addr = htonl(INADDR_ANY); server_address.sin_port = htons(9733); server_len = sizeof(server_address); bind(server_sockfd, (struct sockaddr *)&server_address, server_len); listen(server_sockfd, 5); while (1) { test = (char *) malloc(500*sizeof(char)); printf("server waitting\n"); client_len = sizeof(client_address); client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_address, &client_len); read(client_sockfd, test, 500); root = json_loads(test, 0, &error); free(test); if(!root) { fprintf(stderr, "error: on line %d: %s\n", error.line, error.text); // Response error to client response_data(0, json_object(), client_sockfd); } else { j_type = json_object_get(root, "type"); j_data = json_object_get(root, "data"); if (!j_type || !j_data) { response_data(0, json_object(), client_sockfd); } else { type = json_string_value(j_type); printf("Type: %s\n", type); if (strcmp(type, "gcustomerinfo") == 0) { const char * phone = get_value(root, "phone"); json_t *data = get_customer(phone); response_data(1, data, client_sockfd); } else if (strcmp(type, "pcustomerinfo") == 0) { const char * name = get_value(root, "name"); const char * email = get_value(root, "email"); const char * address = get_value(root, "address"); const char * phone = get_value(root, "phone"); const char * gender = get_value(root, "gender"); json_t *data = new_customer(name, email, address, phone, gender, "test"); response_data(1, data, client_sockfd); } else if (strcmp(type, "ucustomerinfo") == 0) { const char * id = get_value(root, "id"); const char * name = get_value(root, "name"); const char * email = get_value(root, "email"); const char * address = get_value(root, "address"); const char * gender = get_value(root, "gender"); json_t *data = update_customer(id, name, email, address, gender); response_data(1, data, client_sockfd); } else if (strcmp(type, "porder") == 0) { const char * customer_id = get_value(root, "id"); const char * message = get_value(root, "message"); json_t *data = new_order(customer_id, message); response_data(1, data, client_sockfd); } else if (strcmp(type, "porderdetail") == 0) { const char * order_id = get_value(root, "oid"); const char * product_id = get_value(root, "pid"); const char * quantity = get_value(root, "quantity"); json_t *data = new_order_detail(order_id, product_id, quantity); response_data(1, data, client_sockfd); // Default } else { response_data(0, json_object(), client_sockfd); } } } close(client_sockfd); } }