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);
}
}
