Inheriting from ConstBitStream to create a keystream

[sw]

I'm trying to create a keystream class that inherits from ConstBitStream. (Yes, I know, "don't roll your own crypto", this is purely for experiments...).

This is what I've come up with so far:

from abc import ABC, abstractmethod
from typing import cast, Optional, Union

from bitstring import Bits, ByteStore, ConstBitStream, ReadError
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes


class KeyStream(ABC, ConstBitStream):
    def __new__(cls, *_):
        return super().__new__(cls)

    @abstractmethod
    def append(self) -> bytes:
        pass

    def read(self, fmt: Union[int, str]) -> Union[int, float, str, Bits, bytes, None]:
        while True:
            try:
                return super().read(fmt)
            except ReadError:
                self._datastore.appendstore(ByteStore(bytearray(self.append())))

    def cipher(self, pt: Bits) -> Bits:
        """Apply the keystream to the given bitstring"""
        return cast(Bits, self.read(len(pt))) ^ pt


class KeyStreamAes256(KeyStream):
    def __init__(self, key: Optional[bytes] = None, nonce: Optional[bytes] = None):
        if key and nonce:
            self.enc = Cipher(algorithms.AES256(key), modes.CTR(nonce)).encryptor()
        super().__init__()

    def append(self) -> bytes:
        return self.enc.update(bytes(16))

You can then create an instance with KeyStreamAes256(key, iv) and either use the cipher method to implement a stream cipher, or consume bits from the key stream using read etc.

The problem is I've had to fiddle with __new__ and __init__ quite a bit to get this working, and the type checker (pylance) is still not happy.

Also, this depends on bitstring internals (_datastore) and is likely to break. In fact this likely doesn't work with the latest version, I'm using version 4.0.2.

So my question comes down to this: What is the proper way to create an endless ConstBitStream where I can supply the bit stream on demand?

[scott-griffiths]

Hi, thanks for the question. Without going into details, the big thing I notice is that you're using ConstBitStream as your base class. This, as the name suggests is supposed to be const, and not change its value after creation (the bit position can change but not the contents). That's why you're needing to modify the internals to change it.

The BitStream class on the other hand can change its value, and already has an append method you can use. I don't think you need to use it as a base class either, just have an instance as a member of your class to modify (that would be my preference at least).

Give BitStream a try and let me know if there are any other issues.

[sw]

Thanks for the explanation @scott-griffiths. My reasoning for using ConstBitStream is that the bitstream really should be constant from the point of view of the user of the class. That is, I don't want the instance of the KeyStream class to have the methods that modify the stream such as append, insert etc.

Once you have instantiated the class, the bit stream is constant (defined by key and IV), it just gets generated on-the-fly.

I'm aware that I can use BitStream and append to it as needed. I just thought it would be useful to have a constant (to the user) bit stream where you can specify how the stream is generated, by inheriting from ConstBitStream.

This doesn't have to be a cryptographic keystream, it could also be used to implement a LFSR, for example.

[sw]

Thinking some more about this, the inheritance chain Bits -> ConstBitStream -> Keystream is actually wrong for what I'm trying to do. After all, Bits has many methods that assume a finite sequence.

The correct way would probably be something like this:

class PossiblyInfiniteBitStream:
    # possibly unbounded, immutable sequence of bits
    # methods: copy cut split startswith unpack

class Bits(PossiblyInfiniteBitStream):
    # finite immutable sequence of bits
    # additional methods: all any count endswith find findall join pp rfind tobytes tofile

class ConstBitStream(Bits):
    # ...

PossiblyInfiniteBitStream could then be subclassed (or simply instantiated) to implement an LFSR, a keystream, an infinite stream of 1s, etc...

Of course this would likely be a large modification to the code base.