From f24b8820b627b7f2f318d905c4b5d84c5a8ae2b9 Mon Sep 17 00:00:00 2001 From: "Morten V. Christiansen" Date: Tue, 3 Mar 2026 15:17:45 +0100 Subject: [PATCH] some old names left over in tests changed --- ...service_client_integration.cpython-313.pyc | Bin 2237 -> 4166 bytes tests/integration/test_zenroom_live.py | 77 ++++++++---------- ...test_zenroom_service_client_integration.py | 72 ++++++++++++++-- 3 files changed, 98 insertions(+), 51 deletions(-) diff --git a/tests/integration/__pycache__/test_zenroom_service_client_integration.cpython-313.pyc b/tests/integration/__pycache__/test_zenroom_service_client_integration.cpython-313.pyc index 552bde6abe99a6929dfa70f49a413961a3cdbd86..3b8520b5c235fde42d340b2f9d3ed2d1e23dde2e 100644 GIT binary patch literal 4166 zcmbUk-ER}geb%4rjqSvV4f!B24GF|a90MT~a(CPTi3$hgs5eFjL|Sd^iM_<$b!XRb z&ePpPdpY%?oGPTym*%Mg>7?Fc{|x&`6>CwYld4lipMr9I?{D@a>(FpIbsuJaGr#YT z`OWNJEG8iMe)#ualvWI(f3k)9g&bh-I{=;{5sBPQMD3ZQoVE5*AI!d+{*MDRfYEYb z1T6<=Ih!*Vbwzoz=nuj|3}m_xqTyv}=#vS)oZ4l{d#H@iNL z(kMp#XatF&K_rHkx!j<~?LxDD8=~19xPj{F+HL!v$F?Xq3Qi@;*_i zrd35kA1MWLt)dXsDA)q*k-5UYy@xP7Mazgq1tP*xzv!cZ<=|lvU|t;NHCXOneDjSNXzJ`RN_1`+?W5vVFVOm#pESF?O z)eS7;it>oy+=95o{LMOY@%5#pJ6N~9pB97#RbHtOywZR@!%)=HoPhEDg~i+_pWK$N zUJ)0heD2l=YT27%(JyYJ2UAmD{dJ~agP4tV=6^l7ofN-j6#?t63I@A@uwiBU0jDWHZy z*RV(7LLOy4EXKhm{&1anUhK9q8|~12sC7WuV^MZ>P;$8wu10U(w=p61p5eqk@Hq00 zY$x-P4rviF$uy|KJE&86p@aJH8ar};hRglJv&)6VL_Q)Wn5MiSrkweR<=fF|U*0eF zLtMMShQsQl%d3UbKzdNV3&-ZVV(6HBCKrrK0~=+c6MPX9wOG@jMd(;l3j`CnP{!km zij781fs^dE0bJ2adYT>lvuXS*q7rB|BqL|mNTVhzbSguMT!hw;QHszk6{C?^rCK#p zlnohp&UNtA>MIqcz!(8Blg0~bfi`Le$f^=umrEq`STV{OurE`Sb^WnMi$HijjpvC? z$S^-eI(wMRRgGqh#~PSfP-?87>zTUF?3MLKwMq;MCRyS&Xri?;v+aVX(zEUVkn_tl z7L}5k(N-Rk!q3oqF^%sMs;oBNWm`rEak5dTL=YA=gUsP24X+VW!-|0o4U!6ptLRhs zF~OA7A5Fg-e=NTxk%T!B?Pi$n^TrD;Vr-V5M3E0$DY{jRGZx znXEP-bPds3-EpcX?KeYZs7^x7uv0gtpqFJzip+wv&y3sbl7pq}8L~cfom46sW@X%Y zg<=CP;Pu`P7qKlo9WeXc5K4BDGx1C~3o(P4_p}#;Q+8y*u7rc@An)0i;V_sX+d7NK z3>f4y!;DlLx9!8SKFDf|6c3o__+fd*u=~o*uv3KVeftuo_p8a|sLAPRA3e@YWE~TH ziaElhRfSZF-tv)LsS`8eF(()Zsyts7(+SGnlBQ47%`j0PDO6L?AynAQp_F)t>1t*iwsT5^y>yS1$%pmf*C>BP-+lP_bf|J!FFyrwQF|Sj0?Z1 z%N4WNEAoAw&OMhY%Dj`D=$SoGesDmgeecszGoX{osu?O+uSE!qll2H+ z@N)Yc{dgSpp8AIVb^XP9bM96vd%Klb+z9Q4P-H|V%x)OPPwk>WT-fmK3Mihm@!#f} z^Y@#vv1aVShR;&b-{Si>d$;-1Agi~3Co$1VOtkStduVj)UTY}ZPM&S|o!*V0-pO4Q z>=nSd9@L%MiJxx8Pq&Ycw}(${HCn?!Gyp2Q$3bPcu;B-lk=PDz3Gdtd^x1H8{QYhI z15ab$=G|vQ%~RL5`FTh2Xe%+guQi36BbS@W4|jv8cWf8=EyX;@WI=2mnS6eCn?K)< zC!48>R(x{9&!WS^TiBf0=1&}4eb0h3+KP>~2glljcx$LNm}wt7vE_eu{rSvu{l&%B zk@MgQ_!tLOK`UZWriz8z_ji715Auy(z>igz$x9MzIfC@N7kK!+u%s1*R<>#Aa~(t@+IrquFk1)3cl1?gs}L=5O8^dq)NNfLAfLn%nI z0S#cK4m^@XuK|u;Wy6PT;N5|}z4Z$){0_bG1%mu;6oukD!T#@pkl8;E{Ar+ha`xrG zh33UyzYONy_~yCbu{}QuiQJwA+aj5?bhl*;y#X+s)&_L98vICBloiVUS(x{$isdov zQ});}BL%HUBt~ThtT6uf7J_B_&xp8Y)1M*c7P tFZeIJzvzC#eLeG}@yE;CXygZU`Nz;Ljyv{zd}rdl*2H`NL2P9O=ENME8OY_IVqv5?XzM%-9pMC6HAIMDUHF#d^55yP1ks) zXrqXYB3rq)*IH=O&5$?cE&h$~rO*2+z>3h{!FlmJn(VTBfF?+(eyU5?>1%2DewalZ zA&)IwS|h4U!n$r+S*O*!BbQuITtIzrpV+*@;0ZYNiqtQUUL5i& zT^~hRKPIC3COx$)PMw9Ywc%D9$rxX8|b0mGc!vI!W8rg9X(;Wf8GCBx4`8I%>>t|js7U|- diff --git a/tests/integration/test_zenroom_live.py b/tests/integration/test_zenroom_live.py index b045cca..b07762e 100644 --- a/tests/integration/test_zenroom_live.py +++ b/tests/integration/test_zenroom_live.py @@ -3,7 +3,7 @@ import unittest import sys from pathlib import Path -# Import from ca_core (same pattern as other tests) +# Import from ca_core code_path = Path(__file__).parent.parent.parent / "ca_core" sys.path.insert(0, str(code_path)) @@ -11,15 +11,10 @@ from crypto.zenroom_service_client import ZenroomServiceClient def _live_enabled() -> bool: - return os.environ.get("RUN_LIVE_ZENROOM", "").strip().lower() in { - "1", "true", "yes" - } + return os.environ.get("RUN_LIVE_ZENROOM", "").strip().lower() in {"1", "true", "yes"} -@unittest.skipUnless( - _live_enabled(), - "Set RUN_LIVE_ZENROOM=1 to run live Zenroom service smoke tests", -) +@unittest.skipUnless(_live_enabled(), "Set RUN_LIVE_ZENROOM=1 to run live Zenroom service smoke tests") class TestZenroomLiveServices(unittest.TestCase): @classmethod @@ -34,45 +29,43 @@ class TestZenroomLiveServices(unittest.TestCase): timeout_s=timeout_s, ) - def test_keypair_reading_identity_from_data(self): - """ - Tests: - POST /api/Generate-a-keypair,-reading-identity-from-data - Payload wrapped as {"data": {"myName": "..."}} - """ - res = self.client.generate_a_keypair_reading_identity_from_data( - "LiveUser123456" - ) + def test_end_to_end_8_calls(self): + sender_kp = self.client.generate_keypair("LiveUser123456") + sender_pub = self.client.generate_public_key(sender_kp["keyring"]) - self.assertIn("public_key", res) - self.assertIn("private_key", res) - self.assertIsInstance(res["public_key"], str) - self.assertIsInstance(res["private_key"], str) - self.assertTrue(res["public_key"]) - self.assertTrue(res["private_key"]) - - def test_encrypt_decrypt_password_roundtrip(self): - """ - Tests: - POST /api/Encrypt-a-message-with-the-password - POST /api/Decrypt-the-message-with-the-password - """ plaintext = "Dear Bob, your name is too short, goodbye - Alice." - - encrypted = self.client.encrypt_a_message_with_the_password( + sm = self.client.symmetric_encrypt( header="A very important secret", message=plaintext, - password="myVerySecretPassword", + shared_key="myVerySecretPassword", ) + pt = self.client.symmetric_decrypt(secret_message=sm, shared_key="myVerySecretPassword") + self.assertEqual(pt, plaintext) - for k in ("checksum", "header", "iv", "text"): - self.assertIn(k, encrypted) - self.assertIsInstance(encrypted[k], str) - self.assertTrue(encrypted[k]) - - decrypted = self.client.decrypt_the_message_with_the_password( - secret_message=encrypted, - password="myVerySecretPassword", + secret = self.client.asymmetric_encrypt( + receiver_public_key=sender_pub, + sender_keyring=sender_kp["keyring"], + message="Hello from live test", + header="Live header", ) + dec = self.client.asymmetric_decrypt( + sender_public_key=sender_pub, + receiver_keyring=sender_kp["keyring"], + secret=secret, + ) + self.assertEqual(dec["header"], "Live header") + self.assertEqual(dec["text"], "Hello from live test") - self.assertEqual(decrypted.get("textDecrypted"), plaintext) + signed = self.client.sign_objects( + signer_keyring=sender_kp["keyring"], + objects={"myMessage": "Signed live message"}, + ) + sig = signed["myMessage.signature"] + + ok = self.client.verify_signature( + message_field="myMessage", + message_value=signed["myMessage"], + signature={"r": sig["r"], "s": sig["s"]}, + signer_public_key=sender_pub, + ) + self.assertTrue(ok) diff --git a/tests/integration/test_zenroom_service_client_integration.py b/tests/integration/test_zenroom_service_client_integration.py index 90947ca..cf75970 100644 --- a/tests/integration/test_zenroom_service_client_integration.py +++ b/tests/integration/test_zenroom_service_client_integration.py @@ -3,6 +3,7 @@ import unittest import sys from pathlib import Path +# Import from ca_core code_path = Path(__file__).parents[2] / "ca_core" sys.path.insert(0, str(code_path)) @@ -10,21 +11,39 @@ from crypto.zenroom_service_client import ZenroomServiceClient class TestZenroomServiceClientIntegration(unittest.TestCase): + """Service integration: runs against a live RESTroom/Zenroom HTTP service. + + Enable by setting: + ZENROOM_BASE_URL=http://localhost:3300 + """ @unittest.skipUnless(os.getenv("ZENROOM_BASE_URL"), "No ZENROOM_BASE_URL set") - def test_end_to_end_smoke(self): + def test_end_to_end_smoke_8_calls(self): + """Hits exactly these 8 endpoints once each (in typical service logs): + 1) Generate-a-keypair,-reading-identity-from-data + 2) Generate-public-key + 3) Encrypt-a-message-with-the-password + 4) Decrypt-the-message-with-the-password + 5) Encrypt-a-message-for-two-recipients-using-asymmetric-cryptography + 6) Decrypt-a-message-for-two-recipients-using-asymmetric-cryptography + 7) Sign-objects-using-asymmetric-cryptography + 8) Verify-asymmetric-cryptography-signature + + Note: To keep it to 8 calls, we reuse the same identity as both sender and receiver + for the asymmetric encrypt/decrypt roundtrip. + """ client = ZenroomServiceClient(base_url=os.environ["ZENROOM_BASE_URL"]) - # 1) keypair -> public key - kp = client.generate_keypair("IntegrationUser123456") - self.assertIn("keyring", kp) - self.assertIn("private_key", kp) + # 1) keypair (private) -> 2) public key + sender_kp = client.generate_keypair("IntegrationUser123456") + self.assertIn("keyring", sender_kp) + self.assertIn("private_key", sender_kp) - pub = client.generate_public_key(kp["keyring"]) - self.assertIsInstance(pub, str) - self.assertTrue(pub.strip()) + sender_pub = client.generate_public_key(sender_kp["keyring"]) + self.assertIsInstance(sender_pub, str) + self.assertTrue(sender_pub.strip()) - # 2) symmetric roundtrip + # 3) symmetric encrypt -> 4) symmetric decrypt plaintext = "Dear Bob, your name is too short, goodbye - Alice." sm = client.symmetric_encrypt( header="A very important secret", @@ -33,3 +52,38 @@ class TestZenroomServiceClientIntegration(unittest.TestCase): ) pt = client.symmetric_decrypt(secret_message=sm, shared_key="myVerySecretPassword") self.assertEqual(pt, plaintext) + + # 5) asymmetric encrypt (receiver pub == sender pub to avoid extra keypair/public-key calls) + secret = client.asymmetric_encrypt( + receiver_public_key=sender_pub, + sender_keyring=sender_kp["keyring"], + message="Hello from integration test", + header="Integration header", + ) + + # 6) asymmetric decrypt (sender public key is sender_pub; receiver private key == sender private key) + dec = client.asymmetric_decrypt( + sender_public_key=sender_pub, + receiver_keyring=sender_kp["keyring"], + secret=secret, + ) + self.assertEqual(dec["header"], "Integration header") + self.assertEqual(dec["text"], "Hello from integration test") + + # 7) sign -> 8) verify + signed = client.sign_objects( + signer_keyring=sender_kp["keyring"], + objects={"myMessage": "Signed integration message"}, + ) + self.assertIn("myMessage.signature", signed) + sig = signed["myMessage.signature"] + self.assertIn("r", sig) + self.assertIn("s", sig) + + ok = client.verify_signature( + message_field="myMessage", + message_value=signed["myMessage"], + signature={"r": sig["r"], "s": sig["s"]}, + signer_public_key=sender_pub, + ) + self.assertTrue(ok)