Merge pull request #123 from minvws/test-oprf

Added test endpoints for OPRF

Author: jaytaph

README.md

@@ -95,3 +95,124 @@ docker run -ti --rm -p 6502:6502 \
   --mount type=bind,source=./secrets,target=/src/secrets \
   gfmodules-prs
 ```
+
+
+
+# OPRF Testing
+
+This system uses OPRF for pseudonym generation. To test this, there are some available endpoints:
+
+- '/test/oprf/gen_rsa_key' - Generate a new RSA keypair for OPRF (small 1024 bit for testing)
+- '/test/oprf/oprf/client' - Emulates a client that generates OPRF information for a given input
+- '/test/oprf/oprf/receiver' - Emulates the receiver of the pseudonym and returns diagnostic information
+
+To use this system:
+
+1. First, generate a new keypair that will be used for a test organization with `/test/oprf/gen_rsa_key`.
+   ```shell
+    POST /test/oprf/gen_rsa_key 
+   
+    200 OK
+    {
+      "private_key_pem": "-----BEGIN PRIVATE KEY-----\nMIICdwIBA....neDKJ0DsvA5vfpt0=\n-----END PRIVATE KEY-----\n",
+      "public_key_pem": "-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqG....uDQIDAQAB\n-----END PUBLIC KEY-----\n",
+      "public_key_kid": "ajGAx_LKNrJ8vqdahWlSJvOznBi6lnFfSOw72Z4R4uU"
+    } 
+   ```
+ 
+2. Create a new organization into the key resolver with a POST to `/keys`. Add your organization name like 
+   `ura:12345678`, and you can use scope `test` for testing. Add the **PUBLIC key** to the `public_key` field.
+
+    ```shell
+    POST /keys
+    {
+      "organization": "ura:12345678",
+      "scope": "test",
+      "public_key": "-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqG....uDQIDAQAB\n-----END PUBLIC KEY\n",
+    }
+   
+    201 Created
+    ```
+
+3. Emulate a client wanting to send a pseudonym over to a receiver by calling `/test/oprf/client` with a JSON body like:
+
+   ```shell
+   POST /test/oprf/client
+   {
+     "personalId": "testinput-like-a-bsn-number-or-other-id"
+   }
+   
+   200 OK
+   {
+     "blinded_input": "EJU9qVhKNmw_UhCXDN_aVM4GL1DCmpDs8QD5WOdUBCU=",
+     "blind_factor": "eNf80WNHbImaUNU-kokBr7ocELBjMtHcy0re_RKBPQ8="
+   }
+   ```
+
+   This returns the `blinded_input` that must be sent to the receiver, and the `blind_factor` that must be send to the
+   receiver after the server has evaluated the blinded input.
+
+4. Now we can call the "real" OPRF function `/oprf/eval` with the blinded input, the organization name and scope:
+   
+      ```shell
+      POST /oprf/eval
+      {
+        "encryptedPersonalId": "EJU9qVhKNmw_UhCXDN_aVM4GL1DCmpDs8QD5WOdUBCU=",
+        "recipientOrganization": "ura:12345678",
+        "recipientScope": "test"
+      }
+
+      200 OK
+      {
+        "jwe": "eyJraWQiOi....bJUqbbSUIjqiw"
+      } 
+      ```
+   
+   At this point we will get back a JWE that contains the evaluated blinded input and
+   is encrypted with the public key of the organization. At this point, the client is 
+   not able to decrypt this information. It can only forward this to the receiver.
+
+5. Now emulate the receiver by calling `/test/oprf/receiver` with a JSON body like:
+   ```shell   
+    POST /test/oprf/receiver
+    {
+      "blind_factor": "eNf80WNHbImaUNU-kokBr7ocELBjMtHcy0re_RKBPQ8=",
+      "jwe": "eyJraWQiOiA...SzZbJUqbbSUIjqiw",
+      "priv_key_pem": "-----BEGIN RSA PRIVATE KEY-----\nMIICXAIB...oCfe0=\n-----END RSA PRIVATE KEY-----\n"
+    }
+   ```
+   
+    The blind factor is the one returned by the client, the JWE is the one returned by the prs evaluation, and 
+    the private key is returned by the key generation step.
+
+    At this point, it will return any diagnostic information about the OPRF process:
+
+    ```json
+    {
+      "jwe_data": "eyJraWQiOiAi...zZbJUqbbSUIjqiw",
+      "priv_key_pem": "-----BEGIN RSA PRIVATE KEY-----\nMIICXAIBAAKBgH6gmpXpdhtiE...UpWRvoCfe0=\n-----END RSA PRIVATE KEY-----\n",
+      "priv_key_kid": "rNv1O_mXgxF6QEMfaQGvjev7RbT1FG3sJXxxsu_KHbM",
+      "blind_factor": "eNf80WNHbImaUNU-kokBr7ocELBjMtHcy0re_RKBPQ8=",
+      "jwe": {
+        "headers": {
+          "kid": "rNv1O_mXgxF6QEMfaQGvjev7RbT1FG3sJXxxsu_KHbM",
+          "alg": "RSA-OAEP-256",
+          "enc": "A256GCM",
+          "cty": "application/json"
+        },
+        "decrypted": {
+          "subject": "pseudonym:eval:-Jpsoeik2058ip20b9Wd-vlwpjkjxRN4IoBrk8Ym2Bg=",
+          "aud": "ura:12345678",
+          "scope": "nvi",
+          "version": "1.1",
+          "iat": 1758616285,
+          "exp": 1758616585
+        }
+      },
+      "eval_subject": "-Jpsoeik2058ip20b9Wd-vlwpjkjxRN4IoBrk8Ym2Bg=",
+      "final_pseudonym": "fDZYIlajLAV3y8fWl1ObFBDmybUEGrR37pDb-5p5pJJGKvvpDvvMdQmYHKqtiQ8tdF4VL3w8nkbssHtOmkjiOg=="
+    }
+    ```
+
+    The `final_pseudonym` is the actual pseudonym that can be stored by the receiver. Note that this pseudonym is deterministic
+    for the same input, organization and scope. However, it is not possible to reverse this into a BSN.

app/application.py

@@ -10,6 +10,7 @@
 from app.routers.rid import router as rid_router
 from app.routers.bpg import router as bpg_router
 from app.routers.oprf import router as oprf_router
+from app.routers.test_oprf import router as test_oprf_router
 from app.routers.key import router as key_router
 from app.config import get_config
 
@@ -84,6 +85,7 @@ def setup_fastapi() -> FastAPI:
         rid_router,
         bpg_router,
         oprf_router,
+        test_oprf_router,
         key_router,
     ]
     for router in routers:

app/routers/oprf.py

@@ -21,6 +21,12 @@ def post_eval(
     if pub_key_jwk is None:
         return JSONResponse({"error": "No public key found for this organization"}, status_code=404)
 
-    jwe_str = oprf_service.eval_blind(req, pub_key_jwk)
+
+    try:
+        jwe_str = oprf_service.eval_blind(req, pub_key_jwk)
+    except ValueError as e:
+        logger.warning(f"Unable to evaluate blind: {e}")
+        return JSONResponse({"error": "Unable to evaluate blind"}, status_code=400)
+
     return JSONResponse({"jwe": jwe_str})
 

app/routers/test_oprf.py

@@ -0,0 +1,89 @@
+import json
+import logging
+
+from fastapi import APIRouter, Depends
+from jwcrypto import jwe, jwk
+from pydantic import BaseModel
+from starlette.responses import JSONResponse
+
+from app import container
+from app.services.oprf.oprf_service import OprfService
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+class InputRequest(BaseModel):
+    personalId: str
+
+class ReceiverRequest(BaseModel):
+    blind_factor: str
+    jwe: str
+    priv_key_pem: str
+
+@router.post("/test/oprf/gen_rsa_key", summary="Create a RSA (1024bit) key for test usage.", tags=["test-oprf"])
+def post_gen_rsa_key() -> JSONResponse:
+    key = jwk.JWK.generate(kty='RSA', size=1024)
+    priv_pem = key.export_to_pem(private_key=True, password=None).decode('ascii')
+    pub_pem = key.export_to_pem(private_key=False, password=None).decode('ascii')
+
+    return JSONResponse({
+        "private_key_pem": priv_pem,
+        "public_key_pem": pub_pem,
+        "public_key_kid": key.thumbprint().rstrip("="),
+    })
+
+
+@router.post("/test/oprf/client", summary="Create a blinded input and factor for a given BSN (or any other input)", tags=["test-oprf"])
+def post_eval(
+    req: InputRequest,
+    oprf_service: OprfService = Depends(container.get_oprf_service),
+) -> JSONResponse:
+
+    res = oprf_service.blind_input(req.personalId)
+    return JSONResponse({
+        "blinded_input": res['blinded_input'],
+        "blind_factor": res['blind_factor'],
+    })
+
+@router.post("/test/oprf/receiver", summary="Test receiver decryption of JWE with blind factor", tags=["test-oprf"])
+def post_receiver(
+    req: ReceiverRequest,
+    oprf_service: OprfService = Depends(container.get_oprf_service),
+) -> JSONResponse:
+
+    token = jwe.JWE()
+    token.deserialize(req.jwe)
+    headers = token.jose_header
+
+    priv_key_kid = "unknown"
+    plain_data = "unknown"
+    subject = "unknown"
+    pseudonym = "unknown"
+    try:
+        priv_key = jwk.JWK.from_pem(req.priv_key_pem.encode('ascii'))
+        priv_key_kid = priv_key.thumbprint().rstrip("=")
+        token.decrypt(priv_key)
+        plaintext = token.payload.decode('utf-8')
+        plain_data = json.loads(plaintext)
+        subject = plain_data.get("subject", "").split(":")[-1]
+        pseudonym = oprf_service.finalize(req.blind_factor, subject)
+    except Exception as e:
+        plain_data = "Could not decrypt JWE: " + str(e)
+
+
+    res = {
+        'jwe_data': req.jwe,
+        'priv_key_pem': req.priv_key_pem,
+        'priv_key_kid': priv_key_kid,
+        'blind_factor': req.blind_factor,
+        'jwe': {
+            'headers': headers,
+            'decrypted': plain_data,
+        },
+        'eval_subject': subject,
+        'final_pseudonym': pseudonym,
+    }
+
+    return JSONResponse(res)
+
+

app/services/oprf/jwe_token.py

@@ -1,3 +1,4 @@
+
 from jwcrypto import jwe, jwk
 import json
 import time

app/services/oprf/oprf_service.py

@@ -37,8 +37,11 @@ def eval_blind(self, req: BlindRequest, pub_key: jwk.JWK) -> str:
         """
         Evaluate a blind and returns a JWE encrypted on the pubkey
         """
-        bi = base64.urlsafe_b64decode(req.encryptedPersonalId)
-        eval = pyoprf.evaluate(self.__server_key, bi)
+        try:
+            bi = base64.urlsafe_b64decode(req.encryptedPersonalId)
+            eval = pyoprf.evaluate(self.__server_key, bi)
+        except Exception as e:
+            raise ValueError(f"unable to evaluate blind: {e}")
 
         subject = "pseudonym:eval:" + base64.urlsafe_b64encode(eval).decode('utf-8')
         jwe = BlindJwe.build(
@@ -49,3 +52,25 @@ def eval_blind(self, req: BlindRequest, pub_key: jwk.JWK) -> str:
         )
 
         return jwe
+
+    @staticmethod
+    def blind_input(input: str) -> dict[str, str]:
+        """
+        Blind an input and returns the blind factor and the blinded input
+        """
+        blind_factor, blinded_input = pyoprf.blind(input.encode('utf-8'))
+        return {
+            'blind_factor': base64.urlsafe_b64encode(blind_factor).decode('ascii'),
+            'blinded_input': base64.urlsafe_b64encode(blinded_input).decode('ascii'),
+        }
+
+
+    @staticmethod
+    def finalize(blind_factor: str, eval: str) -> str:
+        """
+        Finalize the OPRF by unblinding the evaluated input with the blind factor
+        """
+        bf = base64.urlsafe_b64decode(blind_factor)
+        ev = base64.urlsafe_b64decode(eval)
+        final = pyoprf.finalize(bf, ev)
+        return base64.urlsafe_b64encode(final).decode('ascii')

docker-compose.yaml

@@ -34,6 +34,19 @@ services:
     ports:
       - 6379:6379
 
+  postgres:
+    image: postgres:15
+    environment:
+      POSTGRES_USER: ${POSTGRES_USER:-postgres}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-postgres}
+      POSTGRES_DB: ${POSTGRES_DB:-postgres}
+    ports:
+      - 5432:5432
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+
 volumes:
   secrets:
     name: secrets
+  pgdata:
+    name: pgdata