CCF_Node.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: requests in ./.venv/lib/python3.11/site-packages (2.31.0)\n",
      "Requirement already satisfied: charset-normalizer<4,>=2 in ./.venv/lib/python3.11/site-packages (from requests) (3.3.2)\n",
      "Requirement already satisfied: idna<4,>=2.5 in ./.venv/lib/python3.11/site-packages (from requests) (3.4)\n",
      "Requirement already satisfied: urllib3<3,>=1.21.1 in ./.venv/lib/python3.11/site-packages (from requests) (2.1.0)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in ./.venv/lib/python3.11/site-packages (from requests) (2023.7.22)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "%pip install requests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loding libray and settingp config \n",
    "\n",
    "# Connecting with CCF netowrks.\n",
    "\n",
    "# Loading libaries \n",
    "import requests\n",
    "import json\n",
    "import os\n",
    "import subprocess\n",
    "import sys\n",
    "import base64\n",
    "import hashlib\n",
    "from urllib.parse import urlparse\n",
    "import subprocess\n",
    "import json\n",
    "import time\n",
    "import os\n",
    "import glob\n",
    "\n",
    "\n",
    "RSA_SIZE = 2048\n",
    "\n",
    "\n",
    "DEFAULT_CURVE = \"secp384r1\"\n",
    "FAST_CURVE = \"secp256r1\"\n",
    "SUPPORTED_CURVES = [DEFAULT_CURVE, FAST_CURVE]\n",
    "\n",
    "DIGEST_SHA384 = \"sha384\"\n",
    "DIGEST_SHA256 = \"sha256\"\n",
    "\n",
    "RSA_SIZE = 2048\n",
    "# CCF network node\n",
    "server=\"https://127.0.0.1:8000\"\n",
    "\n",
    "num_users = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status Code: 200\n",
      "\n",
      "Response Headers:\n",
      "content-length: 176\n",
      "content-type: application/json\n",
      "x-ms-ccf-transaction-id: 2.12\n",
      "\n",
      "Response Body:\n",
      "{\n",
      "    \"metrics\": [\n",
      "        {\n",
      "            \"calls\": 1,\n",
      "            \"errors\": 0,\n",
      "            \"failures\": 0,\n",
      "            \"method\": \"GET\",\n",
      "            \"path\": \"api/metrics\",\n",
      "            \"retries\": 0\n",
      "        },\n",
      "        {\n",
      "            \"calls\": 2,\n",
      "            \"errors\": 0,\n",
      "            \"failures\": 0,\n",
      "            \"method\": \"GET\",\n",
      "            \"path\": \"commit\",\n",
      "            \"retries\": 0\n",
      "        }\n",
      "    ]\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "# Getting Network metrices\n",
    "url = server + \"/app/api/metrics\"\n",
    "\n",
    "try:\n",
    "    response = requests.get(url, verify='service_cert.pem')\n",
    "\n",
    "    print(\"Status Code:\", response.status_code)\n",
    "    print(\"\\nResponse Headers:\")\n",
    "    for header, value in response.headers.items():\n",
    "        print(f\"{header}: {value}\")\n",
    "\n",
    "    print(\"\\nResponse Body:\")\n",
    "    try:\n",
    "        # Attempt to parse JSON and print it in an indented format\n",
    "        response_json = response.json()\n",
    "        print(json.dumps(response_json, indent=4))\n",
    "    except ValueError:\n",
    "        # If response is not JSON, print as plain text\n",
    "        print(response.text)\n",
    "\n",
    "except requests.exceptions.RequestException as e:\n",
    "    print(\"Error making request:\", e)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "user0_cert.pem does not exist\n",
      "user0_privk.pem does not exist\n",
      "user0_enc_privk.pem does not exist\n",
      "user0_enc_pubk.pem does not exist\n",
      "user1_cert.pem does not exist\n",
      "user1_privk.pem does not exist\n",
      "user1_enc_privk.pem does not exist\n",
      "user1_enc_pubk.pem does not exist\n",
      "user2_cert.pem does not exist\n",
      "user2_privk.pem does not exist\n",
      "user2_enc_privk.pem does not exist\n",
      "user2_enc_pubk.pem does not exist\n",
      "member1_cert.pem does not exist\n",
      "member1_privk.pem does not exist\n",
      "member1_enc_privk.pem does not exist\n",
      "member1_enc_pubk.pem does not exist\n",
      "member2_cert.pem does not exist\n",
      "member2_privk.pem does not exist\n",
      "member2_enc_privk.pem does not exist\n",
      "member2_enc_pubk.pem does not exist\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import glob\n",
    "\n",
    "def delete_user_and_member_files(num_users, num_members):\n",
    "    for i in range(num_users):\n",
    "        # User file names based on user index\n",
    "        user_files = [f\"user{i}_cert.pem\", f\"user{i}_privk.pem\", f\"user{i}_enc_privk.pem\", f\"user{i}_enc_pubk.pem\"]\n",
    "\n",
    "        # Delete user files if they exist\n",
    "        for file in user_files:\n",
    "            if os.path.exists(file):\n",
    "                os.remove(file)\n",
    "                print(f\"Deleted {file}\")\n",
    "            else:\n",
    "                print(f\"{file} does not exist\")\n",
    "\n",
    "        # Delete all JSON files related to the user\n",
    "        for json_file in glob.glob(f\"set_user{i}*.json\"):\n",
    "            os.remove(json_file)\n",
    "            print(f\"Deleted {json_file}\")\n",
    "\n",
    "    for j in range(1, num_members + 1):\n",
    "        # Member file names based on member index\n",
    "        member_files = [f\"member{j}_cert.pem\", f\"member{j}_privk.pem\", f\"member{j}_enc_privk.pem\", f\"member{j}_enc_pubk.pem\"]\n",
    "\n",
    "        # Delete member files if they exist\n",
    "        for file in member_files:\n",
    "            if os.path.exists(file):\n",
    "                os.remove(file)\n",
    "                print(f\"Deleted {file}\")\n",
    "            else:\n",
    "                print(f\"{file} does not exist\")\n",
    "\n",
    "        # Delete all JSON files related to the member\n",
    "        for json_file in glob.glob(f\"set_member{j}*.json\"):\n",
    "            os.remove(json_file)\n",
    "            print(f\"Deleted {json_file}\")\n",
    "\n",
    "# Example usage\n",
    "delete_user_and_member_files(num_users=3, num_members=2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Keygenrator function for public and private key with ballat request file\n",
    "\n",
    "\n",
    "def generate_keys(name, curve=DEFAULT_CURVE, generate_encryption_key=False):\n",
    "    if not name:\n",
    "        print(\"Error: The name of the participant should be specified (e.g. member0 or user1)\")\n",
    "        sys.exit(1)\n",
    "\n",
    "    if curve not in SUPPORTED_CURVES:\n",
    "        print(f\"{curve} curve is not in {SUPPORTED_CURVES}\")\n",
    "        sys.exit(1)\n",
    "\n",
    "    digest = DIGEST_SHA384 if curve == DEFAULT_CURVE else DIGEST_SHA256\n",
    "\n",
    "    cert = f\"{name}_cert.pem\"\n",
    "    privk = f\"{name}_privk.pem\"\n",
    "\n",
    "    print(f\"-- Generating identity private key and certificate for participant \\\"{name}\\\"...\")\n",
    "    print(f\"Identity curve: {curve}\")\n",
    "\n",
    "    subprocess.run([\"openssl\", \"ecparam\", \"-out\", privk, \"-name\", curve, \"-genkey\"], check=True)\n",
    "    subprocess.run([\"openssl\", \"req\", \"-new\", \"-key\", privk, \"-x509\", \"-nodes\", \"-days\", \"365\", \"-out\", cert, f\"-{digest}\", \"-subj\", f\"/CN={name}\"], check=True)\n",
    "\n",
    "    print(f\"Identity private key generated at: {privk}\")\n",
    "    print(f\"Identity certificate generated at: {cert}\")\n",
    "\n",
    "    enc_priv, enc_pub = None, None\n",
    "    if generate_encryption_key:\n",
    "        print(f\"-- Generating RSA encryption key pair for participant \\\"{name}\\\"...\")\n",
    "\n",
    "        enc_priv = f\"{name}_enc_privk.pem\"\n",
    "        enc_pub = f\"{name}_enc_pubk.pem\"\n",
    "\n",
    "        subprocess.run([\"openssl\", \"genrsa\", \"-out\", enc_priv, str(RSA_SIZE)], check=True)\n",
    "        subprocess.run([\"openssl\", \"rsa\", \"-in\", enc_priv, \"-pubout\", \"-out\", enc_pub], check=True)\n",
    "\n",
    "        print(f\"Encryption private key generated at: {enc_priv}\")\n",
    "        print(f\"Encryption public key generated at: {enc_pub}\")\n",
    "\n",
    "    return cert, enc_pub\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def create_certificatefor_member(cert_name):\n",
    "    cert_file = f\"{cert_name}_cert.pem\"\n",
    "    set_member_file = f\"set_{cert_name}.json\"\n",
    "    \n",
    "    # Call the generate_keys function (make sure to include it in your script)\n",
    "    cert_content, pub_key_content = generate_keys(cert_name)\n",
    "\n",
    "    # Read the certificate file and format it\n",
    "    with open(cert_file, 'r') as file:\n",
    "        cert_content = file.read().replace('\\n', '\\n')\n",
    "\n",
    "    # Create the JSON content\n",
    "    user_json = {\n",
    "        \"actions\": [\n",
    "            {\n",
    "                \"name\": \"set_member\",\n",
    "                \"args\": {\n",
    "                    \"cert\": cert_content,\n",
    "                    \"encryption_pub_key\": pub_key_content\n",
    "                }\n",
    "            }\n",
    "        ]\n",
    "    }\n",
    "\n",
    "    # Write the JSON to a file\n",
    "    with open(set_member_file, 'w') as file:\n",
    "        json.dump(user_json, file, indent=2)\n",
    "    print(f\"JSON file created at: {set_member_file}\")\n",
    "    \n",
    "\n",
    "\n",
    "def send_secure_request(url, request_data_path, signing_privk, signing_cert, command=\"post\"):\n",
    "    def read_request_data(request_path):\n",
    "        if request_path.startswith('@'):\n",
    "            with open(request_path[1:], 'r') as file:\n",
    "                return file.read()\n",
    "        else:\n",
    "            return request_path\n",
    "\n",
    "    def calculate_digest(data):\n",
    "        sha256_hash = hashlib.sha256()\n",
    "        sha256_hash.update(data.encode('utf-8'))\n",
    "        return base64.b64encode(sha256_hash.digest()).decode()\n",
    "\n",
    "    def create_signature(string_to_sign, priv_key_path):\n",
    "        process = subprocess.Popen(\n",
    "            ['openssl', 'dgst', '-sha384', '-sign', priv_key_path],\n",
    "            stdin=subprocess.PIPE,\n",
    "            stdout=subprocess.PIPE,\n",
    "            stderr=subprocess.PIPE\n",
    "        )\n",
    "        signature, _ = process.communicate(string_to_sign.encode())\n",
    "        return base64.b64encode(signature).decode().replace('\\n', '')\n",
    "\n",
    "    def prepare_string_to_sign(method, url, digest, data_length):\n",
    "        parsed_url = urlparse(url)\n",
    "        path = parsed_url.path\n",
    "        return f\"(request-target): {method.lower()} {path}\\ndigest: SHA-256={digest}\\ncontent-length: {data_length}\"\n",
    "\n",
    "    def get_cert_key_id(cert_path):\n",
    "        proc = subprocess.Popen(\n",
    "            ['openssl', 'x509', '-in', cert_path, '-noout', '-fingerprint', '-sha256'],\n",
    "            stdout=subprocess.PIPE,\n",
    "            stderr=subprocess.PIPE\n",
    "        )\n",
    "        output, _ = proc.communicate()\n",
    "        fingerprint = output.decode().split('=')[1].replace(':', '').lower().replace('\\n', '')\n",
    "        return fingerprint\n",
    "\n",
    "    request_data = read_request_data(request_data_path)\n",
    "    request_digest = calculate_digest(request_data)\n",
    "    string_to_sign = prepare_string_to_sign(command, url, request_digest, str(len(request_data)))\n",
    "    signature = create_signature(string_to_sign, signing_privk)\n",
    "    key_id = get_cert_key_id(signing_cert)\n",
    "\n",
    "    headers = {\n",
    "        \"Digest\": f\"SHA-256={request_digest}\",\n",
    "        \"Authorization\": f'Signature keyId=\"{key_id}\",algorithm=\"hs2019\",headers=\"(request-target) digest content-length\",signature=\"{signature}\"'\n",
    "    }\n",
    "\n",
    "    response = requests.post(url, data=request_data, headers=headers, verify='service_cert.pem')\n",
    "    return response.status_code, response.text\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# sending voting to add  the user based on proposal id \n",
    "\n",
    "def send_ballot_request(server_url, proposal_id, data_file_path, signing_privk_path, signing_cert_path):\n",
    "    def read_request_data(file_path):\n",
    "        with open(file_path, 'r') as file:\n",
    "            return file.read()\n",
    "\n",
    "    def calculate_digest(data):\n",
    "        sha256_hash = hashlib.sha256()\n",
    "        sha256_hash.update(data.encode('utf-8'))\n",
    "        return base64.b64encode(sha256_hash.digest()).decode()\n",
    "\n",
    "    def create_signature(string_to_sign, priv_key_path):\n",
    "        process = subprocess.Popen(\n",
    "            ['openssl', 'dgst', '-sha384', '-sign', priv_key_path],\n",
    "            stdin=subprocess.PIPE,\n",
    "            stdout=subprocess.PIPE,\n",
    "            stderr=subprocess.PIPE\n",
    "        )\n",
    "        signature, _ = process.communicate(string_to_sign.encode())\n",
    "        return base64.b64encode(signature).decode().replace('\\n', '')\n",
    "\n",
    "    def prepare_string_to_sign(url, digest, data_length):\n",
    "        parsed_url = urlparse(url)\n",
    "        path = parsed_url.path\n",
    "        return f\"(request-target): post {path}\\ndigest: SHA-256={digest}\\ncontent-length: {data_length}\"\n",
    "\n",
    "    def get_cert_key_id(cert_path):\n",
    "        proc = subprocess.Popen(\n",
    "            ['openssl', 'x509', '-in', cert_path, '-noout', '-fingerprint', '-sha256'],\n",
    "            stdout=subprocess.PIPE,\n",
    "            stderr=subprocess.PIPE\n",
    "        )\n",
    "        output, _ = proc.communicate()\n",
    "        fingerprint = output.decode().split('=')[1].replace(':', '').lower().replace('\\n', '')\n",
    "        return fingerprint\n",
    "\n",
    "    url = f\"{server_url}/gov/proposals/{proposal_id}/ballots\"\n",
    "    request_data = read_request_data(data_file_path)\n",
    "    request_digest = calculate_digest(request_data)\n",
    "    string_to_sign = prepare_string_to_sign(url, request_digest, str(len(request_data)))\n",
    "    signature = create_signature(string_to_sign, signing_privk_path)\n",
    "    key_id = get_cert_key_id(signing_cert_path)\n",
    "\n",
    "    headers = {\n",
    "        \"Digest\": f\"SHA-256={request_digest}\",\n",
    "        \"Authorization\": f'Signature keyId=\"{key_id}\",algorithm=\"hs2019\",headers=\"(request-target) digest content-length\",signature=\"{signature}\"',\n",
    "        \"Content-Type\": \"application/json\"\n",
    "    }\n",
    "\n",
    "    response = requests.post(url, data=request_data, headers=headers, verify='service_cert.pem')\n",
    "    return response.status_code, response.json()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# creation of user id based on certifacte \n",
    "def get_certificate_fingerprint(cert_path):\n",
    "    process = subprocess.Popen(\n",
    "        ['openssl', 'x509', '-in', cert_path, '-noout', '-fingerprint', '-sha256'],\n",
    "        stdout=subprocess.PIPE,\n",
    "        stderr=subprocess.PIPE\n",
    "    )\n",
    "    output, _ = process.communicate()\n",
    "    fingerprint = output.decode().split('=')[1].replace(':', '').lower().strip()\n",
    "    return fingerprint\n",
    "\n",
    "\n",
    "\n",
    "import json\n",
    "\n",
    "def create_certificate(cert_name, entity_type):\n",
    "    cert_file = f\"{cert_name}_cert.pem\"\n",
    "    pub_key_file = f\"{cert_name}_enc_pubk.pem\"  # Public key file name\n",
    "    set_file = f\"set_{cert_name}.json\"\n",
    "    \n",
    "    # Adjust the generate_keys function call based on entity type\n",
    "    if entity_type == \"member\":\n",
    "        cert_content, pub_key_content = generate_keys(cert_name, generate_encryption_key=True)\n",
    "    elif entity_type == \"user\":\n",
    "        cert_content = generate_keys(cert_name, generate_encryption_key=False)[0]\n",
    "    else:\n",
    "        raise ValueError(\"entity_type must be 'user' or 'member'\")\n",
    "\n",
    "    # Read the certificate file and format it\n",
    "    with open(cert_file, 'r') as file:\n",
    "        cert_content = file.read()\n",
    "\n",
    "    # Create the JSON content\n",
    "    action_args = {\"cert\": cert_content}\n",
    "    if entity_type == \"member\":\n",
    "        # Read the public key file and format it\n",
    "        with open(pub_key_file, 'r') as file:\n",
    "            pub_key_content = file.read()\n",
    "        action_args[\"encryption_pub_key\"] = pub_key_content\n",
    "\n",
    "    user_json = {\n",
    "        \"actions\": [\n",
    "            {\n",
    "                \"name\": f\"set_{entity_type}\",\n",
    "                \"args\": action_args\n",
    "            }\n",
    "        ]\n",
    "    }\n",
    "\n",
    "    # Write the JSON to a file\n",
    "    with open(set_file, 'w') as file:\n",
    "        json.dump(user_json, file, indent=2)\n",
    "    print(f\"JSON file created at: {set_file}\")\n",
    "\n",
    "# Replace generate_keys call with the actual implementation\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- Generating identity private key and certificate for participant \"member1\"...\n",
      "Identity curve: secp384r1\n",
      "Identity private key generated at: member1_privk.pem\n",
      "Identity certificate generated at: member1_cert.pem\n",
      "-- Generating RSA encryption key pair for participant \"member1\"...\n",
      "Encryption private key generated at: member1_enc_privk.pem\n",
      "Encryption public key generated at: member1_enc_pubk.pem\n",
      "JSON file created at: set_member1.json\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "writing RSA key\n"
     ]
    }
   ],
   "source": [
    "# Add member \n",
    "# Example usage\n",
    "# Create member1\n",
    "create_certificate(\"member1\", \"member\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- Generating identity private key and certificate for participant \"member2\"...\n",
      "Identity curve: secp384r1\n",
      "Identity private key generated at: member2_privk.pem\n",
      "Identity certificate generated at: member2_cert.pem\n",
      "-- Generating RSA encryption key pair for participant \"member2\"...\n",
      "Encryption private key generated at: member2_enc_privk.pem\n",
      "Encryption public key generated at: member2_enc_pubk.pem\n",
      "JSON file created at: set_member2.json\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "writing RSA key\n"
     ]
    }
   ],
   "source": [
    "# Create member2\n",
    "create_certificate(\"member2\", \"member\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status code: 200 Response: {\"ballot_count\":0,\"proposal_id\":\"e95a83e7dda04bfa03037f743a845003e364bb6b21cc847dc2a590c95013bd38\",\"proposer_id\":\"2c860575e24c88bc239f69833051401b5bac15016ad60f80d9b7e4b63f5c95f0\",\"state\":\"Accepted\",\"votes\":{}}\n",
      "propsal is already accpeted\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Adding new two member and then activationg\n",
    "\n",
    "member1 = \"member1\"\n",
    "member2 = \"member2\"\n",
    "\n",
    "# Send request to add member1\n",
    "status_code, response_json = send_secure_request(\n",
    "    server + \"/gov/proposals\",\n",
    "    f\"@set_{member2}.json\",\n",
    "    \"member0_privk.pem\",\n",
    "    \"member0_cert.pem\",\n",
    "    \"post\"\n",
    ")\n",
    "print(\"Status code:\", status_code, \"Response:\", response_json)\n",
    "response=json.loads(response_json)\n",
    "# Check if the request was successful and then proceed to vote\n",
    "if status_code == 200 and response[\"state\"]==\"open\" :\n",
    "    # Extract the proposal ID from response_json, replace 'proposal_id_field' with the actual field name\n",
    "    proposal_id=response['proposal_id']\n",
    "\n",
    "    # Send a vote for the proposal\n",
    "    vote_status, response_json = send_ballot_request(\n",
    "        server,\n",
    "        proposal_id,\n",
    "        \"vote_accept.json\",\n",
    "        \"member0_privk.pem\",\n",
    "        \"member0_cert.pem\"\n",
    "    )\n",
    "    print(\"Voting status:\", vote_status, \"Response:\", response_json)\n",
    "elif status_code==200 and response[\"state\"]==\"Accepted\":\n",
    "    print(\"propsal is already accpeted\")\n",
    "else:\n",
    "    print(\"Failed to add member, status code:\", status_code)\n",
    "  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "import subprocess\n",
    "import hashlib\n",
    "import base64\n",
    "from urllib.parse import urlparse\n",
    "import json\n",
    "\n",
    "def send_ack_request(server_url, state_digest, signing_privk_path, signing_cert_path):\n",
    "    def create_signature(string_to_sign, priv_key_path):\n",
    "        process = subprocess.Popen(\n",
    "            ['openssl', 'dgst', '-sha384', '-sign', priv_key_path],\n",
    "            stdin=subprocess.PIPE,\n",
    "            stdout=subprocess.PIPE,\n",
    "            stderr=subprocess.PIPE\n",
    "        )\n",
    "        signature, _ = process.communicate(string_to_sign.encode())\n",
    "        return base64.b64encode(signature).decode().replace('\\n', '')\n",
    "\n",
    "    def prepare_string_to_sign(url, digest, data_length):\n",
    "        parsed_url = urlparse(url)\n",
    "        path = parsed_url.path\n",
    "        return f\"(request-target): post {path}\\ndigest: SHA-256={digest}\\ncontent-length: {data_length}\"\n",
    "\n",
    "    def get_cert_key_id(cert_path):\n",
    "        proc = subprocess.Popen(\n",
    "            ['openssl', 'x509', '-in', cert_path, '-noout', '-fingerprint', '-sha256'],\n",
    "            stdout=subprocess.PIPE,\n",
    "            stderr=subprocess.PIPE\n",
    "        )\n",
    "        output, _ = proc.communicate()\n",
    "        fingerprint = output.decode().split('=')[1].replace(':', '').lower().replace('\\n', '')\n",
    "        return fingerprint\n",
    "\n",
    "    def calculate_digest(data):\n",
    "        sha256_hash = hashlib.sha256()\n",
    "        sha256_hash.update(data.encode('utf-8'))\n",
    "        return base64.b64encode(sha256_hash.digest()).decode()\n",
    "\n",
    "    url = f\"{server_url}/gov/ack\"\n",
    "    request_data = json.dumps({\"state_digest\": state_digest})\n",
    "    request_digest = calculate_digest(request_data)\n",
    "    string_to_sign = prepare_string_to_sign(url, request_digest, str(len(request_data)))\n",
    "    signature = create_signature(string_to_sign, signing_privk_path)\n",
    "    key_id = get_cert_key_id(signing_cert_path)\n",
    "\n",
    "    headers = {\n",
    "        \"Digest\": f\"SHA-256={request_digest}\",\n",
    "        \"Authorization\": f'Signature keyId=\"{key_id}\",algorithm=\"hs2019\",headers=\"(request-target) digest content-length\",signature=\"{signature}\"',\n",
    "        \"Content-Type\": \"application/json\"\n",
    "    }\n",
    "\n",
    "    response = requests.post(url, data=request_data, headers=headers, verify='service_cert.pem')\n",
    "    return response.status_code, response.json() if response.status_code != 204 else {}\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Response: {'state_digest': 'ae3d3ef06e5460820379f5147c46237f60bc7b4cdaae160571ab99037535eacd'}\n",
      "State digest saved to member2_request.json\n"
     ]
    }
   ],
   "source": [
    "import requests\n",
    "import json\n",
    "\n",
    "def create_and_save_state_digest(server, cert_path, priv_key_path, output_file):\n",
    "    update_state_digest_url = server + \"/gov/ack/update_state_digest\"\n",
    "\n",
    "    try:\n",
    "        response = requests.post(update_state_digest_url, cert=(cert_path, priv_key_path), verify=\"service_cert.pem\")\n",
    "\n",
    "        # Check if the request was successful\n",
    "        if response.status_code == 200:\n",
    "            # Parse response to JSON\n",
    "            response_json = response.json()\n",
    "            print(\"Response:\", response_json)\n",
    "\n",
    "            # Write the response to a JSON file\n",
    "            with open(output_file, 'w') as file:\n",
    "                json.dump(response_json, file, indent=4)\n",
    "            print(f\"State digest saved to {output_file}\")\n",
    "        else:\n",
    "            print(f\"Request failed with status code: {response.status_code}\")\n",
    "\n",
    "    except requests.exceptions.RequestException as e:\n",
    "        print(f\"Error making request: {e}\")\n",
    "\n",
    "\n",
    "cert = \"member2_cert.pem\"\n",
    "private_key = \"member2_privk.pem\"\n",
    "output_file = \"member2_request.json\"\n",
    "\n",
    "create_and_save_state_digest(server, cert, private_key, output_file)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "response 400 responsdata {'error': {'code': 'StateDigestMismatch', 'message': 'Submitted state digest is not valid.'}}\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "def read_state_digest(file_path):\n",
    "    with open(file_path, 'r') as file:\n",
    "        data = json.load(file)\n",
    "        return data['state_digest']\n",
    "\n",
    "# Read the state digest from request.json\n",
    "state_digest = read_state_digest(\"member2_request.json\")\n",
    "\n",
    "# Now pass the actual state digest to the function\n",
    "response_code, response_data = send_ack_request(server, state_digest, \"member2_privk.pem\", \"member2_cert.pem\")\n",
    "print(\"response\", response_code, \"responsdata\", response_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "member2=get_certificate_fingerprint(\"member2_cert.pem\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "https://127.0.0.1:8000/gov/service/members/2a3c15070488c2914ce7302bb818728f998a72907a44866631e056052528acf1\n",
      "Status Code: (404, '{\"error\":{\"code\":\"ResourceNotFound\",\"message\":\"Unknown path: /service/members/2a3c15070488c2914ce7302bb818728f998a72907a44866631e056052528acf1.\"}}')\n",
      "\n",
      "Response Headers:\n"
     ]
    }
   ],
   "source": [
    "urlr=f\"{server}/gov/service/members/{member2}\"\n",
    "print(urlr)\n",
    "try:\n",
    "    response = requests.get(urlr, verify='service_cert.pem',cert=(\"member2_cert.pem\",\"member2_privk.pem\"))\n",
    "\n",
    "    print(\"Status Code:\", response.status_code)\n",
    "    print(\"\\nResponse Headers:\")\n",
    "    for header, value in response.headers.items():\n",
    "        print(f\"{header}: {value}\")\n",
    "\n",
    "    print(\"\\nResponse Body:\")\n",
    "    try:\n",
    "        # Attempt to parse JSON and print it in an indented format\n",
    "        response_json = response.json()\n",
    "        print(json.dumps(response_json, indent=4))\n",
    "    except ValueError:\n",
    "        # If response is not JSON, print as plain text\n",
    "        print(response.text)\n",
    "\n",
    "except requests.exceptions.RequestException as e:\n",
    "    print(\"Error making request:\", e)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- Generating identity private key and certificate for participant \"user0\"...\n",
      "Identity curve: secp384r1\n",
      "Identity private key generated at: user0_privk.pem\n",
      "Identity certificate generated at: user0_cert.pem\n",
      "JSON file created at: set_user0.json\n",
      "-- Generating identity private key and certificate for participant \"user1\"...\n",
      "Identity curve: secp384r1\n",
      "Identity private key generated at: user1_privk.pem\n",
      "Identity certificate generated at: user1_cert.pem\n",
      "JSON file created at: set_user1.json\n",
      "proposal_id e66e6452c9825471c88cc8f379add1832916acab45f11c6297de4ef32a04dc83\n",
      "vote_status 400 response_json {'error': {'code': 'ProposalNotOpen', 'message': 'Proposal e66e6452c9825471c88cc8f379add1832916acab45f11c6297de4ef32a04dc83 is currently in state accepted - only open proposals can receive votes.'}}\n",
      "Voting failed for user0 by member1\n",
      "vote_status 400 response_json {'error': {'code': 'ProposalNotOpen', 'message': 'Proposal e66e6452c9825471c88cc8f379add1832916acab45f11c6297de4ef32a04dc83 is currently in state accepted - only open proposals can receive votes.'}}\n",
      "Voting failed for user0 by member2\n",
      "Actual id 4661b79776cffaad5c7e3729666e3dd3a32cbda9e43f2fe80bde7dbac1ae913b\n",
      "proposal_id 50504fbedc683c5c59d0fd937f54b0f1e212ed3ff7ec730ec44689dd0ae42fc1\n",
      "vote_status 400 response_json {'error': {'code': 'ProposalNotOpen', 'message': 'Proposal 50504fbedc683c5c59d0fd937f54b0f1e212ed3ff7ec730ec44689dd0ae42fc1 is currently in state accepted - only open proposals can receive votes.'}}\n",
      "Voting failed for user1 by member1\n",
      "vote_status 400 response_json {'error': {'code': 'ProposalNotOpen', 'message': 'Proposal 50504fbedc683c5c59d0fd937f54b0f1e212ed3ff7ec730ec44689dd0ae42fc1 is currently in state accepted - only open proposals can receive votes.'}}\n",
      "Voting failed for user1 by member2\n",
      "Actual id e75d24dd34b593f0f6d4c717c205b88a59dbab34ebceafc071325eaabb818e8a\n"
     ]
    }
   ],
   "source": [
    "def main_process(num_initial_users):\n",
    "    # Generate keys and certificates for all users\n",
    "    for i in range(num_initial_users):\n",
    "        create_certificate(f\"user{i}\",\"user\")\n",
    "\n",
    "    # Submit proposal and voting for each user\n",
    "    for i in range(num_initial_users):\n",
    "        user_name = f\"user{i}\"\n",
    "        user_cert_path = f\"{user_name}_cert.pem\"\n",
    "        user_key_path = f\"{user_name}_privk.pem\"\n",
    "\n",
    "        # Member0 submits the proposal\n",
    "        status_code, response_json = send_secure_request(server + \"/gov/proposals\", f\"@set_{user_name}.json\", \"member1_privk.pem\", \"member1_cert.pem\", \"post\")\n",
    "        print(\"proposal_id\",json.loads(response_json)['proposal_id'])\n",
    "        proposal_id=json.loads(response_json)['proposal_id']\n",
    "\n",
    "        # Other members vote\n",
    "        for j in range(1, 3):  # Assuming 2 other members (member1 and member2)\n",
    "            vote_status, response_json = send_ballot_request(server, proposal_id, \"vote_accept.json\", f\"member{j}_privk.pem\", f\"member{j}_cert.pem\")\n",
    "            print(\"vote_status\",vote_status,\"response_json\",response_json)\n",
    "            if vote_status != 200:\n",
    "                print(f\"Voting failed for {user_name} by member{j}\")\n",
    "                continue\n",
    "            time.sleep(1)  # Delay for processing\n",
    "\n",
    "        # Create account for the user\n",
    "        user_id=get_certificate_fingerprint(user_cert_path)\n",
    "        print(\"Actual id\",user_id) \n",
    "   \n",
    "      \n",
    "       \n",
    "\n",
    "\n",
    "# Run the script for a specified number of users\n",
    "main_process(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}