zkp hmac communication cpp

ZK-Call＆Labs

使用C ++中的HMAC通信的“零知识”证明实现

_{由zk-call构建:)}

目录

• 学分
• 目的
• 它如何工作
• API
• 示例用法

学分

该存储库持有Schnorr协议的精致实施，并创新地纳入了一种状态种子，以进行增强的安全措施。尽管基本证据可能看起来很复杂，但我旨在尽我所能阐明它们的功能。但是，为了深入了解，我鼓励参考基于此实施的开创性研究论文，因为它们提供了全面的见解。

---

进一步探索：

基于椭圆曲线的“零知识”证明及其对资源约束设备的适用性

---

此外，该存储库深入研究“零知识”证明（ZKP）和基于哈希的消息身份验证代码（HMAC）的概念。 ZKP是加密协议，允许一个方（供奉献者）向另一方（验证者）证明给定的语句是真实的，而无需透露任何其他信息以外的任何其他信息。该财产对于在建立信任的同时保留隐私特别有价值。

另一方面， HMAC是用于消息身份验证的一种加密哈希功能。它们涉及加密哈希功能（例如SHA-256）和秘密加密密钥。 HMAC提供了一种验证消息的数据完整性和真实性的方法，以确保在传输过程中未对其进行更改或篡改，并且确实源自声称的发件人。

目的

在当今迅速发展的IT和应用程序开发环境中， “零知识”证明（ZKPS）作为身份验证安全性的关键范式出现。他们确认索赔的有效性的能力，例如证明拥有秘密密码 - 而没有透露有关索赔本身的任何敏感信息，例如密码或哈希，这彻底改变了对安全AAA操作（身份验证，授权和会计）的保证。

---

ZK-Call＆Labs代表非相互作用的“零知识”证明（NIZKP）协议的实现，专门针对验证基于文本的秘密。该框架证明，可以保护密码和其他身份验证机制，从而确保不损害隐私权的强大安全措施。此外， HMAC的集成（基于哈希的消息身份验证代码）进一步巩固了身份验证过程，增强了数据完整性并挫败潜在的安全漏洞。

它如何工作

本系统中采用的身份验证协议基于两个基本概念运行： “零知识”证明（ZKP）和基于哈希的消息身份验证代码（HMAC） 。让我们深入研究这些组件中的每一个，并了解它们如何协同化以确保消息应用程序中的安全身份验证。

“零知识”证明（ZKP）

“零知识”证明（ZKP）：

ZKP构成了隐私保护身份验证机制的基础。这些证据允许一方（供奉献者）证明另一方（验证者）索赔的有效性，而无需透露索赔有效性以外的任何其他信息。从本质上讲， ZKPS可以启用身份验证，而无需供奉献者披露敏感数据，例如密码或加密密钥。

---

身份验证的应用：

在消息传递应用程序的背景下， ZKP在验证用户的身份方面起着关键作用，而无需通过网络传输明确的凭据。取而代之的是，用户可以生成信函证明，以证明其身份或拥有某些凭据的情况，而无需揭露这些凭据。这样可以确保在身份验证过程中保密敏感信息，从而加强安全性和隐私。

基于哈希的消息身份验证代码（HMAC）

基于哈希的消息身份验证代码（HMAC）：

HMAC提供了一种强大的机制，用于验证当事方之间交换消息的完整性和真实性。它涉及使用加密哈希功能与秘密键一起生成每个消息的唯一代码（HMAC） 。该代码是数字签名，允许收件人验证该消息在传输过程中尚未被篡改或更改。

---

身份验证的应用：

在消息传递应用程序中，可以使用HMAC来验证消息发件人并确保通信渠道的完整性。通过使用共享的秘密密钥将HMAC附加到每个消息上，发件人和收件人都可以在收到后验证消息的真实性。对消息的任何未经授权的修改都将导致计算的HMAC与接收到的HMAC之间的不匹配，从而提醒收件人潜在的篡改。

协同操作

合并后， “零知识”证明和HMAC创建了一个强大的框架，用于消息传递应用程序中的安全身份验证。 ZKP促进身份验证，而无需泄露敏感信息，而HMAC可确保当事方之间交换消息的完整性和真实性。这些机制共同维护了通信渠道的机密性，完整性和真实性，保护了数字领域中用户的隐私和安全性。

---

API

"HMAC_Client" „ ch ++ API的意图是简单而直观的：

核心组件

Core Components简化了安全消息加密和解密，支持块和角色级处理以增强数据保护。

---

hmac_client.encrypt_message_by_chunks

通过在块中处理消息来加密消息的方法。

 std::string encrypt_message_by_chunks(const std::string& message);

    message: string                    # The message to be encrypted, processed in chunks

hmac_client.encrypt_message

通过字符加密消息的方法。

 std::string encrypt_message(const std::string& message);

    message: string                    # The message to be encrypted, processed in characters

hmac_client.decrypt_message_by_chunks

通过在块中处理消息来解密消息的方法。

 std::string decrypt_message_by_chunks(const std::string& message);

    message: string                    # The message to be decrypted, processed in chunks

hmac_client.decrypt_message

通过以字符处理消息来解密消息的方法。

 std::string encrypt_message(const std::string& message);

    message: string                    # The message to be decrypted, processed in characters

---

示例用法

托多：包括Example Usage

示例1

 #include <iostream> // Include the input/output stream standard header
#include <thread> // Include the thread standard header
#include <queue> // Include the queue standard header
#include <string> // Include the string standard header
#include "src/HMAC/core/base.h" // Include the header file for HMAC_Client functionality
#include "src/SeedGeneration/core/base.h" // Include the header file for SeedGenerator functionality

constexpr bool DEBUG = true; // Define a constexpr boolean variable DEBUG with value true

void print_msg(const std::string &who, const std::string &message) { // Define a function to print messages
    if (DEBUG) { // Check if debugging is enabled
        std::cout << "[" << who << "] " << message << std::endl; // Print the message with source identifier
    }
}

bool check_if_queue_empty(std::queue<std::string> &socket) { // Define a function to check if a queue is empty
    while (true) { // Infinite loop
        if (!socket.empty()) { // Check if the queue is not empty
            return true; // Return true if the queue is not empty
        }
    }
}

std::string get_content_from_socket(std::queue<std::string> &socket) { // Define a function to get content from a socket (queue)
    if (check_if_queue_empty(socket)) { // Check if the queue is not empty
        std::string val = socket.front(); // Get the front element of the queue
        socket.pop(); // Remove the front element from the queue
        return val; // Return the retrieved value
    }
}

void client(std::queue<std::string> &client_socket, std::queue<std::string> &server_socket) { // Define the client function
    // Generating the main seed
    SeedGenerator seed_generator("job"); // Create an instance of SeedGenerator
    std::vector<unsigned char> main_seed = seed_generator.generate(); // Generate the main seed

    // Creating an instance of HMAC_Client for encrypting messages
    print_msg("client", "first");
    HMAC_Client obj("sha256", main_seed, 1); // Create an instance of HMAC_Client

    // Sending the main seed to the server
    server_socket.emplace(main_seed.begin(), main_seed.end()); // Convert the main seed vector to a string and send it to the server
    print_msg("client", "after obj");

    // Checking if the server has successfully received the seed
    if (get_content_from_socket(client_socket) == obj.encrypt_message("")) { // Check if the server received the seed
        print_msg("client", "after if");

        // If successful, send a message to the server
        std::string message = "hello"; // Define the message to be sent
        server_socket.push(obj.encrypt_message_by_chunks(message)); // Encrypt and send the message to the server
        print_msg("client", "client sent message " + message);

        // Checking if the server has successfully decrypted the message
        if (get_content_from_socket(client_socket) == obj.encrypt_message(message)) { // Check if the server decrypted the message
            print_msg("client", "server has decrypted message");
        }
    }
}

void server(std::queue<std::string> &server_socket, std::queue<std::string> &client_socket) { // Define the server function
    // Receiving the main seed from the client
    std::string main_seed = get_content_from_socket(server_socket); // Receive the main seed from the client

    // Creating an instance of HMAC_Client for encrypting messages
    HMAC_Client obj("sha256", std::vector<unsigned char>(main_seed.begin(), main_seed.end()), 1); // Create an instance of HMAC_Client

    // Sending an empty message to the client as acknowledgment
    client_socket.push(obj.encrypt_message("")); // Encrypt and send an empty message to the client as acknowledgment

    // Receiving the encrypted message from the client
    std::string msg = get_content_from_socket(server_socket); // Receive the encrypted message from the client
    print_msg("server", "message encrypted: " + msg);

    // Decrypting the message
    print_msg("server", "before decrypt ");
    std::string msg_raw = obj.decrypt_message_by_chunks(msg); // Decrypt the received message
    print_msg("server", "message raw: " + msg_raw);

    // Sending the encrypted message back to the client
    client_socket.push(obj.encrypt_message(msg_raw)); // Encrypt and send the decrypted message back to the client
}

int main() { // Main function
    std::queue<std::string> client_socket, server_socket; // Create queues for client and server sockets
    std::thread client_thread(client, std::ref(client_socket), std::ref(server_socket)); // Create a thread for the client function
    std::thread server_thread(server, std::ref(server_socket), std::ref(client_socket)); // Create a thread for the server function

    // Joining the threads to wait for their completion
    client_thread.join(); // Wait for the client thread to finish
    server_thread.join(); // Wait for the server thread to finish

    return 0; // Return 0 to indicate successful execution
}

---

示例2

 #include "src/ZeroKnowledge/core/base.h" // Include the header file for ZeroKnowledge class

int main() { // Main function
    // Creating a ZeroKnowledge object for the client with specified curve and hash algorithm
    ZeroKnowledge clientObject = ZeroKnowledge::createNew("secp256k1", "sha3_256");

    // Creating a ZeroKnowledge object for the server with specified curve and hash algorithm
    ZeroKnowledge serverObject = ZeroKnowledge::createNew("secp384r1", "sha3_512");

    // Setting the server password
    std::string serverPassword = "SecretServerPassword";

    // Creating a signature for the server password
    ZeroKnowledgeSignature serverSignature = serverObject.createSignature(serverPassword);

    // Creating a signature for the client identity
    std::string identity = "John";
    ZeroKnowledgeSignature clientSignature = clientObject.createSignature(identity);
    std::cout<<"beforen";

    // Generating a token signed by the server for the client
    std::cout<<clientObject.token()<<"n";

    ZeroKnowledgeData token = serverObject.sign(serverPassword, clientObject.token());
    std::cout<<"aftern";

    // Generating proof using client identity and token
    ZeroKnowledgeData proof = clientObject.sign(identity, token.data);

    // Verifying the received proof
    bool serverVerification = serverObject.verify(token, serverSignature);
    if (!serverVerification) { // Check if server verification failed
        std::cout << "Server verification failed" << std::endl; // Print error message
    } else { // If server verification succeeded
        // Otherwise, verify the proof using client signature
        bool clientVerification = clientObject.verify(token, clientSignature, proof.proof);
        if (!clientVerification) { // Check if client verification failed
            std::cout << "Client verification failed" << std::endl; // Print error message
        } else { // If client verification succeeded
            std::cout << "Authentication successful" << std::endl; // Print success message
        }
    }

    return 0; // Return 0 to indicate successful execution
}

---

示例3

 #include "src/ZeroKnowledge/core/base.h" // Include the header file for ZeroKnowledge class
#include "src/HMAC/core/base.h" // Include the header file for HMAC_Client functionality
#include "src/SeedGeneration/core/base.h" // Include the header file for SeedGenerator functionality
#include <iostream> // Include the input/output stream standard header
#include <thread> // Include the thread standard header
#include <queue> // Include the queue standard header
#include <string> // Include the string standard header

constexpr bool DEBUG = true; // Define a constexpr boolean variable DEBUG with value true

void print_msg(const std::string &who, const std::string &message) { // Define a function to print messages
    if (DEBUG) { // Check if debugging is enabled
        std::cout << "[" << who << "] " << message << std::endl; // Print the message with source identifier
    }
}

bool check_if_queue_empty(std::queue<std::string> &socket) { // Define a function to check if a queue is empty
    while (true) { // Infinite loop
        if (!socket.empty()) { // Check if the queue is not empty
            return true; // Return true if the queue is not empty
        }
    }
}

std::string get_content_from_socket(std::queue<std::string> &socket) { // Define a function to get content from a socket (queue)
    if (check_if_queue_empty(socket)) { // Check if the queue is not empty
        std::string val = socket.front(); // Get the front element of the queue
        socket.pop(); // Remove the front element from the queue
        return val; // Return the retrieved value
    }
}

void client(std::queue<std::string> &client_socket, std::queue<std::string> &server_socket) { // Define the client function
    // Generating the main seed
    SeedGenerator seed_generator("job"); // Create an instance of SeedGenerator
    std::vector<unsigned char> main_seed = seed_generator.generate(); // Generate the main seed

    // Creating an instance of HMAC_Client for encrypting messages
    print_msg("client", "first");
    HMAC_Client obj("sha256", main_seed, 1); // Create an instance of HMAC_Client

    // Sending the main seed to the server
    server_socket.emplace(main_seed.begin(), main_seed.end()); // Convert the main seed vector to a string and send it to the server
    print_msg("client", "after obj");

    // Checking if the server has successfully received the seed
    if (get_content_from_socket(client_socket) == obj.encrypt_message("")) { // Check if the server received the seed
        print_msg("client", "after if");

        // If successful, send a message to the server
        std::string message = "hello"; // Define the message to be sent
        server_socket.push(obj.encrypt_message_by_chunks(message)); // Encrypt and send the message to the server
        print_msg("client", "client sent message " + message);

        // Checking if the server has successfully decrypted the message
        if (get_content_from_socket(client_socket) == obj.encrypt_message(message)) { // Check if the server decrypted the message
            print_msg("client", "server has decrypted message");
        }
    }
}

void server(std::queue<std::string> &server_socket, std::queue<std::string> &client_socket) { // Define the server function
    // Receiving the main seed from the client
    std::string main_seed = get_content_from_socket(server_socket); // Receive the main seed from the client

    // Creating an instance of HMAC_Client for encrypting messages
    HMAC_Client obj("sha256", std::vector<unsigned char>(main_seed.begin(), main_seed.end()), 1); // Create an instance of HMAC_Client

    // Sending an empty message to the client as acknowledgment
    client_socket.push(obj.encrypt_message("")); // Encrypt and send an empty message to the client as acknowledgment

    // Receiving the encrypted message from the client
    std::string msg = get_content_from_socket(server_socket); // Receive the encrypted message from the client
    print_msg("server", "message encrypted: " + msg);

    // Decrypting the message
    print_msg("server", "before decrypt ");
    std::string msg_raw = obj.decrypt_message_by_chunks(msg); // Decrypt the received message
    print_msg("server", "message raw: " + msg_raw);

    // Sending the encrypted message back to the client
    client_socket.push(obj.encrypt_message(msg_raw)); // Encrypt and send the decrypted message back to the client
}

void init_talking() { // Define a function to initialize client-server communication
    std::queue<std::string> client_socket, server_socket; // Create queues for client and server sockets
    std::thread client_thread(client, std::ref(client_socket), std::ref(server_socket)); // Create a thread for the client function
    std::thread server_thread(server, std::ref(server_socket), std::ref(client_socket)); // Create a thread for the server function

    // Joining the threads to wait for their completion
    client_thread.join(); // Wait for the client thread to finish
    server_thread.join(); // Wait for the server thread to finish
}

int main() { // Main function

    // Creating a ZeroKnowledge object for the client with specified curve and hash algorithm
    ZeroKnowledge clientObject = ZeroKnowledge::createNew("secp256k1", "sha3_256");

    // Creating a ZeroKnowledge object for the server with specified curve and hash algorithm
    ZeroKnowledge serverObject = ZeroKnowledge::createNew("secp384r1", "sha3_512");

    // Setting the server password
    std::string serverPassword = "SecretServerPassword";

    // Creating a signature for the server password
    ZeroKnowledgeSignature serverSignature = serverObject.createSignature(serverPassword);

    // Creating a signature for the client identity
    std::string identity = "John";
    ZeroKnowledgeSignature clientSignature = clientObject.createSignature(identity);
    std::cout << "beforen";

    // Generating a token signed by the server for the client
    std::cout << clientObject.token() << "n";

    ZeroKnowledgeData token = serverObject.sign(serverPassword, clientObject.token());
    std::cout << "aftern";

    // Generating proof using client identity and token
    ZeroKnowledgeData proof = clientObject.sign(identity, token.data);

    // Verifying the received proof
    bool serverVerification = serverObject.verify(token, serverSignature);
    if (!serverVerification) { // Check if server verification failed
        std::cout << "Server verification failed" << std::endl; // Print error message
    } else { // If server verification succeeded
        // Otherwise, verify the proof using client signature
        bool clientVerification = clientObject.verify(token, clientSignature, proof.proof);
        if (!clientVerification) { // Check if client verification failed
            std::cout << "Client verification failed" << std::endl; // Print error message
        } else { // If client verification succeeded
            std::cout << "Authentication successful" << std::endl; // Print success message
            init_talking(); // Initialize client-server communication

        }
    }

    return 0; // Return 0 to indicate successful execution
}