def __init__(self,
name="testchainid",
crypto_suite=ecies(),
peers=None,
orderers=None,
key_value_store=None,
tcert_batch_size=0,
is_dev_mode=False,
is_pre_fetch_mode=False):
"""
Args:
name: Chain unique name
peers: Peer set
orderers: Orderer set
key_value_store: A KeyValueStore instance
tcert_batch_size: Tcert batch size
is_dev_mode: Determines if chaincode deployment in dev mode
is_pre_fetch_mode: Determines if pre fetch tcerts
"""
self._orderers = {} if not orderers else orderers
self._peers = {} if not peers else peers
self._name = name
self._key_value_store = key_value_store
self._tcert_batch_size = tcert_batch_size
self._is_dev_mode = is_dev_mode
self._is_pre_fetch_mode = is_pre_fetch_mode
self._crypto = crypto_suite
def test_ecies_secp256r1_sha2(self):
"""Test case for security level 256, hash SHA2."""
ecies256 = ecies(CURVE_P_256_Size, SHA2)
private_key = ecies256.generate_private_key()
cipher_text = ecies256.encrypt(private_key.public_key(),
self.plain_text)
self.assertEqual(ecies256.decrypt(private_key, cipher_text),
self.plain_text)
def test_ecies_secp384r1_sha3(self):
"""Test case for security level 384, hash SHA3."""
ecies384 = ecies(CURVE_P_384_Size, SHA3)
private_key = ecies384.generate_private_key()
cipher_text = ecies384.encrypt(private_key.public_key(),
self.plain_text)
self.assertEqual(ecies384.decrypt(private_key, cipher_text),
self.plain_text)
def test_ecies_generate_csr(self):
"""Test case for generate certificate signing request."""
ecies256 = ecies()
private_key = ecies256.generate_private_key()
csr = ecies256.generate_csr(
private_key,
x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, u"test")]))
csr_pem = csr.public_bytes(Encoding.PEM)
self.assertTrue(
csr_pem.startswith(b"-----BEGIN CERTIFICATE REQUEST-----"))
def test_secp256r1_check_malleability_and_check_prevent_malleability(self):
"""Test case for check_malleability and prevent_malleability."""
ecies256 = ecies(CURVE_P_256_Size, SHA2)
private_key = ecies256.generate_private_key()
signature = ecies256.sign(private_key, self.plain_text)
self.assertEqual(ecies256._check_malleability(signature), True)
self.assertEqual(
ecies256._check_malleability(
ecies256._prevent_malleability(signature)), True)
def test_ecies_secp384r1_sha2_sign_verify(self):
"""Test case for security level 256, hash SHA2."""
ecies384 = ecies(CURVE_P_384_Size, SHA2)
private_key = ecies384.generate_private_key()
signature = ecies384.sign(private_key, self.plain_text)
self.assertEqual(
ecies384.verify(private_key.public_key(), self.plain_text,
signature), True)
self.assertEqual(
ecies384.verify(private_key.public_key(), self.plain_text + b'!',
signature), False)
def msp(identity, signer=None, crypto_suite=ecies(),
root_certs=None, admins=None):
"""Create msp instance
Args:
identity: id
signer: signing identity
crypto_suite: crypto suite
root_certs: root certs
admins: admins
Returns: msp instance
"""
return MSP(identity, signer, crypto_suite, root_certs, admins)
def __init__(self, identity, signer=None, crypto_suite=ecies(),
root_certs=None, admins=None):
""" Init with configuration info.
Args:
root_certs: trust anchors at boot
signer: signing identity
admins: admin privileges
crypto_suite: crypto algorithm family
identity: id of the instance
"""
self._root_certs = [] if not root_certs else root_certs
self._signer = signer
self._admins = [] if not admins else admins
self._crypto_suite = crypto_suite
self._id = identity
def ca_service(target=DEFAULT_CA_ENDPOINT,
ca_certs_path=None,
crypto=ecies(),
ca_name=""):
"""Create ca service
Args:
target: url
ca_certs_path: certs path
crypto: crypto
ca_name: CA name
Returns: ca service instance
"""
return CAService(target, ca_certs_path, crypto, ca_name)
def __init__(self,
target=DEFAULT_CA_ENDPOINT,
ca_certs_path=None,
crypto=ecies(),
ca_name=""):
""" Init CA service.
Args:
target (str): CA server address including protocol,hostname,port
ca_certs_path (str): Local ca certs path
crypto (Crypto): A crypto instance
ca_name (str): The optional name of the CA, Fabric-ca servers
support multiple Certificate Authorties from a signle server.
If omitted or null or an empty string, then the default CA
is the target of requests
"""
self._ca_client = CAClient(target, ca_certs_path, ca_name=ca_name)
self._crypto = crypto
def test_user_state(self):
store = file_key_value_store(self.path)
user = User('test_user', 'peerOrg1', store)
user.roles = ['test']
ec = ecies()
enrollment = Enrollment(ec.generate_private_key(), "dasdasdasdasdasd")
user.enrollment = enrollment
user1 = User('test_user', 'peerOrg1', store)
self.assertTrue(user1.roles == ['test'])
self.assertTrue(user1.enrollment.cert == "dasdasdasdasdasd")
pub_key = user1.enrollment.private_key.public_key()
self.assertTrue(
pub_key.public_bytes(
encoding=Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo).
startswith(b'-----BEGIN PUBLIC KEY'))
def get_submitter():
ca = ca_service()
user = User(USER_ID, USER_PASSWD, msp_impl=msp('DEFAULT', ecies()), ca=ca)
user.enroll()
return user