How to use the rsa.sign function in rsa

To help you get started, we’ve selected a few rsa examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github google / python-adb / adb / View on Github external
def Sign(self, data):
        return rsa.sign(data, self.priv_key, 'SHA-1-PREHASHED')
github DingGuodong / LinuxBashShellScriptForOps / functions / string / encrypt / View on Github external
if __name__ == '__main__':
    private_key_file = "rsa_4096_private.pem"
    public_key_file = "rsa_4096_public.pem"

    pub_key, priv_key = load_keys()

    message = "hello"

    crypto = rsa.encrypt(message, pub_key)
    message_decrypted = rsa.decrypt(crypto, priv_key)
    print(message == message_decrypted)

    hash_method = 'SHA-512'
    signature = rsa.sign(message, priv_key, hash_method)

        rsa.verify(message, signature, pub_key)
    except rsa.pkcs1.VerificationError:
        print('Verification failed')
        print('Verification succeed')
github Chenwe-i-lin / KnowledgeFruits / src / handler / path / yggdrasil / common / View on Github external
def _sign_text(self, data, key_file=path_render(Config.ModulesConfig.yggdrasil.SignnatureKeys.Private)):
        key_file = open(key_file, 'r').read()
        key = rsa.PrivateKey.load_pkcs1(key_file.encode('utf-8'))
        return bytes(Base64(rsa.sign(data.encode("utf-8"), key, 'SHA-1'))).decode("utf-8")
github boto / boto / boto / cloudfront / View on Github external
if private_key_file and private_key_string:
            raise ValueError("Only specify the private_key_file or the private_key_string not both")
        if not private_key_file and not private_key_string:
            raise ValueError("You must specify one of private_key_file or private_key_string")
        # If private_key_file is a file name, open it and read it
        if private_key_string is None:
            if isinstance(private_key_file, six.string_types):
                with open(private_key_file, 'r') as file_handle:
                    private_key_string =
            # Otherwise, treat it like a file
                private_key_string =

        # Sign it!
        private_key = rsa.PrivateKey.load_pkcs1(private_key_string)
        signature = rsa.sign(str(message), private_key, 'SHA-1')
        return signature
github Abraxos / hermes / hermes-api / hermeslib / hermeslib / crypto / View on Github external
def asymmetric_sign(plaintext, sign_key):
    """ A function that takes in a plaintext and a private key and signs the
        plaintext with the key to generate an RSA signature and return it.

            plaintext (bytearray): The plaintext that is to be signed.
            sign_key (rsa.PrivateKey): The private key that is to be used to
                                       sign the plaintext.

            bytearray: A bytearray representing the RSA signature of the
                       plaintext generated with the given private key.
    return sign(plaintext, sign_key, 'SHA-512')
github rexbu / MeCloud / server / lib / View on Github external
def make_sign(message):
    :param message:
    private_key = rsa.PrivateKey._load_pkcs1_pem(alipay_config.RSA_PRIVATE)
    sign = rsa.sign(message, private_key, SIGN_TYPE)
    b64sing = base64.b64encode(sign)
    return b64sing
github Nomadblue / django-chile-payments / getpaid / backends / webpaypure / View on Github external
def encrypt(cls, message):
        public_key_data, private_key_data = cls.get_keys_raw()

        private_rsa_key = rsa.PrivateKey.load_pkcs1(private_key_data)
        signature = rsa.sign(message, private_rsa_key, 'SHA-512')
        iv, aes_key, encrypted_message = aes_cbc_encrypt(signature + message)
        public_key = RSA.importKey(public_key_data.strip())
        public_cipher =
        encrypted_key = public_cipher.encrypt(aes_key)

        return base64.b64encode(iv + encrypted_key + encrypted_message)
github davidblus / android_dynamic_detection / StaticAnalyzer / views / View on Github external
def _get_token():
    """Get the authentication token for windows vm xmlrpc client."""
    challenge = proxy.get_challenge()
    priv_key = rsa.PrivateKey.load_pkcs1(
    signature = rsa.sign(challenge, priv_key, 'SHA-512')
    sig_b64 = base64.b64encode(signature)
    return sig_b64
github gil9red / SimplePyScripts / pycryptodome__examples__AES_DES_RSA / RSA__examples / View on Github external
msg2 = "Hello Toni, I am Jarvis!".encode('utf-8')

public, private = rsa.new_keys(key_size=2048)
print('private:', private.exportKey('PEM'))
print('public:', public.exportKey('PEM'))

# Encrypt-Decrypt: private -> private
encrypted = b64encode(rsa.encrypt(msg1, private))
print("Encrypted:", encrypted)

decrypted = rsa.decrypt(b64decode(encrypted), private)
print("Decrypted:", decrypted)

signature = b64encode(rsa.sign(msg1, private))
print("Signature:", signature)

verify = rsa.verify(msg1, b64decode(signature), private)
print("Verify:", verify)  # True

verify = rsa.verify(msg2, b64decode(signature), private)
print("Verify:", verify)  # False
# Encrypt-Decrypt: private -> private


# Encrypt-Decrypt: public -> private
encrypted = b64encode(rsa.encrypt(msg1, public))
print("Encrypted:", encrypted)