🔧Technical deep Dive

Server and Encryption

Overview

The Python files implement a Pedersen Commitment scheme for privacy-preserving encrypted values and a Flask web application to facilitate user interaction with the model training process. This includes functionalities for file uploads, model training, and encrypted data handling.

1. Pedersen Commitment Implementation

Imports

pythonCopy codeimport os
import sys
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.asymmetric import rsa

• The os module is used for file handling and generating random bytes.

• The sys module allows interaction with the Python interpreter, particularly for command-line arguments.

• The cryptography library provides the necessary cryptographic primitives, specifically for RSA key generation.

Prime Generation

pythonCopy codedef generate_large_prime(bit_length):
    return rsa.generate_private_key(public_exponent=65537, key_size=bit_length, backend=default_backend()).private_numbers().p

• This function generates a large prime number using RSA. The bit_length parameter specifies the size of the prime.

• It leverages RSA's private key generation to extract the prime ppp.

Pedersen Commitment Class

pythonCopy codeclass PedersonCommitment:
    def __init__(self, security=1024):
        self.p = generate_large_prime(security)
        self.q = generate_large_prime(security * 2)
        self.g = int.from_bytes(os.urandom(32), 'big') % self.q
        self.s = int.from_bytes(os.urandom(32), 'big') % self.q
        self.h = pow(self.g, self.s, self.q)

• Initialization: The constructor initializes the Pedersen commitment scheme:

  • Generates two large primes ppp and qqq.

  • Initializes the generator ggg and a secret sss from random bytes, ensuring ggg is less than qqq.

  • Computes hhh using ggg raised to the power of sss modulo qqq.

Commitment Methods

pythonCopy code    def commit(self, x):
        r = int.from_bytes(os.urandom(32), 'big') % self.q
        c = (pow(self.g, x, self.q) * pow(self.h, r, self.q)) % self.q
        return c, r

• Commit: This method takes a value xxx and commits it using a random value rrr:

  • The commitment ccc is computed using gxg^xgx and hrh^rhr, both modulo qqq.

  • Returns the commitment and the random value rrr.

pythonCopy code    def verify(self, c, x, r):
        return c == (pow(self.g, x, self.q) * pow(self.h, r, self.q)) % self.q

• Verify: Validates a commitment against the original value and randomness, ensuring that the provided ccc matches the expected computation.

pythonCopy code    def add_commitments(self, c1, c2):
        return (c1 * c2) % self.q

• Add Commitments: Allows the addition of two commitments, crucial for aggregating multiple encrypted values.

Utility Functions

pythonCopy codedef encrypt_cost(cost):
    cost_int = int(cost)
    c, r = commitment.commit(cost_int)
    print(f"Encrypted cost: {c}")
    sys.stdout.flush()
    return c, r

• Encrypt Cost: Takes a cost as input, commits it using the Pedersen scheme, and prints the encrypted value. It returns the commitment and the random value.

pythonCopy codedef aggregate_commitments(commitments):
    result = 1
    for c in commitments:
        result = commitment.add_commitments(result, c)
    return result

• Aggregate Commitments: Iterates through a list of commitments, adding them together to form a single aggregated commitment.

Flask Web Application

Flask Setup

pythonCopy codeapp = Flask(__name__)
CORS(app)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER

• Initializes a Flask application and enables CORS (Cross-Origin Resource Sharing) to allow requests from other origins.

File Upload Functions

pythonCopy codedef allowed_file_dataset(filename):
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS_DATASET

def allowed_file_model(filename):
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS_MODEL

• File Validation: These utility functions check if uploaded files have the correct extensions (CSV for datasets and PKL/PY for models).

Routes

pythonCopy [e-mail]('/')
def index():
    return render_template('index.html')

• Index Route: Renders the main page of the application.

pythonCopy [e-mail]('/model_trainer', methods=['POST'])
def model_trainer():
    ...

• Model Trainer Route: Handles dataset uploads. It checks if the uploaded file is valid, saves it to the specified directory, and redirects to the index page.

pythonCopy [e-mail]('/model_upload', methods=['POST'])
def model_upload():
    ...

• Model Upload Route: Accepts model files via JSON data in the request body, saves them, and confirms successful uploads.

pythonCopy [e-mail]('/stake')
def stake():
    ...

• Stake Route: Executes a bash script for model training. It captures the output and returns it as a JSON response, providing feedback on the training process.