def main():
command = sys.argv[1]
if command == 'create_new_wallet':
create_new_wallet()
return
PUB = ''.join(open('rsa.pub').read().split('\n')[1:4])
receiver = command
amount = sys.argv[2]
timestamp = time()
sha = hasher.sha256()
sha.update(str(PUB) + str(receiver) + str(amount) + str(timestamp))
hash = sha.hexdigest()
with open('rsa.pri', 'r') as f:
PRI = PrivateKey.load_pkcs1(f.read())
sig = sign(hash, PRI, 'SHA-256').encode('hex')
try:
requests.post('http://{ip}:8000/new_transaction/'.format(
ip=MINERS[randint(0,
len(MINERS) - 1)]),
data={
'timestamp': timestamp,
'sender': PUB,
'receiver': receiver,
'amount': amount,
'hash': hash,
'sign': sig,
})
except:
pass
def main():
if len(argv) < 3:
print 'Format: enc.py <identifier> <message>'
return
ID = argv[1] # Identifier of origin
MESSAGE = argv[2]
# Read private key of origin
with open(ID + '.pr', 'r') as f:
privatekey = PrivateKey.load_pkcs1(f.read())
# Sign message with private key
SIGN = sign(MESSAGE, privatekey, 'SHA-256').encode('hex')
# Concatenate message, signature and identifier
TEXT = padding(MESSAGE, 100) + padding(SIGN, 400) + padding(ID, 100)
# Create QR code
qr = QRCode(
version=1,
error_correction=ERROR_CORRECT_L,
box_size=10,
border=4,
)
qr.add_data(TEXT)
qr.make(fit=True)
img = qr.make_image()
img.save(ID + '.png')
def rsa_load_key(public_file=None, private_file=None, dir=None):
"""
Загружаем ключи из файлов
:param public_file: файл публичного ключа
:param private_file: файл приватного ключа
:param dir: папка с ключами
:return: возвращаем публичный и приватный ключи
"""
try:
if dir:
if dir[-1] not in sep:
dir += sep
public_file = dir + 'public.key'
private_file = dir + 'private.key'
if not exists(public_file) or not exists(private_file):
raise IOError("Key files not found!")
with open(public_file, 'rb') as f:
public_file = f.read()
with open(private_file, 'rb') as f:
private_file = f.read()
pubkey = PublicKey.load_pkcs1(keyfile=public_file)
privkey = PrivateKey.load_pkcs1(keyfile=private_file)
return pubkey, privkey
except IOError as e:
print("Error: %s" % e)
return None, None
def __init__(self, private_key_data):
"""
:param private_key_data:
"""
self.private_key_data = private_key_data
self.pk = PrivateKey.load_pkcs1(private_key_data, 'PEM')
def private_key_from_pref_data(pref_cert):
"""Load private key from NSData."""
if PYTHONTHREE:
private_key = PrivateKey.load_pkcs1(bytes(pref_cert))
else:
private_key = load_privatekey(FILETYPE_PEM, str(pref_cert))
return private_key
def private_key_from_pref(pref_cert):
"""Load private key from string."""
if PYTHONTHREE:
private_key = PrivateKey.load_pkcs1(base64.b64decode(pref_cert))
else:
private_key = load_privatekey(FILETYPE_PEM, base64.b64decode(pref_cert))
return private_key
def _load_key_file(self, file):
# 从.pem文件中读取key
try:
with open(file) as f:
p = f.read()
self._private_key = PrivateKey.load_pkcs1(p.encode())
except Exception as error:
raise error
def _load_key_file(self, file):
# 从.pem文件中读取key
try:
with open(file) as f:
p = f.read()
self._private_key = PrivateKey.load_pkcs1(p.encode())
return True
except Exception as error:
print(error)
return False
def from_files(cls,
pub_path: str,
priv_path: str,
key_format: str = 'PEM') -> 'Rsa':
"""Parse an RSA keypair from existing files."""
with open(pub_path, "rb") as f:
pub = PublicKey.load_pkcs1(f.read(), format=key_format)
with open(priv_path, "rb") as f:
priv = PrivateKey.load_pkcs1(f.read(), format=key_format)
return cls(pub, priv)
def private_key_from_file(key_file):
"""Load private key from file path."""
with open(key_file, 'r') as f:
data = f.read()
if PYTHONTHREE:
private_key = PrivateKey.load_pkcs1(data.encode('utf8'))
else:
private_key = load_privatekey(FILETYPE_PEM, data)
return private_key
def private_key_from_str(private_key_str):
""" Loads a private key from a given PEM-formatted string.
Args:
private_key_str (bytearray): A byte string which contains the private
key in a PEM format.
Returns:
rsa.PrivateKey: The private key that results from reading the given
file.
"""
return PrivateKey.load_pkcs1(private_key_str, format='PEM')
def decrypt(self, crypt_path, name):
with open(self.privkey, "r") as f2:
priv_key = PrivateKey.load_pkcs1(f2.read().encode())
with open(name, "rb") as f3:
mge = f3.read()
un_rsa_key = decrypt(mge, priv_key).decode()
key_file = os.path.join(crypt_path, name[0:-4])
with open(key_file, "w+") as f4:
f4.write(un_rsa_key)
def test_many_encrypt_decrypt(self):
priv_key = PrivateKey.load_pkcs1(private_key_data)
pub_key = PublicKey.load_pkcs1_openssl_pem(public_key_data)
for i in range(100):
try:
data = randnum.read_random_bits(16 * 8)
enc = pkcs1_v2.encrypt(data, pub_key, hasher='SHA-256')
dec = pkcs1_v2.decrypt(enc, priv_key, hasher='SHA-256')
self.assertEqual(dec, data, i)
except BaseException as e:
self.assertIsNone(e, i)
def sign(self, privkey):
"""
privkey: 私钥
"""
with open(privkey, "r")as f1:
priv_key = PrivateKey.load_pkcs1(f1.read().encode())
with open(self.hash_file, 'rb') as f:
mess = f.read()
with open(self.sha, 'wb') as f:
f.write(sign(mess, priv_key, 'SHA-256'))
def test_many_sign_verify(self):
priv_key = PrivateKey.load_pkcs1(private_key_data)
pub_key = PublicKey.load_pkcs1_openssl_pem(public_key_data)
for i in range(100):
try:
data = randnum.read_random_bits(16 * 8)
signature = pkcs1_v2.sign(data, priv_key, hasher='SHA-256')
self.assertTrue(
pkcs1_v2.verify(data, signature, pub_key,
hasher='SHA-256'), i)
except BaseException as e:
self.assertIsNone(e, i)
def _sign(self, content):
if keystore is None or not path.exists(keystore):
raise IllegalArgumentException(
'Unable to find the keystore: ' + keystore)
with open(keystore, 'r') as key_file:
private_key = PrivateKey.load_pkcs1(key_file.read().encode())
try:
signature = sign(content, private_key, 'SHA-256')
return urlsafe_b64encode(signature)
except TypeError:
signature = sign(content.encode(), private_key, 'SHA-256')
return urlsafe_b64encode(signature).decode()
def private_key_from_file(filepath):
""" Loads a private key from a given filepath.
Args:
filepath (string): A path to the file which contains the private key in
a PEM format.
Returns:
rsa.PrivateKey: The private key that results from reading the given
file.
"""
with open(filepath, 'rb') as f:
pk = PrivateKey.load_pkcs1(f.read(), format='PEM')
return pk
def _load_rsa_keys(self) -> Tuple[PublicKey, PrivateKey]:
"""Load RSA keys from filesystem"""
self.logger.debug("Load public key from %s", self.__pub_key_path)
with open(self.__pub_key_path, "rb") as pem_file:
pub_key_data = pem_file.read()
self.logger.debug("RSA public key loaded")
self.logger.debug("Load private key from %s", self.__priv_key_path)
with open(self.__priv_key_path, "rb") as pem_file:
priv_key_data = pem_file.read()
self.logger.debug("RSA private key loaded")
return PublicKey.load_pkcs1(pub_key_data), PrivateKey.load_pkcs1(
priv_key_data)
def load_wallet(uri):
"""
loads a wallet from a public key file
and a private key file
"""
assert not isdir(uri)
with ZipFile(uri, "r") as walletfile:
pub_key = (PublicKey.load_pkcs1(
walletfile.read(WalletConf.PUBLIC_KEY_FILE_NAME)))
priv_key = PrivateKey.load_pkcs1(
walletfile.read(WalletConf.PRIVATE_KEY_FILE_NAME))
return pub_key, priv_key
def __init__(self, connection_string, keys_folder):
super().__init__(connection_string, keys_folder)
self._data = json.loads(connection_string)
self._private_key = None
if self._data.get("encryption_key_name"):
if not os.path.exists(
os.path.join(keys_folder,
self._data.get("encryption_key_name"))):
raise Exception(
"Couldn't initialize environment-based secret-manager, as encryption name with name {} do not exist."
.format(self._data.get("encryption_key_name")))
with open(
os.path.join(keys_folder,
self._data.get("encryption_key_name")),
"rb") as f:
# PEM key
self._private_key = PrivateKey.load_pkcs1(f.read())
def test_many_encrypt_decrypt_fixed_data(self):
priv_key = PrivateKey.load_pkcs1(private_key_data)
pub_key = PublicKey.load_pkcs1_openssl_pem(public_key_data)
all_enc = set()
for i in range(100):
try:
data = b'a simple test message, which will be encrypted'
enc = pkcs1_v2.encrypt(data, pub_key, hasher='SHA-256')
dec = pkcs1_v2.decrypt(enc, priv_key, hasher='SHA-256')
self.assertEqual(dec, data, i)
all_enc.add(enc)
except BaseException as e:
self.assertIsNone(e, i)
# Make sure the seed is doing what it's supposed to do
# This test might (theoretically) fail, although it really shouldn't
# A fail here might indicate a bad RNG
self.assertGreater(len(all_enc), 1)
def test_many_sign_verify_fixed_data(self):
priv_key = PrivateKey.load_pkcs1(private_key_data)
pub_key = PublicKey.load_pkcs1_openssl_pem(public_key_data)
all_signatures = set()
for i in range(100):
try:
data = b'a simple test message, which will be signed'
signature = pkcs1_v2.sign(data, priv_key, hasher='SHA-256')
self.assertTrue(
pkcs1_v2.verify(data, signature, pub_key,
hasher='SHA-256'), i)
all_signatures.add(signature)
except BaseException as e:
self.assertIsNone(e, i)
# Make sure the salt is doing what it's supposed to do
# This test might (theoretically) fail, although it really shouldn't
# A fail here might indicate a bad RNG
self.assertGreater(len(all_signatures), 1)
# prepare environment
home = environ.get('HOME')
user = environ.get('USER')
os.chdir('{home}/.sams/'.format(home=home))
# get pubkey
addressbook = Addressbook('addressbook.csv')
own_address = addressbook.get_by_name(user)
n = int(own_address['n'])
e = int(own_address['e'])
pubkey = PublicKey(n, e)
# get privkey
with open('private.pem', 'r') as privatefile:
keydata = privatefile.read()
privkey = PrivateKey.load_pkcs1(keydata)
# receive messages
receiver = Receiver(privkey, pubkey)
mtime = 0
files = os.listdir('messages/')
for file in files:
filestat = os.stat('messages/{file}'.format(file=file))
if filestat.st_mtime > mtime:
mtime = filestat.st_mtime
if mtime:
dt = datetime.fromtimestamp(mtime)
messages = receiver(dt)
else:
messages = receiver()
def sign_block(b):
with open('rsa.pri', 'r') as f:
privatekey = PrivateKey.load_pkcs1(f.read())
return sign(b.hash, privatekey, 'SHA-256').encode('hex')
def ctrl(conn):
"""
读取控制命令，并在本机还原操作
"""
with open("privkey.pem", "rb") as x:
private_key = x.read()
private_key = PrivateKey.load_pkcs1(private_key) # 私钥
def Op(key, op, ox, oy):
# print(key, op, ox, oy)
if key == 1:
if op == 100:
# 左键按下
mouse.move(ox, oy)
mouse.press(button=mouse.LEFT)
elif op == 117:
# 左键弹起
x, y = mouse.get_position()
if ox != x or oy != y:
if not mouse.is_pressed():
mouse.press(button=mouse.LEFT)
mouse.move(ox, oy)
mouse.release(button=mouse.LEFT)
elif key == 2:
# 滚轮事件
if op == 0:
# 向上
mouse.move(ox, oy)
mouse.wheel(delta=-1)
else:
# 向下
mouse.move(ox, oy)
mouse.wheel(delta=1)
elif key == 3:
# 鼠标右键
if op == 100:
# 右键按下
mouse.move(ox, oy)
mouse.press(button=mouse.RIGHT)
elif op == 117:
# 右键弹起
mouse.move(ox, oy)
mouse.release(button=mouse.RIGHT)
else:
k = official_virtual_keys.get(key)
if k is not None:
if op == 100:
keyboard.press(k)
elif op == 117:
keyboard.release(k)
try:
base_len = 21
while True:
cmd = b''
rest = base_len - 0
while rest > 0:
cmd += conn.recv(rest)
rest -= len(cmd)
key = int(decrypt(cmd[:16], private_key))
op = cmd[16]
x = struct.unpack('>H', cmd[17:19])[0]
y = struct.unpack('>H', cmd[19:21])[0]
Op(key, op, x, y)
except:
return
def test_decrypt(self):
priv_key = PrivateKey.load_pkcs1(private_key_data)
message = pkcs1_v2.decrypt(enc_data, priv_key)
self.assertEqual(message, b'test')
def test_sign(self):
priv_key = PrivateKey.load_pkcs1(private_key_data)
sig = pkcs1_v2.sign(b'test', priv_key, salt_len=0)
self.assertEqual(sig, sig_data)
import os
from rsa import common, transform, core, PrivateKey, PublicKey
from frame.http.exception import BusiError
try:
current_path = os.path.abspath(__file__)
grader_father = os.path.abspath(
os.path.dirname(current_path) + os.path.sep + "..")
pubkey = PublicKey.load_pkcs1(open("resource/public.pem").read())
privkey = PrivateKey.load_pkcs1(open("resource/private.pem").read())
except:
raise BusiError("证书文件路径错误！")
def _pad_for_encryption(message, target_length):
max_msglength = target_length - 11
msglength = len(message)
if msglength > max_msglength:
raise OverflowError("%i bytes needed for message, but there is only"
" space for %i" % (msglength, max_msglength))
padding = b""
padding_length = target_length - msglength - 3
while len(padding) < padding_length:
needed_bytes = padding_length - len(padding)
new_padding = os.urandom(needed_bytes + 5)
new_padding = new_padding.replace(b"\x00", b"")
padding = padding + new_padding[:needed_bytes]
assert len(padding) == padding_length
import json
import sys
from rsa import PrivateKey
with open(sys.argv[1], 'rb') as input:
key = PrivateKey.load_pkcs1(input.read())
d = {}
d['n'] = key.n
d['e'] = key.e
d['d'] = key.d
d['p'] = key.p
d['q'] = key.q
with open(sys.argv[2], 'w') as output:
output.write(json.dumps(d))
def __init__(self, private_key_data):
self.private_key_data = private_key_data
self.pk = PrivateKey.load_pkcs1(private_key_data, 'PEM')
def import_key(extern_key, passphrase=None):
"""Import an RSA key (public or private half), encoded in standard
form.
:Parameter extern_key:
The RSA key to import, encoded as a byte string.
An RSA public key can be in any of the following formats:
- X.509 certificate (binary or PEM format)
- X.509 ``subjectPublicKeyInfo`` DER SEQUENCE (binary or PEM
encoding)
- `PKCS#1`_ ``RSAPublicKey`` DER SEQUENCE (binary or PEM encoding)
- OpenSSH (textual public key only)
An RSA private key can be in any of the following formats:
- PKCS#1 ``RSAPrivateKey`` DER SEQUENCE (binary or PEM encoding)
- `PKCS#8`_ ``PrivateKeyInfo`` or ``EncryptedPrivateKeyInfo``
DER SEQUENCE (binary or PEM encoding)
- OpenSSH (textual public key only)
For details about the PEM encoding, see `RFC1421`_/`RFC1423`_.
The private key may be encrypted by means of a certain pass phrase
either at the PEM level or at the PKCS#8 level.
:Type extern_key: string
:Parameter passphrase:
In case of an encrypted private key, this is the pass phrase from
which the decryption key is derived.
:Type passphrase: string
:Return: An RSA key object (`RsaKey`).
:Raise ValueError/IndexError/TypeError:
When the given key cannot be parsed (possibly because the pass
phrase is wrong).
.. _RFC1421: http://www.ietf.org/rfc/rfc1421.txt
.. _RFC1423: http://www.ietf.org/rfc/rfc1423.txt
.. _`PKCS#1`: http://www.ietf.org/rfc/rfc3447.txt
.. _`PKCS#8`: http://www.ietf.org/rfc/rfc5208.txt
"""
if passphrase is not None:
raise ValueError("RSA key passphrase is not supported")
if extern_key.startswith('ssh-rsa '):
# This is probably an OpenSSH key
keystring = binascii.a2b_base64(extern_key.split(' ')[1])
keyparts = []
while len(keystring) > 4:
l = struct.unpack(">I", keystring[:4])[0]
keyparts.append(keystring[4:4 + l])
keystring = keystring[4 + l:]
e = Integer.from_bytes(keyparts[1])
n = Integer.from_bytes(keyparts[2])
return PublicKey(n._value, e._value)
for fmt in ("PEM", "DER"):
try:
return PrivateKey.load_pkcs1(extern_key, fmt)
except:
try:
return PublicKey.load_pkcs1(extern_key, fmt)
except:
pass
raise ValueError("RSA key format is not supported")
# prepare environment
home = environ.get('HOME')
user = environ.get('USER')
os.chdir('{home}/.sams/'.format(home=home))
# get pubkey
addressbook = Addressbook('addressbook.csv')
own_address = addressbook.get_by_name(user)
n = int(own_address['n'])
e = int(own_address['e'])
pubkey = PublicKey(n, e)
# get privkey
with open('private.pem', 'r') as privatefile:
keydata = privatefile.read()
privkey = PrivateKey.load_pkcs1(keydata)
# receive messages
receiver = Receiver(privkey, pubkey)
mtime = 0
files = os.listdir('messages/')
for file in files:
filestat = os.stat('messages/{file}'.format(file=file))
if filestat.st_mtime > mtime:
mtime = filestat.st_mtime
if mtime:
dt = datetime.fromtimestamp(mtime)
messages = receiver(dt)
else:
messages = receiver()
