def getFileSignature(cls, filename: str,
private_key: RSAPrivateKey) -> Optional[str]:
"""Creates the signature for the (hash of the) provided file, given a private key.
:param filename: The file to be signed.
:param private_key: The private key used for signing.
:return: The signature if successful, 'None' otherwise.
"""
file_hash = cls.getFileHash(filename)
if file_hash is None:
return None
try:
file_hash_bytes = base64.b64decode(file_hash)
signature_bytes = private_key.sign(
file_hash_bytes,
padding.PSS(mgf=padding.MGF1(cls.__hash_algorithm),
salt_length=padding.PSS.MAX_LENGTH),
Prehashed(cls.__hash_algorithm))
return base64.b64encode(signature_bytes).decode("utf-8")
except: # Yes, we do really want this on _every_ exception that might occur.
Logger.logException(
"e", "Couldn't sign '{0}', no signature generated.".format(
filename))
return None
def getHashSignature(cls,
shash: str,
private_key: RSAPrivateKey,
err_info: Optional[str] = None) -> Optional[str]:
""" Creates the signature for the provided hash, given a private key.
:param shash: The provided string.
:param private_key: The private key used for signing.
:param err_info: Some optional extra info to be printed on error (for ex.: a filename the data came from).
:return: The signature if successful, 'None' otherwise.
"""
try:
hash_bytes = base64.b64decode(shash)
signature_bytes = private_key.sign(
hash_bytes,
padding.PSS(mgf=padding.MGF1(cls.__hash_algorithm),
salt_length=padding.PSS.MAX_LENGTH),
Prehashed(cls.__hash_algorithm))
return base64.b64encode(signature_bytes).decode("utf-8")
except: # Yes, we do really want this on _every_ exception that might occur.
if err_info is None:
err_info = "HASH:" + shash
Logger.logException(
"e", "Couldn't sign '{0}', no signature generated.".format(
err_info))
return None
def _DefaultBlobSign(
self,
blob_bytes: bytes,
private_key: rsa.RSAPrivateKey,
) -> bytes:
padding_algorithm = padding.PKCS1v15()
return private_key.sign(blob_bytes, padding_algorithm, hashes.SHA256())
def compute_signature(pkey: RSAPrivateKey, text: str) -> str:
signature = pkey.sign(
text.encode('utf-8'),
padding.PKCS1v15(),
SHA256(),
)
return b64encode(signature).decode('ascii')
def get_envelope(self, key: RSAPrivateKey):
json_message = self.to_json()
signature = base64.b64encode(
key.sign(json_message.encode("utf-8"), padding.PKCS1v15(), hashes.SHA256())
)
return PaymentRequestEnvelope(
message=json_message, signature=signature.decode("utf-8")
)
def sign(self, key: rsa.RSAPrivateKey, msg: bytes) -> bytes:
"""Sign the ``msg`` using ``key``."""
try:
return key.sign(msg, self.padding, self.hash)
except AttributeError as error:
logger.debug(error, exc_info=True)
raise errors.Error("Public key cannot be used for signing")
except ValueError as error: # digest too large
logger.debug(error, exc_info=True)
raise errors.Error(str(error))
def sign(private_key: RSAPrivateKey, data: bytes) -> bytes:
"""Sign one block of data which can be verified later by other using the public key.
Args:
private_key: The private key with which the data is signed.
data: The message data to sign.
Returns:
Signature
"""
return private_key.sign(data, padding.PKCS1v15(), hashes.SHA256())
def sellar(
message: Union[bytes, str],
private_key: rsa.RSAPrivateKey,
hash_algo: hashes.HashAlgorithm = hashes.SHA256()) -> str:
if isinstance(message, str):
message = message.encode('utf-8')
hashlib_algo = getattr(hashlib, hash_algo.name)
digest = hashlib_algo(message).digest()
signed = private_key.sign(
digest,
padding.PKCS1v15(),
utils.Prehashed(hash_algo)
)
return base64.b64encode(signed).decode('utf-8')
def getFileSignature(cls, filename: str,
private_key: RSAPrivateKey) -> Optional[str]:
file_hash = cls.getFileHash(filename)
if file_hash is None:
return None
try:
file_hash_bytes = base64.b64decode(file_hash)
signature_bytes = private_key.sign(
file_hash_bytes,
padding.PSS(mgf=padding.MGF1(cls.__hash_algorithm),
salt_length=padding.PSS.MAX_LENGTH),
Prehashed(cls.__hash_algorithm))
return base64.b64encode(signature_bytes).decode("utf-8")
except: # Yes, we do really want this on _every_ exception that might occur.
Logger.logException(
"e", "Couldn't sign '{0}', no signature generated.".format(
filename))
return None
def sign(data, skey: rsa.RSAPrivateKey):
"""Sign the given data `data` with the given private key `skey`.
Returns the signature."""
sig = skey.sign(data, padding.PKCS1v15(),
utils.Prehashed(hashes.MD5()))
return sig
def sign(private_key: RSAPrivateKey, data: bytes) -> bytes:
return private_key.sign(
data,
padding=padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=16),
algorithm=hashes.SHA256(),
)
def _sign_bytes(private_key: RSAPrivateKey, data: bytes) -> bytes:
return private_key.sign(
data,
padding.PSS(mgf=padding.MGF1(hashes.SHA256()),
salt_length=padding.PSS.MAX_LENGTH), hashes.SHA256())
def sign(data: bytes, key: RSAPrivateKey, hasher: HashAlgorithm) -> bytes:
return key.sign(data, padding.PKCS1v15(), hasher)
