ee = EllipticCurve([0, 4*10^2+12*10-3, 0, 32*(10+3), 0])
print(ee)
print(ee.gens())
P = ee(-416,4160) 

def orig(P,N):
    x = P[0]
    y = P[1]
    a = (8*(N+3)-x+y)/(2*(N+3)*(4-x))
    b = (8*(N+3)-x-y)/(2*(N+3)*(4-x))
    c = (-4*(N+3)-(N+2)*x)/((N+3)*(4-x))
    da = denominator(a)
    db = denominator(b)
    dc = denominator(c)
    l = lcm(da,lcm(db,dc))
    return [a*l, b*l, c*l]

ans = []
for k in range(200):
    u = orig(k*P, 10) 
    (a,b,c) = (u[0],u[1],u[2])
    if a>0 and b>0 and c>0:
        print(k)
        print(a)
        print(b)
        print(c)
        print(a/(b+c)+b/(a+c)+c/(a+b))
        print()
        ans.append((a,b,c))
        
print(ans)

from pwn import * 
from tqdm import *
r = remote("10.102.32.141", 35785) 

for i in trange(1,416):
    with open(rf"collisions\coll\{bin(i)[2:].rjust(9,'0')}", "rb") as f:
        data = f.read()
        hex_data = data.hex()  # 转换成十六进制
        r.sendlineafter(b"Show me your magic:", hex_data.encode())

print(r.recvall()) 

if __name__ == '__main__':
    FLAG = b""
    database_size = 10 * 10
    database = np.random.randint(0, 256, [database_size], dtype=np.uint32)
    flag_array = np.frombuffer(FLAG, dtype=np.uint8)
    # Place flag at the beginning of database
    database[0:len(flag_array)] = flag_array
    pir_server = PIRServer(database)
    pir_client = PIRClient(pir_server.lwe_mat, pir_server.setup(), pir_server.get_scale_factor())

class Params:
    """
    We follow the original paper's implementation, where the secret dimension and the ciphertext modulus is fixed.
    The database size
    """
    secret_dimension = 10
    ciphertext_modulus = 2 ** 32

    @classmethod
    def get_plaintext_modulus(cls, database_size: int):
        return np.floor((cls.ciphertext_modulus / (2 ** 0.5 * 6.4 * database_size ** 0.25 * 40 ** 0.5)) ** 0.5).astype(int)

def get_scale_factor(self):
        return (2 ** 32) // self.plain_modulus

from pwn import * 
import numpy as np
from Crypto.Util.number import *
from tqdm import *
r = remote("10.102.32.141",30824)  
# r = remote("127.0.0.1",38009)
hint = r.recvuntil('s:',drop=True)
s = r.recvuntil('Delta:',drop=True)
delta = r.recvline()
hint = str(hint)[8:]
hint1 = []
for i in range(len(hint)):
    if hint[i] in ['1','2','3','4','5','6','7','8','9','0',' ','[',']']:
            hint1.append(hint[i])
hint = ''.join(hint1)
hint= re.sub(r'\s+', ',', hint.strip())
hint = hint.replace('],[', '],[')
hint = re.sub(r',+', ',', hint) 
hint = hint.replace('[,', '[').replace(',]', ']')
hint = np.array(eval(hint),dtype=np.uint32)
# print(hint)
s = s.decode()
s= re.sub(r'\s+', ',', s.strip())
s =re.sub(r' {1,3}', ',', s)
s = s.replace('[,', '[').replace(',]', ']')
s = np.array(eval(str(s.strip())),dtype=np.uint32)
# print(s)
delta = int(delta.strip().decode())
# print(delta)
def recover(answer: np.ndarray, index: int) -> int:
        row_id = index // 10
        col_id = index % 10
        hint_part = np.dot(hint[row_id], s)
        scaled_value = answer[row_id] - hint_part
        recovered_value = scaled_value // delta
        return recovered_value
database = np.zeros(100, dtype=np.uint8)
data =[]
for i in range(100):
    r.sendlineafter(b'please input index: ',f'{i}')
    ans = r.recvuntil('p',drop=False)
    ans = ans.decode()[5:]
    ans= re.sub(r'\s+', ',', ans.strip())
    ans =re.sub(r' {1,3}', ',', ans)
    ans = ans.replace('[,', '[').replace(',]', ']')
    # print(ans)
    ans = np.array(eval(str(ans.strip()[:-1])),dtype=np.uint64)
    ans = ans[0]
        # print(f'{ans=}')
        # print(ans)
    r.unrecv(b'p')
    database[i] = recover(ans,i)
print(database)
print(bytearray(database))
        # if(b'HASHCTF' in flag):
        #      print(bytes(flag))
        #      break

from typing import List, Collection
import socket
import numpy as np
np.seterr(over='ignore')
import threading
from params import Params
from discrete_gaussian import default_sampler


class PIRServer:
    def __init__(self, database: Collection[int]):
        self.plain_modulus = Params.get_plaintext_modulus(len(database))
        if np.max(database) >= self.plain_modulus or np.min(database) < 0:
            raise ValueError(f"Database elements shall not exceed the plaintext_modulus {self.plain_modulus} "
                             f"or be negative!")

        n_rows = n_cols = np.ceil(np.sqrt(len(database))).astype(int)
        self.data_matrix = np.zeros((n_rows, n_cols), dtype=np.uint32)
        index1d = np.arange(0, len(database))
        row_ind = index1d // n_cols
        col_ind = index1d % n_cols
        self.data_matrix[row_ind, col_ind] = database
        self.lwe_mat = np.random.randint(0, 2**32, [n_cols, Params.secret_dimension], dtype=np.uint32)

    def get_scale_factor(self):
        return (2 ** 32) // self.plain_modulus

    def setup(self):
        """
        Send the client hint to the client
        :return:
        """
        client_hint = self.data_matrix @ self.lwe_mat
        return client_hint

    def answer(self, query: np.ndarray):
        return self.data_matrix @ query
class PIRClient:
    def __init__(self, lwe_mat: np.ndarray, hint: np.ndarray, scale_factor: int):
        self.lwe_mat = lwe_mat
        self.hint = hint
        self.secret = np.random.randint(0, 2**32, [Params.secret_dimension], dtype=np.uint32)
        self.scale_factor = scale_factor
        self.n_rows = hint.shape[0]
        self.n_cols = lwe_mat.shape[0]

    def query(self, index: int):
        col_id = index % self.n_cols
        # print(self.n_rows)
        noise = default_sampler.sample_dgaussian(self.n_rows).astype(np.uint32)
        row_selection = np.zeros([self.n_rows], dtype=np.uint32)
        row_selection[col_id] = 1
        return self.lwe_mat @ self.secret + noise + self.scale_factor * row_selection
    def recover(self, answer: np.ndarray, index: int) -> int:
        """
        Recover the database value at the given index from the server's answer.
        
        Args:
            answer: The server's response to the query
            index: The index in the database we want to recover
            
        Returns:
            The recovered value at the specified index
        """
        row_id = index // self.n_cols
        col_id = index % self.n_cols
        
        # Compute the inner product between the hint and the secret
        hint_part = np.dot(self.hint[row_id], self.secret)
        
        # Subtract the hint part from the answer to get the scaled value
        scaled_value = answer[row_id] - hint_part
        
        # Divide by the scale factor to get the original value
        recovered_value = scaled_value // self.scale_factor
        
        return recovered_value
class PIRServerSocket:
    def __init__(self, host='localhost', port=38009):
        self.host = host
        self.port = port
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        
        # 初始化数据库
        FLAG = b"HASHCTF{fake_flag}"
        database_size = 10 * 10
        self.database = np.random.randint(0, 256, [database_size], dtype=np.uint32)
        flag_array = np.frombuffer(FLAG, dtype=np.uint8)
        self.database[0:len(flag_array)] = flag_array
        
        self.pir_server = PIRServer(self.database)
        self.pir_client = PIRClient(
            self.pir_server.lwe_mat, 
            self.pir_server.setup(), 
            self.pir_server.get_scale_factor()
        )

    def handle_client(self, client_socket):
        print(self.database)
        # print(self.pir_server.lwe_mat)
        try:
            # 发送初始参数
            client_socket.sendall(f"hint: {self.pir_client.hint}\n".encode())
            client_socket.sendall(f"s: {self.pir_client.secret}\n".encode())
            client_socket.sendall(f"Delta: {self.pir_client.scale_factor}\n".encode())
            while True:
                # 接收查询
                client_socket.sendall(f"please input index: ".encode())
                index= int(client_socket.recv(1024).decode())
                query = self.pir_client.query(index)
                answer = self.pir_server.answer(query)
                # print(f'{query=}')
                # print(f'{answer=}')
                # print(f'secret={self.pir_client.secret}')
                # print(f'hint={self.pir_client.hint}')
                # print((answer-self.pir_client.hint@self.pir_client.secret)//self.pir_client.scale_factor)
                response = f"ans: {answer}\n"
                recovered = self.pir_client.recover(answer, index)
                print("Recovered value:", recovered)
                client_socket.sendall(response.encode())
        finally:
            client_socket.close()

    def start(self):
        self.server_socket.bind((self.host, self.port))
        self.server_socket.listen(5)
        print(f"PIR Server listening on {self.host}:{self.port}")

        try:
            while True:
                client_sock, addr = self.server_socket.accept()
                print(f"Accepted connection from {addr}")
                client_handler = threading.Thread(
                    target=self.handle_client,
                    args=(client_sock,)
                )
                client_handler.start()
        except KeyboardInterrupt:
            print("Shutting down server...")
        finally:
            self.server_socket.close()

if __name__ == '__main__':
    server = PIRServerSocket()
    server.start()

p = 227805922452728292747730017012033415976587765247137601855939
x_Q, y_Q = (56007489270601603131820434248160278890260529944186739664579, 31171885484029271251993848216964314797846449339948904132147)

C = (y_Q^2-x_Q^3) 
M = matrix(ZZ, [
    [1, 0, x_Q],
    [0, 2^100, C],
    [0, 0, p]
])

L = M.BKZ(BlockSize=100,prune=30)
print(L)
[ 190316620525157915167256140799                               0 -293317973953547789538693588857]
[-554560224733382239414510645717                               0 -342289815355864698377873143530]
[-193928845675276018543768994937 1267650600228229401496703205376 -243383739183434077716210196120]

a =193928845675276018543768994937
b = 243383739183434077716210196120
p = 227805922452728292747730017012033415976587765247137601855939
x_Q, y_Q = (56007489270601603131820434248160278890260529944186739664579, 31171885484029271251993848216964314797846449339948904132147)
f = (y_Q^2 - x_Q^3 -a*x_Q -b)%p
a1 =list(primes(a-1000000, a+1000000))
print(len(a1))
b1 = list(primes(b-100000,b+100000))
print(len(b1))
for i in a1:
    for j in b1:
        f = (y_Q^2 - x_Q^3 -i*x_Q -j)%p
        if(f==0):
            print(i,j)