abdm-encryption-test/test_python_custom_curve.py at main · ajeety4/abdm-encryption-test · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
# This is a test code for python custom curve util (to be developed) that should generate keys similar to Fidelius CLI
# based on custom curve 25519 as used here
# https://github.com/mgrmtech/fidelius-cli/blob/main/src/main/java/com/mgrm/fidelius/keypairgen/KeyPairGenController.java#L36
import base64

import unittest
from fildelius_encryption_util import getEcdhKeyMaterial, decryptData, encryptData
from python_custom_curve import PythonCustomCurve25519


class TestPythonCustomCurve25519(unittest.TestCase):

    def test_public_key(self):
        key_material = PythonCustomCurve25519.get_key_material()
        public_key = key_material['publicKey']
        public_key_bytes = base64.b64decode(public_key.encode())
        assert len(public_key_bytes) == 65
        assert public_key_bytes[0] == 4

    def test_encryption(self):
        """Test by encrypting using python and decryption using fidelius cli"""
        string_to_encrypt = "This should be kept secret at all cost"

        # Requester is peer who shared his public key (Fidelius CLI)
        requester_key_material = getEcdhKeyMaterial()

        # Encrypt using Python Util
        sender_key_material = PythonCustomCurve25519.get_key_material()
        encryption_params = {
            "string_to_encrypt": string_to_encrypt,
            "sender_nonce": sender_key_material["nonce"],
            "requester_nonce": requester_key_material["nonce"],
            "sender_private_key": sender_key_material["privateKey"],
            "requester_public_key": requester_key_material["publicKey"]
        }
        encrypted_data = PythonCustomCurve25519.encrypt_data(encryption_params)

        # Decrypt using Fidelius CLI
        decryption_params = {
            "encryptedData": encrypted_data,
            "requesterNonce": requester_key_material["nonce"],
            "senderNonce": sender_key_material["nonce"],
            "requesterPrivateKey": requester_key_material["privateKey"],
            "senderPublicKey": sender_key_material["publicKey"]
        }
        decrypted_data = decryptData(decryption_params)
        assert string_to_encrypt == decrypted_data['decryptedData']

    def test_decryption(self):
        """Test by encrypting using fidelius cli and decryption using Python Util """
        string_to_encrypt = "This should be kept secret at all cost"

        # Requester is peer who shared his public key (Fidelius CLI)
        requester_key_material = PythonCustomCurve25519.get_key_material()

        # Encrypt using Python Util
        sender_key_material = getEcdhKeyMaterial()
        encryption_params = {
            "stringToEncrypt": string_to_encrypt,
            "senderNonce": sender_key_material["nonce"],
            "requesterNonce": requester_key_material["nonce"],
            "senderPrivateKey": sender_key_material["privateKey"],
            "requesterPublicKey": requester_key_material["publicKey"]
        }
        encrypted_data = encryptData(encryption_params)

        # Decrypt using Fidelius CLI
        decryption_params = {
            "encrypted_data": encrypted_data['encryptedData'],
            "requester_nonce": requester_key_material["nonce"],
            "sender_nonce": sender_key_material["nonce"],
            "requester_private_key": requester_key_material["privateKey"],
            "sender_public_key": sender_key_material["publicKey"]
        }
        decrypted_data = PythonCustomCurve25519.decrypt_data(decryption_params)
        assert string_to_encrypt == decrypted_data

    def test_encryption_x509(self):
        """Test by encrypting using python and decryption using fidelius cli using x509 public key"""
        string_to_encrypt = "This should be kept secret at all cost"

        # Requester is peer who shared his public key (Fidelius CLI)
        requester_key_material = getEcdhKeyMaterial()

        # Encrypt using Python Util
        sender_key_material = PythonCustomCurve25519.get_key_material()
        encryption_params = {
            "string_to_encrypt": string_to_encrypt,
            "sender_nonce": sender_key_material["nonce"],
            "requester_nonce": requester_key_material["nonce"],
            "sender_private_key": sender_key_material["privateKey"],
            "requester_public_key": requester_key_material["x509PublicKey"]
        }
        encrypted_data = PythonCustomCurve25519.encrypt_data(encryption_params)

        # Decrypt using Fidelius CLI
        decryption_params = {
            "encryptedData": encrypted_data,
            "requesterNonce": requester_key_material["nonce"],
            "senderNonce": sender_key_material["nonce"],
            "requesterPrivateKey": requester_key_material["privateKey"],
            "senderPublicKey": sender_key_material["x509PublicKey"]
        }
        decrypted_data = decryptData(decryption_params)
        assert string_to_encrypt == decrypted_data

    def test_decryption_x509(self):
        """Test by encrypting using fidelius cli and decryption using Python Util using x509 public key"""
        string_to_encrypt = "This should be kept secret at all cost"

        # Requester is peer who shared his public key (Python util)
        requester_key_material = PythonCustomCurve25519.get_key_material()

        # Encrypt using Python Util
        sender_key_material = getEcdhKeyMaterial()

        # Expecting x509PublicKey in base64 format
        # requester_key_material["x509PublicKey"] = (base64.b64encode(requester_key_material["x509PublicKey"])).decode()

        encryption_params = {
            "stringToEncrypt": string_to_encrypt,
            "senderNonce": sender_key_material["nonce"],
            "requesterNonce": requester_key_material["nonce"],
            "senderPrivateKey": sender_key_material["privateKey"],
            "requesterPublicKey": requester_key_material["x509PublicKey"]
        }
        encrypted_data = encryptData(encryption_params)

        # Decrypt using Fidelius CLI
        decryption_params = {
            "encrypted_data": encrypted_data['encryptedData'],
            "requester_nonce": requester_key_material["nonce"],
            "sender_nonce": sender_key_material["nonce"],
            "requester_private_key": requester_key_material["privateKey"],
            "sender_public_key": sender_key_material["x509PublicKey"]
        }
        decrypted_data = PythonCustomCurve25519.decrypt_data(decryption_params)
        assert string_to_encrypt == decrypted_data


if __name__ == "__main__":
    unittest.main()