code: def ciphertext(self, be_secure=True):
          
          if be_secure and not self.__is_obfuscated:
              self.obfuscate()
  
          return self.__ciphertext
docs: Return the ciphertext of the EncryptedNumber.
  
          Choosing a random number is slow. Therefore, methods like
          :meth:`__add__` and :meth:`__mul__` take a shortcut and do not
          follow Paillier encryption fully - every encrypted sum or
          product should be multiplied by r **
          :attr:`~PaillierPublicKey.n` for random r < n (i.e., the result
          is obfuscated). Not obfuscating provides a big speed up in,
          e.g., an encrypted dot product: each of the product terms need
          not be obfuscated, since only the final sum is shared with
          others - only this final sum needs to be obfuscated.
  
          Not obfuscating is OK for internal use, where you are happy for
          your own computer to know the scalars you've been adding and
          multiplying to the original ciphertext. But this is *not* OK if
          you're going to be sharing the new ciphertext with anyone else.
  
          So, by default, this method returns an obfuscated ciphertext -
          obfuscating it if necessary. If instead you set `be_secure=False`
          then the ciphertext will be returned, regardless of whether it
          has already been obfuscated. We thought that this approach,
          while a little awkward, yields a safe default while preserving
          the option for high performance.
  
          Args:
            be_secure (bool): If any untrusted parties will see the
              returned ciphertext, then this should be True.
  
          Returns:
            an int, the ciphertext. If `be_secure=False` then it might be
              possible for attackers to deduce numbers involved in
              calculating this ciphertext.