PubNub SDK v5.1.0 release.

Author: client-engineering-bot

.pubnub.yml

@@ -1,8 +1,14 @@
 name: python
-version: 5.0.1
+version: 5.1.0
 schema: 1
 scm: github.com/pubnub/python
 changelog:
+  - version: v5.1.0
+    date: Mar 8, 2021
+    changes:
+      -
+        text: "BREAKING CHANGE: Add randomized initialization vector usage by default for data encryption / decryption in publish / subscribe / history API calls."
+        type: feature
   - version: v5.0.1
     date: Feb 4, 2021
     changes:

CHANGELOG.md

@@ -1,3 +1,9 @@
+## [v5.1.0](https://github.com/pubnub/python/releases/tag/v5.1.0)
+
+[Full Changelog](https://github.com/pubnub/python/compare/v5.0.1...v5.1.0)
+
+- 🌟️ BREAKING CHANGE: Add randomized initialization vector usage by default for data encryption / decryption in publish / subscribe / history API calls. 
+
 ## [v5.0.1](https://github.com/pubnub/python/releases/tag/v5.0.1)
 
 [Full Changelog](https://github.com/pubnub/python/compare/v5.0.0...v5.0.1)

pubnub/pnconfiguration.py

@@ -29,7 +29,7 @@ def __init__(self):
         self.reconnect_policy = PNReconnectionPolicy.NONE
         self.daemon = False
         self.disable_token_manager = False
-        self.use_random_initialization_vector = False
+        self.use_random_initialization_vector = True
         self.suppress_leave_events = False
 
         self.heartbeat_default_values = True

pubnub/pubnub_core.py

@@ -65,7 +65,7 @@
 
 class PubNubCore:
     """A base class for PubNub Python API implementations"""
-    SDK_VERSION = "5.0.1"
+    SDK_VERSION = "5.1.0"
     SDK_NAME = "PubNub-Python"
 
     TIMESTAMP_DIVIDER = 1000

setup.py

@@ -2,7 +2,7 @@
 
 setup(
     name='pubnub',
-    version='5.0.1',
+    version='5.1.0',
     description='PubNub Real-time push service in the cloud',
     author='PubNub',
     author_email='[email protected]',

tests/functional/test_publish.py

@@ -1,10 +1,8 @@
 import copy
 import unittest
 
-try:
-    from mock import MagicMock
-except ImportError:
-    from unittest.mock import MagicMock
+
+from unittest.mock import MagicMock
 
 from pubnub.endpoints.pubsub.publish import Publish
 from pubnub.pubnub import PubNub
@@ -139,6 +137,7 @@ def test_pub_with_auth(self):
 
     def test_pub_encrypted_list_message(self):
         conf = copy.copy(pnconf)
+        conf.use_random_initialization_vector = False
         conf.cipher_key = "testCipher"
 
         pubnub = MagicMock(

tests/helper.py

@@ -8,8 +8,8 @@
 from pubnub.crypto import PubNubCryptodome
 from pubnub.pnconfiguration import PNConfiguration
 
-
-crypto = PubNubCryptodome(PNConfiguration())
+crypto_configuration = PNConfiguration()
+crypto = PubNubCryptodome(crypto_configuration)
 
 DEFAULT_TEST_CIPHER_KEY = "testKey"
 
@@ -71,6 +71,13 @@
 mocked_config.publish_key = pub_key_mock
 mocked_config.subscribe_key = sub_key_mock
 
+hardcoded_iv_config = PNConfiguration()
+hardcoded_iv_config.use_random_initialization_vector = False
+
+
+def hardcoded_iv_config_copy():
+    return copy(hardcoded_iv_config)
+
 
 def mocked_config_copy():
     return copy(mocked_config)
@@ -131,14 +138,6 @@ def gen_string(length):
     return ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(length))
 
 
-def gen_decrypt_func(cipher_key=DEFAULT_TEST_CIPHER_KEY):
-    def decrypter(entry):
-        mr = crypto.decrypt(cipher_key, entry)
-        return mr
-
-    return decrypter
-
-
 class CountDownLatch(object):
     def __init__(self, count=1):
         self.count = count

tests/integrational/asyncio/test_file_upload.py

@@ -1,5 +1,6 @@
 import pytest
 
+from unittest.mock import patch
 from pubnub.pubnub_asyncio import PubNubAsyncio
 from tests.integrational.vcr_helper import pn_vcr
 from tests.helper import pnconf_file_copy
@@ -91,17 +92,18 @@ async def test_send_and_download_file(event_loop, file_for_upload):
 @pytest.mark.asyncio
 async def test_send_and_download_file_encrypted(event_loop, file_for_upload, file_upload_test_data):
     pubnub = PubNubAsyncio(pnconf_file_copy(), custom_event_loop=event_loop)
-    envelope = await send_file(pubnub, file_for_upload, cipher_key="test")
-    download_envelope = await pubnub.download_file().\
-        channel(CHANNEL).\
-        file_id(envelope.result.file_id).\
-        file_name(envelope.result.name).\
-        cipher_key("test").\
-        future()
-
-    assert isinstance(download_envelope.result, PNDownloadFileResult)
-    assert download_envelope.result.data == bytes(file_upload_test_data["FILE_CONTENT"], "utf-8")
-    pubnub.stop()
+    with patch("pubnub.crypto.PubNubCryptodome.get_initialization_vector", return_value="knightsofni12345"):
+        envelope = await send_file(pubnub, file_for_upload, cipher_key="test")
+        download_envelope = await pubnub.download_file().\
+            channel(CHANNEL).\
+            file_id(envelope.result.file_id).\
+            file_name(envelope.result.name).\
+            cipher_key("test").\
+            future()
+
+        assert isinstance(download_envelope.result, PNDownloadFileResult)
+        assert download_envelope.result.data == bytes(file_upload_test_data["FILE_CONTENT"], "utf-8")
+        pubnub.stop()
 
 
 @pn_vcr.use_cassette(

tests/integrational/asyncio/test_publish.py

@@ -4,6 +4,7 @@
 import pytest
 import pubnub as pn
 
+from unittest.mock import patch
 from pubnub.exceptions import PubNubException
 from pubnub.models.consumer.common import PNStatus
 from pubnub.models.consumer.pubsub import PNPublishResult
@@ -108,27 +109,29 @@ async def test_publish_object_via_post(event_loop):
     filter_query_parameters=['uuid', 'seqn', 'pnsdk'])
 @pytest.mark.asyncio
 async def test_publish_mixed_via_get_encrypted(event_loop):
-    pubnub = PubNubAsyncio(pnconf_enc_copy(), custom_event_loop=event_loop)
-    await asyncio.gather(
-        asyncio.ensure_future(assert_success_publish_get(pubnub, "hi")),
-        asyncio.ensure_future(assert_success_publish_get(pubnub, 5)),
-        asyncio.ensure_future(assert_success_publish_get(pubnub, True)),
-        asyncio.ensure_future(assert_success_publish_get(pubnub, ["hi", "hi2", "hi3"])))
+    with patch("pubnub.crypto.PubNubCryptodome.get_initialization_vector", return_value="knightsofni12345"):
+        pubnub = PubNubAsyncio(pnconf_enc_copy(), custom_event_loop=event_loop)
+        await asyncio.gather(
+            asyncio.ensure_future(assert_success_publish_get(pubnub, "hi")),
+            asyncio.ensure_future(assert_success_publish_get(pubnub, 5)),
+            asyncio.ensure_future(assert_success_publish_get(pubnub, True)),
+            asyncio.ensure_future(assert_success_publish_get(pubnub, ["hi", "hi2", "hi3"])))
 
-    pubnub.stop()
+        pubnub.stop()
 
 
 @pn_vcr.use_cassette(
     'tests/integrational/fixtures/asyncio/publish/object_via_get_encrypted.yaml',
     filter_query_parameters=['uuid', 'seqn', 'pnsdk'],
-    match_on=['host', 'method', 'query', 'object_in_path_with_decrypt']
+    match_on=['host', 'method', 'query']
 )
 @pytest.mark.asyncio
 async def test_publish_object_via_get_encrypted(event_loop):
-    pubnub = PubNubAsyncio(pnconf_enc_copy(), custom_event_loop=event_loop)
-    await asyncio.ensure_future(assert_success_publish_get(pubnub, {"name": "Alex", "online": True}))
+    with patch("pubnub.crypto.PubNubCryptodome.get_initialization_vector", return_value="knightsofni12345"):
+        pubnub = PubNubAsyncio(pnconf_enc_copy(), custom_event_loop=event_loop)
+        await asyncio.ensure_future(assert_success_publish_get(pubnub, {"name": "Alex", "online": True}))
 
-    pubnub.stop()
+        pubnub.stop()
 
 
 @pn_vcr.use_cassette(
@@ -138,28 +141,30 @@ async def test_publish_object_via_get_encrypted(event_loop):
 )
 @pytest.mark.asyncio
 async def test_publish_mixed_via_post_encrypted(event_loop):
-    pubnub = PubNubAsyncio(pnconf_enc_copy(), custom_event_loop=event_loop)
-    await asyncio.gather(
-        asyncio.ensure_future(assert_success_publish_post(pubnub, "hi")),
-        asyncio.ensure_future(assert_success_publish_post(pubnub, 5)),
-        asyncio.ensure_future(assert_success_publish_post(pubnub, True)),
-        asyncio.ensure_future(assert_success_publish_post(pubnub, ["hi", "hi2", "hi3"]))
-    )
+    with patch("pubnub.crypto.PubNubCryptodome.get_initialization_vector", return_value="knightsofni12345"):
+        pubnub = PubNubAsyncio(pnconf_enc_copy(), custom_event_loop=event_loop)
+        await asyncio.gather(
+            asyncio.ensure_future(assert_success_publish_post(pubnub, "hi")),
+            asyncio.ensure_future(assert_success_publish_post(pubnub, 5)),
+            asyncio.ensure_future(assert_success_publish_post(pubnub, True)),
+            asyncio.ensure_future(assert_success_publish_post(pubnub, ["hi", "hi2", "hi3"]))
+        )
 
-    pubnub.stop()
+        pubnub.stop()
 
 
 @pn_vcr.use_cassette(
     'tests/integrational/fixtures/asyncio/publish/object_via_post_encrypted.yaml',
     filter_query_parameters=['uuid', 'seqn', 'pnsdk'],
-    match_on=['method', 'path', 'query', 'object_in_body_with_decrypt']
+    match_on=['method', 'path', 'query']
 )
 @pytest.mark.asyncio
 async def test_publish_object_via_post_encrypted(event_loop):
-    pubnub = PubNubAsyncio(pnconf_enc_copy(), custom_event_loop=event_loop)
-    await asyncio.ensure_future(assert_success_publish_post(pubnub, {"name": "Alex", "online": True}))
+    with patch("pubnub.crypto.PubNubCryptodome.get_initialization_vector", return_value="knightsofni12345"):
+        pubnub = PubNubAsyncio(pnconf_enc_copy(), custom_event_loop=event_loop)
+        await asyncio.ensure_future(assert_success_publish_post(pubnub, {"name": "Alex", "online": True}))
 
-    pubnub.stop()
+        pubnub.stop()
 
 
 @pytest.mark.asyncio

tests/integrational/asyncio/test_subscribe.py

@@ -3,6 +3,7 @@
 import pytest
 import pubnub as pn
 
+from unittest.mock import patch
 from pubnub.models.consumer.pubsub import PNMessageResult
 from pubnub.pubnub_asyncio import PubNubAsyncio, AsyncioEnvelope, SubscribeListener
 from tests.helper import pnconf_sub_copy, pnconf_enc_sub_copy
@@ -95,46 +96,49 @@ async def test_subscribe_publish_unsubscribe(event_loop):
     pubnub_sub.stop()
 
 
-@pn_vcr.use_cassette('tests/integrational/fixtures/asyncio/subscription/sub_pub_unsub_enc.yaml',
-                     filter_query_parameters=['pnsdk'])
+@pn_vcr.use_cassette(
+    'tests/integrational/fixtures/asyncio/subscription/sub_pub_unsub_enc.yaml',
+    filter_query_parameters=['pnsdk']
+)
 @pytest.mark.asyncio
 async def test_encrypted_subscribe_publish_unsubscribe(event_loop):
     pubnub = PubNubAsyncio(pnconf_enc_sub_copy(), custom_event_loop=event_loop)
     pubnub.config.uuid = 'test-subscribe-asyncio-uuid'
 
-    callback = VCR599Listener(1)
-    channel = "test-subscribe-asyncio-ch"
-    message = "hey"
-    pubnub.add_listener(callback)
-    pubnub.subscribe().channels(channel).execute()
+    with patch("pubnub.crypto.PubNubCryptodome.get_initialization_vector", return_value="knightsofni12345"):
+        callback = VCR599Listener(1)
+        channel = "test-subscribe-asyncio-ch"
+        message = "hey"
+        pubnub.add_listener(callback)
+        pubnub.subscribe().channels(channel).execute()
 
-    await callback.wait_for_connect()
+        await callback.wait_for_connect()
 
-    publish_future = asyncio.ensure_future(pubnub.publish().channel(channel).message(message).future())
-    subscribe_message_future = asyncio.ensure_future(callback.wait_for_message_on(channel))
+        publish_future = asyncio.ensure_future(pubnub.publish().channel(channel).message(message).future())
+        subscribe_message_future = asyncio.ensure_future(callback.wait_for_message_on(channel))
 
-    await asyncio.wait([
-        publish_future,
-        subscribe_message_future
-    ])
+        await asyncio.wait([
+            publish_future,
+            subscribe_message_future
+        ])
 
-    publish_envelope = publish_future.result()
-    subscribe_envelope = subscribe_message_future.result()
+        publish_envelope = publish_future.result()
+        subscribe_envelope = subscribe_message_future.result()
 
-    assert isinstance(subscribe_envelope, PNMessageResult)
-    assert subscribe_envelope.channel == channel
-    assert subscribe_envelope.subscription is None
-    assert subscribe_envelope.message == message
-    assert subscribe_envelope.timetoken > 0
+        assert isinstance(subscribe_envelope, PNMessageResult)
+        assert subscribe_envelope.channel == channel
+        assert subscribe_envelope.subscription is None
+        assert subscribe_envelope.message == message
+        assert subscribe_envelope.timetoken > 0
 
-    assert isinstance(publish_envelope, AsyncioEnvelope)
-    assert publish_envelope.result.timetoken > 0
-    assert publish_envelope.status.original_response[0] == 1
+        assert isinstance(publish_envelope, AsyncioEnvelope)
+        assert publish_envelope.result.timetoken > 0
+        assert publish_envelope.status.original_response[0] == 1
 
-    pubnub.unsubscribe().channels(channel).execute()
-    await callback.wait_for_disconnect()
+        pubnub.unsubscribe().channels(channel).execute()
+        await callback.wait_for_disconnect()
 
-    pubnub.stop()
+        pubnub.stop()
 
 
 @pn_vcr.use_cassette('tests/integrational/fixtures/asyncio/subscription/join_leave.yaml',