Esempio n. 1
0
 def _generate_new_key(self):
     if self._using_m2crypto:
         self._private_key = M2RSA.gen_key(2048, 65537, lambda x,y,z: None)
         self._public_key = M2RSA.RSA_pub(self._private_key.rsa)
     else:
         try:
             (self._public_key, self._private_key) = PYRSA.newkeys(2048, poolsize=4)
         except:
             (self._public_key, self._private_key) = PYRSA.newkeys(2048)
Esempio n. 2
0
def reset_keys():
    try:
        (public_key, private_key) = rsa.newkeys(2048, poolsize=4)
    except:
        (public_key, private_key) = rsa.newkeys(2048)
    Settings.set("private_key", private_key.save_pkcs1())
    Settings.set("public_key", serialize_public_key(public_key))
    keys["private"] = private_key
    keys["public"] = public_key
Esempio n. 3
0
def run_speed_test(bitsize):
    iterations = 0
    start = end = time.time()

    # At least a number of iterations, and at least 2 seconds
    while iterations < 10 or end - start < 2:
        iterations += 1
        rsa.newkeys(bitsize, accurate=accurate, poolsize=poolsize)
        end = time.time()

    duration = end - start
    dur_per_call = duration / iterations

    print('%5i bit: %9.3f sec. (%i iterations over %.1f seconds)' %
          (bitsize, dur_per_call, iterations, duration))
Esempio n. 4
0
    def test_sign(self):
        """Test sign works."""
        # rsa_pk = M2Crypto.RSA.gen_key(2048, 65537)
        rsa_keys = rsa.newkeys(2048, 65537)
        rsa_pk = rsa_keys[1]
        rsa_pub = rsa_keys[0]
        salt = 'salt'
        data = {"flags": 8,
                "name": "MyAwesomeVM",
                "ram": 512,
                "secret": "mg041na39123",
                "userData": "[amiconfig]\nplugins=cernvm\n[cernvm]\nusers=user:users;password",
                "vcpus": 1,
                "version": "1.5"}
        strBuffer = vmcp.calculate_buffer(data, salt)
        
        with patch('rsa.PrivateKey.load_pkcs1', return_value=rsa_pk):
            with patch('pybossa.vmcp.open', mock_open(read_data=''), create=True) as m:
                out = vmcp.sign(data, salt, 'testkey')
                err_msg = "There should be a key named signature"
                assert out.get('signature'), err_msg

                err_msg = "The signature should not be empty"
                assert out['signature'] is not None, err_msg
                assert out['signature'] != '', err_msg

                err_msg = "The signature should be the same"
                signature = base64.b64decode(out['signature'])
                assert rsa.verify(strBuffer, signature, rsa_pub) == 1, err_msg

                # The output must be convertible into json object
                import json
                assert_not_raises(Exception, json.dumps, out)
def main():
	(pubkey, privkey) = rsa.newkeys(512)
	test = "goob"
	signature = rsa.sign(test, privkey, 'SHA-1')
	msg = ("I, Cecil Lam, signed this sentence!")
	publicKey = pubkey
	return msg, signature, publicKey;
def main():
    message = "I, Raymund Alksninis, signed this sentence!"
    message_enc = message.encode('utf-8')
    (publicKey, privateKey) = rsa.newkeys(1024)
    signature = rsa.sign(message_enc, privateKey, 'SHA-256')

    return(message, signature, publicKey)
Esempio n. 7
0
 def check_rsa_keys(self):
     '''
     If rsa keys pair doesnt exists, creates them
     '''
     
     
     path = self.config.get('General', 'rsa') or './.rsa'
     if not os.path.exists(path):
         os.makedirs(path)
     
     my_id = self.config.get('General', 'id')
     priv = os.path.join(path, '%s.priv' % my_id)
     pub = os.path.join(path, '%s.pub' % my_id)
     
     if not os.path.exists(priv) or not os.path.exists(pub):
         
         # generate new keys
         (pubkey, privkey) = rsa.newkeys(512)
         
         # save keys
         pem = privkey.save_pkcs1('PEM')
         open(priv, 'w').write(pem)
 
         pem = pubkey.save_pkcs1('PEM')
         open(pub, 'w').write(pem)
         
         log.info("keys pair generated !!")
     else:
         print "RSA ok"
         
     # any way, fix permitions
     os.system("chmod -R 600 %s/*" % path)
     return True
Esempio n. 8
0
def keygen():
    """Key generator."""

    # Parse the CLI options
    parser = OptionParser(
        usage="usage: %prog [options] keysize", description='Generates a new RSA keypair of "keysize" bits.'
    )

    parser.add_option(
        "--pubout",
        type="string",
        help="Output filename for the public key. The public key is "
        "not saved if this option is not present. You can use "
        "pyrsa-priv2pub to create the public key file later.",
    )

    parser.add_option(
        "-o",
        "--out",
        type="string",
        help="Output filename for the private key. The key is " "written to stdout if this option is not present.",
    )

    parser.add_option(
        "--form", help="key format of the private and public keys - default PEM", choices=("PEM", "DER"), default="PEM"
    )

    (cli, cli_args) = parser.parse_args(sys.argv[1:])

    if len(cli_args) != 1:
        parser.print_help()
        raise SystemExit(1)

    try:
        keysize = int(cli_args[0])
    except ValueError:
        parser.print_help()
        print("Not a valid number: %s" % cli_args[0], file=sys.stderr)
        raise SystemExit(1)

    print("Generating %i-bit key" % keysize, file=sys.stderr)
    (pub_key, priv_key) = rsa.newkeys(keysize)

    # Save public key
    if cli.pubout:
        print("Writing public key to %s" % cli.pubout, file=sys.stderr)
        data = pub_key.save_pkcs1(format=cli.form)
        with open(cli.pubout, "wb") as outfile:
            outfile.write(data)

    # Save private key
    data = priv_key.save_pkcs1(format=cli.form)

    if cli.out:
        print("Writing private key to %s" % cli.out, file=sys.stderr)
        with open(cli.out, "wb") as outfile:
            outfile.write(data)
    else:
        print("Writing private key to stdout", file=sys.stderr)
        sys.stdout.write(data)
def main():

    (my_pubkey, my_privkey) = rsa.newkeys(1024)
    message = 'I, Bryan Ngo, signed this message'.encode('utf-8')
    sign = rsa.sign(message, my_privkey, "SHA-256")
    rsa.verify(message, sign, my_pubkey)
    return message, sign, my_pubkey
Esempio n. 10
0
def main():
    # Do we have our OWN Keys?
    if not (os.path.isfile('./privkey.pem') and os.path.isfile('./pubkey.pem')):
        (pubkey, privkey) = rsa.newkeys(512)
        with open("privkey.pem", 'w') as keyfile:
            keyfile.write(privkey.save_pkcs1())
        with open("pubkey.pem", 'w') as keyfile:
            keyfile.write(pubkey.save_pkcs1())
    else:
        with open("privkey.pem") as keyfile:
            keydata = keyfile.read()
            privkey = rsa.PrivateKey.load_pkcs1(keydata)
        with open("pubkey.pem") as keyfile:
            keydata = keyfile.read()
            pubkey = rsa.PublicKey.load_pkcs1(keydata)

    # After this, we can use pubkey and privkey as our keypair for encryption

    # Connect to stomp and fetch messages
    conn = stomp.StompConnection10()
    conn.set_listener('', MixListener(privkey))
    conn.start()
    conn.connect()
    conn.subscribe(destination=QUEUE, id=1, ack='auto')

    # Yes we do this :-)
    while (True):
        time.sleep(10)
Esempio n. 11
0
def keygen():
    parser = OptionParser(usage='usage: %prog [options] keysize', description='Generates a new RSA keypair of "keysize" bits.')
    parser.add_option('--pubout', type='string', help='Output filename for the public key. The public key is not saved if this option is not present. You can use pyrsa-priv2pub to create the public key file later.')
    parser.add_option('-o', '--out', type='string', help='Output filename for the private key. The key is written to stdout if this option is not present.')
    parser.add_option('--form', help='key format of the private and public keys - default PEM', choices=('PEM', 'DER'), default='PEM')
    cli, cli_args = parser.parse_args(sys.argv[1:])
    if len(cli_args) != 1:
        parser.print_help()
        raise SystemExit(1)
    try:
        keysize = int(cli_args[0])
    except ValueError:
        parser.print_help()
        print('Not a valid number: %s' % cli_args[0], file=sys.stderr)
        raise SystemExit(1)

    print('Generating %i-bit key' % keysize, file=sys.stderr)
    pub_key, priv_key = rsa.newkeys(keysize)
    if cli.pubout:
        print('Writing public key to %s' % cli.pubout, file=sys.stderr)
        data = pub_key.save_pkcs1(format=cli.form)
        with open(cli.pubout, 'wb') as outfile:
            outfile.write(data)
    data = priv_key.save_pkcs1(format=cli.form)
    if cli.out:
        print('Writing private key to %s' % cli.out, file=sys.stderr)
        with open(cli.out, 'wb') as outfile:
            outfile.write(data)
    else:
        print('Writing private key to stdout', file=sys.stderr)
        sys.stdout.write(data)
Esempio n. 12
0
def rsa_demo():
    (pubkey,privkey)=rsa.newkeys(1024)
    print('pubkey >>>> {}'.format(pubkey))
    print('privkey >>>> {}'.format(privkey))
    with open('pub.pem','w') as f:
        f.write(pubkey.save_pkcs1().decode())

    with open('priva.pem','w') as f:
        f.write(privkey.save_pkcs1().decode())

    message = 'Kill bill tonight'
    print("message encode {}".format(message.encode()))
    crypto=rsa.encrypt(message.encode(),pubkey)

    print('密文{}'.format(crypto))

    # 解密
    e_message = rsa.decrypt(crypto,privkey)
    print("解密后{}".format(e_message.decode()))

    private_sign = rsa.sign(message.encode(),privkey,'SHA-1')
    print('签名:{}'.format(private_sign))

    print('验证签名')
    print(rsa.verify(message.encode(),private_sign,pubkey))
Esempio n. 13
0
def get_keypair():
    """
    Returns a (private, public) key pair as two strings encoded as pkcs1.
    """
    public, private = rsa.newkeys(1024)
    return (private.save_pkcs1().decode('ascii'),
            public.save_pkcs1().decode('ascii'))
def main():

    (publicKey, privateKey) = rsa.newkeys(1024)
    msg = ('I, Ran, signed this sentence!').encode('utf-8')
    signature = rsa.sign(msg, privateKey, 'SHA-256')

    return [msg, signature, publicKey]
Esempio n. 15
0
def keys(this):
    public_name = 'public.txt'
    private_name = 'private.txt'
    try:
        with open(public_name,'r') as f:
            pubkey = rsa.PublicKey.load_pkcs1(f.read())
        with open(private_name,'r') as f:
            privkey = rsa.PrivateKey.load_pkcs1(f.read())
    except:
        print 'generic keys...'
        pubkey, privkey = rsa.newkeys(2048, poolsize=2) #2 core
        with open(public_name,'w') as f:
            f.write(pubkey.save_pkcs1())
        with open(private_name,'w') as f:
            f.write(privkey.save_pkcs1())
    this.pubkey = pubkey
    this.privkey = privkey
    # поток выполнил полезную работу, теперь страдаем фигнёй
    # test 1
    text1 =''.join(random.choice(string.ascii_uppercase +\
    string.ascii_lowercase + string.digits) for x in range(16))
    text2 = rsa.encrypt(text1, this.static_public_key)
    text3 = rsa.decrypt(text2, this.static_private_key)
    if text1 != text3:
        print 'FATAL ERROR: fail test 1'
    # test 2
    text1 =''.join(random.choice(string.ascii_uppercase +\
    string.ascii_lowercase + string.digits) for x in range(16))
    text2 = rsa.encrypt(text1, pubkey)
    text3 = rsa.decrypt(text2, privkey)
    if text1 != text3:
        print 'ERROR: fail test 2'    
def main():
    import rsa
    message = "I, Matthew Kyawmyint, signed this sentence!".encode('utf-8')

    (matt_pub, matt_priv) = rsa.newkeys(1024)
    signature = rsa.sign(message, matt_priv, 'SHA-256')
    return message, signature, matt_priv
Esempio n. 17
0
    def test_encrypt_decrypt_bigfile(self):
        # Expected block size + 11 bytes padding
        pub_key, priv_key = rsa.newkeys((6 + 11) * 8)

        # Encrypt the file
        message = b('123456Sybren')
        infile = BytesIO(message)
        outfile = BytesIO()

        bigfile.encrypt_bigfile(infile, outfile, pub_key)

        # Test
        crypto = outfile.getvalue()

        cryptfile = BytesIO(crypto)
        clearfile = BytesIO()

        bigfile.decrypt_bigfile(cryptfile, clearfile, priv_key)
        self.assertEquals(clearfile.getvalue(), message)

        # We have 2x6 bytes in the message, so that should result in two
        # bigfile.
        cryptfile.seek(0)
        varblocks = list(varblock.yield_varblocks(cryptfile))
        self.assertEqual(2, len(varblocks))
Esempio n. 18
0
    def rsa_key(self):
	self.pub, self.pri = newkeys(512)
	self.rsa_pub.setText(unicode(self.pri.e))
	self.rsa_pri.setText(unicode(self.pri.d))
	self.rsa_n.setText(unicode(self.pri.n))
	self.rsa_p.setText(unicode(self.pri.p))
	self.rsa_q.setText(unicode(self.pri.q))
Esempio n. 19
0
def main():
    (pubkey, privkey) = rsa.newkeys(2048)
    with open('public.pem', 'wb') as fd:
        fd.write(pubkey.save_pkcs1('PEM'))
    with open('private.pem', 'wb') as fd:
        fd.write(privkey.save_pkcs1('PEM'))
    print('Success!')
Esempio n. 20
0
def main():
    (publicKey, privateKey) = rsa.newkeys(1024)

    pub = publicKey.save_pkcs1()
    pubfile = open("public.pem", "w+")
    pubfile.write(pub)
    pubfile.close()

    pri = privateKey.save_pkcs1()
    prifile = open("private.pem", "w+")
    prifile.write(pri)
    prifile.close()

    prifile = open("private.pem", "r")
    p = prifile.read()
    privateKey = rsa.PrivateKey.load_pkcs1(p)
    prifile.close()

    pubfile = open("public.pem", "r")
    p = pubfile.read()
    publicKey = rsa.PublicKey.load_pkcs1(p)
    pubfile.close()

    message = "lalalalal"

    secret = rsa.encrypt(message, publicKey)
    non_secret = rsa.decrypt(secret, privateKey)
    print non_secret

    signature = rsa.sign(message, privateKey, "SHA-1")
    rsa.verify("lalalalal", signature, publicKey)
Esempio n. 21
0
def keys(this):
    name = 'keys.txt'
    #TODO зашифровать файл
    try:
        with open(name,'r') as f:
            data = f.read()
        pubkey = rsa.PublicKey.load_pkcs1(data)
        privkey = rsa.PrivateKey.load_pkcs1(data)
    except:
        print 'generic keys...'
        pubkey, privkey = rsa.newkeys(2048, poolsize=2) #2 core
        with open(name,'w') as f:
            f.write(pubkey.save_pkcs1())
            f.write(privkey.save_pkcs1())
    this.pubkey = pubkey
    this.privkey = privkey
    # поток выполнил полезную работу, теперь страдаем фигнёй
    # TODO chmod +r name
    # test 1
    text1 =''.join(random.choice(string.ascii_uppercase +\
    string.ascii_lowercase + string.digits) for x in range(16))
    text2 = rsa.encrypt(text1, this.static_public_key)
    text3 = rsa.decrypt(text2, this.static_private_key)
    if text1 != text3:
        printf ('FATAL ERROR: fail test 1','red')
    # test 2
    text1 =''.join(random.choice(string.ascii_uppercase +\
    string.ascii_lowercase + string.digits) for x in range(16))
    text2 = rsa.encrypt(text1, pubkey)
    text3 = rsa.decrypt(text2, privkey)
    if text1 != text3:
        printf ('ERROR: fail test 2','red')  
Esempio n. 22
0
def get_keypair():
    """
    Returns a (private, public) key pair as two strings.
    """
    (pub, priv) = rsa.newkeys(512)
    return (priv.save_pkcs1().decode('ascii'),
            pub.save_pkcs1().decode('ascii'))
Esempio n. 23
0
    def __init__(self, networking, request_processor, database_engine, nick_name):
        super().__init__(networking, request_processor, 'auth_database')

        #self.users_database = UsersTable()

        self.database_engine = database_engine
        #self.database_engine.add_table(self.users_database)

        self.register_callbacks_for_requests()
        self.random_msg = []
        self.my_name = nick_name
        self.users_list = []
        if self.my_name is None:
            self.my_name = "Alex"
        # print("Auth_module: Nick name: " + self.my_name)
        (self.pubkey, self.privkey) = rsa.newkeys(256)
        # msg="Hello my friend"
        # cr=rsa.encrypt(msg, self.pubkey)
        # msg2=rsa.decrypt(cr, self.privkey)
        welcome_data = {'nick': self.my_name, 'pubkey_n': self.pubkey.n, 'pubkey_e': self.pubkey.e}
        for peer in self.networking.get_peers():
            # print("Auth_module: Request connect me into p2p network")
            welcome_request = self.send_request(peer, 'welcome', welcome_data)

        self.process()
Esempio n. 24
0
def generateKey():
    (pubkey, privkey) = rsa.newkeys(169)
    print('pubkey:  %s,\n privkey:  %s' % (pubkey, privkey))
    pub = pubkey.save_pkcs1('PEM').decode()  ## public.pem','w+' ,decode后不能用wb
    with open('public.pem', 'w+') as myfile:
        myfile.write(pub)
        myfile.close()
    pri = privkey.save_pkcs1('PEM').decode()
    with open('private.pem', 'w+') as myfile:
        myfile.write(pri)
        myfile.close()
    message = 'helloworld-python'

    with open('public.pem', 'r') as f:
        pubkey = rsa.PublicKey.load_pkcs1(f.read())
        print('pubkey%s'%pubkey)

    with open('private.pem', 'r') as f:
        privkey = rsa.PrivateKey.load_pkcs1(f.read())
        print('privkey%s'%privkey)

    ## OverflowError: 17 bytes needed for message, but there is only space for 10
    crypto = base64.b64encode(rsa.encrypt(message.encode(encoding="UTF-8"), pubkey))  # 私钥解密
    message = rsa.decrypt(base64.b64dncode(crypto), privkey)
    print(message)
def main():
    (pcKey, pKey) = rsa.newkeys(1024)
    messg = 'I, Graciela Vargas Roque, signed this message!'
    messg = messg.encode('utf-8')
    sig = rsa.sign(messg, pKey, 'SHA-256')

    return messg, sig, pcKey
def generate_secret():
    """Generate rsa keys for authentication."""
    import rsa
    print("[*] Generating secret, please hang on.")
    # Generate keys, taken from https://stuvel.eu/python-rsa-doc/usage.html#generating-keys
    (pubkey, privkey) = rsa.newkeys(2048)

    # Save private and pub key
    priv_key_file = open(CONFIG['MobSF']['priv_key'], 'w')
    priv_key_file.write(privkey.save_pkcs1().decode('utf-8'))
    priv_key_file.close()
    pub_key_file = open(CONFIG['MobSF']['pub_key'], 'w')
    pub_key_file.write(pubkey.save_pkcs1().decode('utf-8'))
    pub_key_file.close()

    print(
        "[!] Please move the private key file\n"
        "\t{}\n"
        "\tto MobSF to the path specified in settings.py\n"
        "\t(default: Mobile-Security-Framework-MobSF/MobSF/windows_vm_priv_key.asc)"
        .format(CONFIG['MobSF']['priv_key'])
    )
    if sys.version_info.major == 3:
        # pylint: disable-msg=W0141
        # For python3
        input("Please press any key when done..")
    elif sys.version_info.major == 2:
        raw_input("Please press any key when done..")
Esempio n. 27
0
 def KeyGen(self):
     (keyPub, keyPriv) = rsa.newkeys(512)
     print "KeyGen: New keys generated."
     self.clientKeyPrivate = keyPriv
     self.clientKeyPublic = keyPub
     self.KeySave(self.clientKeyPrivate, self.clientKeyFilePrivate, self.keyTypeClient, self.keyClassPrivate)
     self.KeySave(self.clientKeyPublic, self.clientKeyFilePublic, self.keyTypeClient, self.keyClassPublic)
     print "KeyGen: New keys saved successfully."
Esempio n. 28
0
def work_with_big_file():
    """encrypt a big file using IO stream
    """
    (pubkey, privkey) = rsa.newkeys(512, poolsize=1)
    with open(r"testdata\message.txt", "rb") as infile, open(r"testdata\received.txt", 'wb') as outfile:
        encrypt_bigfile(infile, outfile, pubkey)
    with open(r"testdata\received.txt", "rb") as infile, open(r"testdata\decrypted.txt", 'wb') as outfile:
        decrypt_bigfile(infile, outfile, privkey)
Esempio n. 29
0
def main(UAClass):
    print "Running Protocol with %s" % UAClass.__name__
    print "=" * 40
    publickey, privatekey = rsa.newkeys(512)
    tpm = TPM(privatekey)
    ua = UAClass(tpm)
    server = Server(publickey)
    ua.send_message("Javascript result", server)
Esempio n. 30
0
 def __init__(self, keysize=1024, *args, **kargs):
     if kargs.get('keysize'):
         keysize = kargs.pop('keysize')
     self.sock = socket.socket(*args, **kargs)
     self.conn = None
     self.pub, self.priv = rsa.newkeys(keysize)
     self.keysize = keysize
     self.key = None
Esempio n. 31
0
from rsa import newkeys, encrypt, decrypt

# Generating public and private key pair
print("Generating keypair!")
pubkey, privkey = newkeys(4096, poolsize=8)

print("Keys generated!")
print(f"Your public key is: {pubkey}")
print(f"Your private key is: {privkey}")

# Accept string to encrypt with public key
message = input("Enter a message to encrypt: ").encode("utf-8")
# Encrypt the given string using the generated public key
encrypted = encrypt(message, pubkey)

print(f"Encrypted message is {encrypted}")

# Decrypt the encrypted string using the generated private key
decrypted = decrypt(encrypted, privkey)

print(f"Decrypted message is: {decrypted.decode()}")
Esempio n. 32
0
import rsa
import json
import hashlib

d = 3171116340292388119434451358851392461119376028218393462974765347922079624990431158157119359468019911817507985531433220411075365766294033871942139272090097
e = 65537
n = 9412810887890857384092379125188808719796211185350280917748865284060389172093699004782158842329541367593956792940586337736197470391447676122078020829219401
p = 6687752773375905845628287846107383612359021833928018756053495242416598040217779597
q = 1407469924032399816120206005991522429163464449823001027488465080413289133

pub = rsa.PublicKey(n, e)
priv = rsa.PrivateKey(n, e, d, p, q)

with open('WS2021/Модуль2/Task1/Task7-block.json', 'r') as f:
    block = json.load(f)

block = json.dumps(block, separators=(',', ':'))

sign = rsa.sign(block.encode(), priv, 'SHA-1').hex()

pub, priv = rsa.newkeys(1024)
print(len(hashlib.sha512('a'.encode()).hexdigest()))
print(len(rsa.sign('a'.encode(), priv, 'SHA-512').hex()))
Esempio n. 33
0
 def __init__(self, name: str):
     self.name = name
     self.connections = []
     self.messages = []
     self.public_key, self.private_key = rsa.newkeys(512)
Esempio n. 34
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import rsa
from base64 import b64encode

secret = 'hello' * 1000
pubkey, privkey = rsa.newkeys(512)
print(pubkey)
print(pubkey.save_pkcs1())
print(repr(pubkey.save_pkcs1('DER')))
print(b64encode(pubkey.save_pkcs1('DER')))
print(privkey)
print(privkey.save_pkcs1())

pubkey = rsa.PublicKey(
    7415502624357151701843602000555318455948573542840931625729150638611638251360782052774127447815979830851875097447216767147242437831115031378524678172264921,
    65537,
)
privkey = rsa.PrivateKey(
    7415502624357151701843602000555318455948573542840931625729150638611638251360782052774127447815979830851875097447216767147242437831115031378524678172264921,
    65537,
    5677294416545159019180046849533288120103448090575457288569207215654347148007043218092439893759997074589438975571531525440203012025002055883676278902503473,
    4446231151572194572272541834440666920306217930405766286220328832524851462544515341,
    1667817612616703003339597571420391729959720600059564280837759069331120381,
)
print(pubkey)
print(pubkey.save_pkcs1())
print(privkey)
print(privkey.save_pkcs1())
Esempio n. 35
0
    sys.stdout.flush()
    backup = sys.stdin.readline()
    print backup
    global entries
    entries = pickle.loads(rsa.decrypt(backup.decode("base64"), privkey))
    print("Successfully restored %d entries\n" % len(entries))


def show_key():
    print("Here is your key:")
    print(str(pubkey))


print("Welcome to Super Password Authentication Manager (SPAM)!")
sys.stdout.flush()
(pubkey, privkey) = rsa.newkeys(1024)
while 1:
    while 1:
        print("Menu:")
        print("1) List Passwords")
        print("2) Add a Password")
        print("3) Remove a Password")
        print("4) Backup Passwords")
        print("5) Restore backup")
        print("6) Show the key")
        sys.stdout.flush()
        l = str(input())
        if len(l) == 1 and l in "123456":
            [
                spam_list, spam_add, spam_del, spam_backup, spam_restore,
                show_key
Esempio n. 36
0
import rsa

(bob_pub, bob_pri) = rsa.newkeys(512)
print(f'公钥:{bob_pub}\n私钥:{bob_pri}\n')
message = 'hello world'.encode('utf-8')
crypto = rsa.encrypt(message, bob_pub)
print(f'密文:{crypto}', len(crypto))
message = rsa.decrypt(crypto, bob_pri)

print('解密后:', message.decode('utf-8'))
Esempio n. 37
0
import rsa
import time
import threading
import keyboard
import qrcode
import logger
import glob
'''
An improved version of the old ACDS. 

What it does is safely overload your CPU and run several priv/pub scripts simultaneously on your server. 

Please use a spoof for the best experience.
'''

public, private = rsa.newkeys(612)

HOSTNAME = socket.gethostname()
IP = None
SECRET = auth.twofactorAUTH.SECRETKEY_AT_LOAD
CURSOR = f"\n\033[38;5;129m╔\033[38;5;128m═\033[38;5;123m[\033[38;5;125m{os.getcwd()}\033[38;5;123m]\033[38;5;128m-\033[38;5;123m[\033[38;5;127m{socket.gethostname()}\033[38;5;123m]\n\033[38;5;129m╚══\033[38;5;128m══\033[38;5;124m➤ \033[38;5;123m"
TOTP = auth.twofactorAUTH.PinAuthorization.TOTP(
    auth.twofactorAUTH.Decrypt(SECRET))

pt_infoFiles = glob.glob(f"**\\[p]*.txt",
                         recursive=True)  # Match all pentest info files
logDB = glob.glob(
    f"**\\lo??.csv", recursive=True
)  # Our local Database data to find all valid pentest info files

Esempio n. 38
0
 def generate_new_key(self, keysize=2048):
     try:
         self._public_key, self._private_key = PYRSA.newkeys(keysize, poolsize=4)
     except:
         self._public_key, self._private_key = PYRSA.newkeys(keysize)
Esempio n. 39
0
def create_keys():
    return rsa.newkeys(1024)
        for i in range(1, self.getLength()):
            currentBlock = self.chain[i]
            previousBlock = self.chain[i-1]
            if not currentBlock.hasValidTransactions():
                return False
            if currentBlock.hash != currentBlock.calculateHash():
                return False
            if currentBlock.prevhash != previousBlock.hash:
                return False
        return True




# Create my keys
keyPair = rsa.newkeys(512)
myKey = keyPair[1]
myWalletAddress = keyPair[0]
print('Your private key:', myKey)
print('Your public key:', myWalletAddress)


# Create the Blockchain platform
Platform = Blockchain()

# Prompt user to enter transactions or start the miner
work = True
while work:
    dowhat = input('Please enter the things you want to do: enter "mine" for mining, enter "esc" for exit, others for adding transactions> ')
    if dowhat == 'esc':
        work = False
Esempio n. 41
0
def genRSAKeyPair(a, b):
    (pubKey, privKey) = rsa.newkeys(4096)
    with open(a, "w+") as pubKeyFile:
        pubKeyFile.write(pubKey.save_pkcs1(format='PEM'))
    with open(b, "w+") as privKeyFile:
        privKeyFile.write(privKey.save_pkcs1(format='PEM'))
Esempio n. 42
0
    # 产生公钥私钥
    (pub, pri) = rsa.newkeys(2048)

    # 构建新的公钥私钥
    pubkey = rsa.PublicKey(pri.n, pri.e)
    pri_key = rsa.PrivateKey(pri.n, pri.e, pri.d, pri.p, pri.q)

    message = b'\x00\x00\x00\x00\x01'
    # 加密 message
    crypto = rsa.encrypt(message, pubkey)
    # 解密
    d_crypto = rsa.decrypt(crypto, pri_key)

    print(d_crypto)

keys = rsa.newkeys(2048)

bts_str = {
    "version": "2.0",
    "charset": "UTF-8",
    "messageId": "02dxxadwf3f3a29674e674e6",
    "guestId": "10100",
    "appId": "10103",
    "signType": "RSA2",
    "reqTime": "2020043011212",
    "beginTime": "20200804-121212",
    "endTime": "20200805-231212",
    "deviceId": "04181100646",
    "pspId": "2",
    "businessDate": "20200805"
}
Esempio n. 43
0
from multiprocessing import Queue
import multiprocessing, os, pickle, select, socket, sys, time, rsa, traceback
from common.safeprint import safeprint
from common.bounty import *

global ext_port
global ext_ip
global port
global myPriv
global myPub
ext_port = -1
ext_ip = ""
port = 44565
myPub, myPriv = rsa.newkeys(1024)

seedlist = [("127.0.0.1",44565), ("localhost",44565), ("10.132.80.128",44565)]
peerlist = [("24.10.111.111",44565)]
remove   = []
bounties = []

#constants
peers_file          = "data" + os.sep + "peerlist.pickle"
key_request         = "Key Request".encode('utf-8')
close_signal        = "Close Signal".encode("utf-8")
peer_request        = "Requesting Peers".encode("utf-8")
bounty_request      = "Requesting Bounties".encode("utf-8")
incoming_bounties   = "Incoming Bounties".encode("utf-8")
incoming_bounty     = "Incoming Bounty".encode("utf-8")
valid_signal        = "Bounty was valid".encode("utf-8")
invalid_signal      = "Bounty was invalid".encode("utf-8")
end_of_message      = "End of message".encode("utf-8")
Esempio n. 44
0
 def setUp(self):
     (self.pub, self.priv) = rsa.newkeys(512)
Esempio n. 45
0
#     'k3':'v3',
# }
# for k in list(api_dict.keys()):
#     v = api_dict[k]
#     if v == 'v2':
#         del  api_dict[k]
# print(api_dict)
# # for k,v in api_dict.keys():
# #     if v == 'v2':
# #         del api_dict[k]

import rsa
import base64

# ######### 1. 生成公钥私钥 #########
pub_key_obj, priv_key_obj = rsa.newkeys(256)

pub_key_str = pub_key_obj.save_pkcs1()
pub_key_code = base64.standard_b64encode(pub_key_str)

priv_key_str = priv_key_obj.save_pkcs1()
priv_key_code = base64.standard_b64encode(priv_key_str)

print(pub_key_code, type(pub_key_code))
print(priv_key_code, type(priv_key_code))


# ######### 2. 加密 #########
def encrypt(value):
    key_str = base64.standard_b64decode(pub_key_code)
    pk = rsa.PublicKey.load_pkcs1(key_str)
    input('Press ENTER to help Bob encrypt his message to Alice.')
elif continuegame.lower() != "yes":
    print(
        'Aww man, that sucks.  Unfortunately without your help, Evil Eve figured out how to crash Bob and Alice\'s second date and that ends the Alice and Bob story.'
    )
    sys.exit()

#Let's start the encryption portion
print(
    '\nAlrighty, thanks for agreeing to help Bob out. Honestly, Bob is kind of a doof and would not be able to do this without you. Here is the plan. You will need to encrypt Bob\'s message to Alice first. Don\'t know how to do that? Don\'t worry, let\'s walk through this step by step.'
)
input('Press ENTER to run the RSA Encryption Program.')

#Insert RSA Encryption Program here (this is where the rsa module gets used)
#Alice's generated key pair, Bob has public Alice's public key
(alice_pub, alice_priv) = rsa.newkeys(512)
#Need Alice's private key later to decrypt message, so making a global variable
ALICE_PRIV = alice_priv

#Bob uses Alice's public key to encrypt message to Alice
bobmessage = input('What is the message you want to send? ')
message = bobmessage.encode('utf8')
#Need CRYPTO to be global so we can call this variable later when Alice decrypts the encrypted message
CRYPTO = rsa.encrypt(message, alice_pub)

#Here is the encrypted message
input('Press ENTER to see the encrypted message.')
print('\nGreat job! Here is the encrypted message:' + ' \n' + str(CRYPTO))

input('Press ENTER to continue with the tutorial.')
print(
Esempio n. 47
0
def gen_addr_key_pair():
    pubkey, privkey = rsa.newkeys(384)
    return pubkey_to_address(pubkey), privkey
Esempio n. 48
0
import rsa
import pickle
from stegano import lsb
from LSBSteg import LSBSteg
import cv2
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad


global bob_pub
global bob_priv
global my_pub
global my_priv


(bob_pub, bob_priv) = rsa.newkeys(512)


(my_priv,my_pub)= rsa.newkeys(512)


def lis(s):
    my=[s]
    while True:
        r,w,e=select.select(my,[],[])
        if s in r:
            try:
                global bob_pub
                global bob_priv
                (p,te)=pickle.loads(s.recv(100000000))
                if p==1:
#
#     Licensed under the Apache License, Version 2.0 (the "License");
#     you may not use this file except in compliance with the License.
#     You may obtain a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#     Unless required by applicable law or agreed to in writing, software
#     distributed under the License is distributed on an "AS IS" BASIS,
#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#     See the License for the specific language governing permissions and
#     limitations under the License.
#
import rsa

# nuitka-skip-unless-imports: rsa

(tambe_pub, tambe_priv) = rsa.newkeys(512)
message = "beautiful Tambe!".encode("utf8")
encrypted_msg = rsa.encrypt(message, tambe_pub)
message = rsa.decrypt(encrypted_msg, tambe_priv)


def encryption_decryption():
    """Function to test encryption and decryption"""
    assert message.decode("utf8") == "beautiful Tambe!"


if __name__ == "__main__":
    encryption_decryption()
Esempio n. 50
0
import rsa

key = rsa.newkeys(3000)  #生成随机秘钥
privateKey = key[1]  #私钥
publicKey = key[0]  #公钥

message = '中国山东烟台.Now is better than never.'
print('Before encrypted:', message)
message = message.encode()

cryptedMessage = rsa.encrypt(message, publicKey)
print('After encrypted:\n', cryptedMessage)

message = rsa.decrypt(cryptedMessage, privateKey)
message = message.decode()
print('After decrypted:', message)
Esempio n. 51
0
def generate_keys(size):
    return rsa.newkeys(size)
Esempio n. 52
0
def generate(filename):
    (public, private) = rsa.newkeys(1024)
    sig = saveWallet(public, private, filename)
    text = "New wallet generated in '"+filename+"' with signature "+sig
    return text
Esempio n. 53
0
class Server(ss.StreamRequestHandler):

    (serverPublicKey, serverPrivateKey) = rsa.newkeys(1600, poolsize=2)

    #	key: address ... val: serverobject
    clients = dict()

    #	key: name ... val: address
    usernames = dict()

    # key:address.... val:pKey
    publicKeys = dict()

    #	key: name ... val: [messageDict]
    offlineMessages = dict()

    def createMessageDict(self, source, data):
        messageDictionary = {"from": source, "message": data}

        return messageDictionary

    def dumpAndEncodeDict(self, messageDictionary):
        messageJson = json.dumps(messageDictionary)
        encoded = messageJson.encode()

        return encoded

    def encryptMessageAndSend(self, thisClient, encodedMessage, destAddr):

        pubKey = self.publicKeys[destAddr]

        encryptedMessage = rsa.encrypt(encodedMessage, pubKey)

        print(encodedMessage)

        thisClient.request.sendall(encryptedMessage)

    def sendEveryoneMessage(self, messageDictionary, myAddr):

        for addr, client in self.clients.items():

            if (addr != myAddr):

                encoded = self.dumpAndEncodeDict(messageDictionary)

                self.encryptMessageAndSend(client, encoded, addr)

    def sendExternalMessage(self, destAddr, messageDictionary):

        encoded = self.dumpAndEncodeDict(messageDictionary)

        reciever = self.clients[destAddr]

        self.encryptMessageAndSend(reciever, encoded, destAddr)

    def getMyAddr(self):

        peerName = self.request.getpeername()
        myAddr = peerName[1]
        return myAddr

    def systemResponse(self, message):
        messageDictionary = {"from": "SERVER", "message": message}
        encodedMessage = self.dumpAndEncodeDict(messageDictionary)

        myAddr = self.getMyAddr()

        self.encryptMessageAndSend(self, encodedMessage, myAddr)

    def remove(self, connectionAddr, name):
        res1 = self.clients.pop(connectionAddr, None)
        res2 = self.usernames.pop(name, None)

        messageDictionary = {
            "from": "SERVERTERM",
            "message": "Have a great day!"
        }
        encodedMessage = self.dumpAndEncodeDict(messageDictionary)

        myAddr = self.getMyAddr()

        self.encryptMessageAndSend(self, encodedMessage, myAddr)

    def sendServerKey(self):

        pickledPublicKey = pickle.dumps(self.serverPublicKey, 0).decode()

        messageDictionary = {
            "destName": "SERVERPUBLICKEY",
            "message": pickledPublicKey
        }

        send = self.dumpAndEncodeDict(messageDictionary)

        self.request.sendall(send)

    def handle(self):
        while True:

            fromAddr = self.getMyAddr()

            self.data = self.request.recv(1024)

            jsonData = json.loads(self.data.decode())

            message = jsonData["message"]
            dest = jsonData["destName"]

            if (dest.startswith("CONNECTEDUSERNAME")):
                #wants to join

                try:

                    split = message.split(sep="-")

                    name = split[0]

                    publicKeyPickledDecoded = split[1]

                except Exception as e:
                    print("NAme pickle split issue")
                    print(e)
                    continue

                try:

                    publicKeyPickled = publicKeyPickledDecoded.encode()
                    publicKey = pickle.loads(publicKeyPickled)

                except Exception as e:
                    print("public key depickle issue")
                    print(e)
                    continue

                try:
                    # add self to clients list
                    self.clients[fromAddr] = self
                    # add self to usernames list
                    self.usernames[name] = fromAddr

                    self.publicKeys[fromAddr] = publicKey

                    print(fromAddr, "with username,", name,
                          "just connected to the server.")

                except Exception as e:
                    print("ERROR")
                    print(e)

                response = "Welcome to ClassChat, " + name + ".\n\tTo send a message use the format \"USERNAME-MESSAGE\" " + "\n\t Type GETUSERS to view all users."

                try:
                    offlineArray = self.offlineMessages.pop(name)

                    offlineResponse = "Welcome to ClassChat, " + name + ".\n\tTo send a message use the format \"USERNAME-MESSAGE\" " + "\n\t Type GETUSERS to view all users. \n\t Type LEAVE to leave. \n\n Here's what you missed while you were gone..... "

                    offlineMessage = {
                        "from": "SERVER",
                        "message": offlineResponse
                    }

                    offlineArray.insert(0, offlineMessage)

                    encodedMessage = self.dumpAndEncodeDict(
                        {"messages": offlineArray})

                    myAddr = self.getMyAddr()

                    self.encryptMessageAndSend(self, encodedMessage, myAddr)

                except KeyError as e:
                    print("No offline messages for", e)
                    self.systemResponse(response)

            elif (dest == "LEAVE"):
                #wants to leave

                myAddr = fromAddr
                myName = list(self.usernames.keys())[list(
                    self.usernames.values()).index(fromAddr)]

                print("Deleting user,", fromAddr, "with username,", myName,
                      "from server.")

                self.remove(myAddr, myName)

            elif (dest.startswith("GETUSERS")):
                #wants the list of users

                message = ""
                self.usernames.keys()
                for key in sorted(self.usernames.keys()):
                    message += ("\n" + key)

                self.systemResponse(message)

            elif (dest.startswith("EVERYONE")):
                #sending a group message

                myName = list(self.usernames.keys())[list(
                    self.usernames.values()).index(fromAddr)]
                messageDict = self.createMessageDict(myName, message)

                self.sendEveryoneMessage(messageDict, fromAddr)

                self.systemResponse(("Sent message to " + dest))

            else:
                #sending a direct message
                myName = list(self.usernames.keys())[list(
                    self.usernames.values()).index(fromAddr)]

                messageDict = self.createMessageDict(myName, message)

                try:
                    destAddr = self.usernames[dest]

                except KeyError as e:

                    self.offlineMessages.setdefault(dest,
                                                    []).append(messageDict)

                    self.systemResponse("No user available named " + dest +
                                        " ....storing message offline.")

                    continue

                print("Message sent: {} -> {}".format(myName, dest))

                self.sendExternalMessage(destAddr, messageDict)

                self.systemResponse(("Sent message to " + dest))
Esempio n. 54
0
import pyaes
import socket
import threading
import json
from datetime import datetime
import rsa
import hashlib

HOST = '127.0.0.1'
PORT = 8888
SECMODE = True

if SECMODE:
    pubkey, prikey = rsa.newkeys(2048)
    print("Server public key ", pubkey)
    print("[+] Server Running ")
    print("[+] Waiting For Connection...")
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind((HOST, PORT))
    s.listen(1)
    conn, addr = s.accept()
    print('[+] Connected by ', addr)
    conn.send(bytes(str(pubkey.n).encode()))
    data = conn.recv(512)
    print("Received encrypted session key ", data)
    AESkey = rsa.decrypt(data, prikey)
    print("Received decrypted session key ")
    hashed = hashlib.sha256(AESkey).digest()
    aes = pyaes.AESModeOfOperationCBC(hashed)
    cl_pub = conn.recv(2048)
    n_cl = int(cl_pub.decode())
Esempio n. 55
0
import rsa

public, private = rsa.newkeys(8096)

with open("priv_key.txt", "w") as file:
    file.write(str(private)[11:-1])

with open("pub_key.txt", "w") as file:
    file.write(str(public)[10:-1])
 def make_keys(self):
     return rsa.newkeys(512)
import rsa
import base64

(pub_key, private_key) = rsa.newkeys(512)


def check_rsa():
    message = b'Hello World!'
    crypto = rsa.encrypt(message, pub_key)
    print(crypto)
    message = rsa.decrypt(crypto, private_key)
    print(message)


def encrypt_rsa_with_base64(message: str) -> bytes:
    crypto = rsa.encrypt(message.encode(), pub_key)
    return base64.b64encode(crypto)


def decrypt_rsa_with_base64(crypto: bytes) -> str:
    raws = base64.b64decode(crypto)
    return str(rsa.decrypt(raws, private_key))


if __name__ == '__main__':
    crypto_message = encrypt_rsa_with_base64('Hello world!')
    print(crypto_message)
    print(decrypt_rsa_with_base64(crypto_message))

Esempio n. 58
0
 def _generate_rsa_keys(cls, nbits: int) -> Tuple[PublicKey, PrivateKey]:
     cls.logger.debug("Generate RSA key with %i bits", nbits)
     return rsa.newkeys(nbits)
Esempio n. 59
0
 def __init__(self, number=1024):
     """
     :param number: 公钥、私钥
     """
     self.pubkey, self.privkey = rsa.newkeys(number)
Esempio n. 60
0
game_type = dsp_choice_game()

deck = []
if(game_type == 1 or game_type == 2 or game_type == 3 or game_type == 4):
    make_deck_by_type(game_type, deck)
else:
    dsp_end()
    exit()

player_a = []
player_b = []
player_c = []
player_d = []
player_dumy = []

key = rsa.newkeys(4500)
public_key = key[0]
private_key = key[1]

if game_type == 1:
    deal_to_multi_players(deck, player_a, player_b, player_c)
    record_deck_crypted_csv(player_a, '争上游01的副牌.csv',public_key)
    record_deck_crypted_csv(player_b, '争上游02的副牌.csv',public_key)
    record_deck_crypted_csv(player_c, '争上游03的副牌.csv',public_key)
if game_type == 2:
    deal_to_multi_players(deck, player_a, player_b, player_c, player_d)
    record_deck_crypted_csv(player_a, '桥牌01的副牌.csv',public_key)
    record_deck_crypted_csv(player_b, '桥牌02的副牌.csv',public_key)
    record_deck_crypted_csv(player_c, '桥牌03的副牌.csv',public_key)
    record_deck_crypted_csv(player_d, '桥牌04的副牌.csv',public_key)
if game_type == 3: