class ClientPoolUpgradeOperation(MessageValidator):
schema = (
(TXN_TYPE, ConstantField(POOL_UPGRADE)),
(ACTION, ChooseField(values=(
START,
CANCEL,
))),
(VERSION,
VersionField(components_number=(
2,
3,
),
max_length=VERSION_FIELD_LIMIT)),
# TODO replace actual checks (idr, datetime)
(SCHEDULE,
MapField(IdentifierField(), NonEmptyStringField(), optional=True)),
(SHA256, Sha256HexField()),
(TIMEOUT, NonNegativeNumberField(optional=True)),
(JUSTIFICATION,
LimitedLengthStringField(max_length=JUSTIFICATION_MAX_SIZE,
optional=True,
nullable=True)),
(NAME, LimitedLengthStringField(max_length=NAME_FIELD_LIMIT)),
(FORCE, BooleanField(optional=True)),
(REINSTALL, BooleanField(optional=True)),
)
class ClientTAAAcceptance(MessageValidator):
""" Transaction Author Agreement metadata. """
schema = (
(f.TAA_ACCEPTANCE_DIGEST.nm, Sha256HexField()),
(f.TAA_ACCEPTANCE_MECHANISM.nm,
LimitedLengthStringField(
max_length=TAA_ACCEPTANCE_MECHANISM_FIELD_LIMIT)),
(f.TAA_ACCEPTANCE_TIME.nm, TimestampField()),
)
class ClientAttribOperation(MessageValidator):
schema = (
(TXN_TYPE, ConstantField(ATTRIB)),
(TARGET_NYM, IdentifierField(optional=True)),
(RAW, JsonField(max_length=JSON_FIELD_LIMIT, optional=True)),
(ENC, LimitedLengthStringField(max_length=ENC_FIELD_LIMIT, optional=True)),
(HASH, Sha256HexField(optional=True)),
)
def _validate_message(self, msg):
self._validate_field_set(msg)
if RAW in msg:
self.__validate_raw_field(msg[RAW])
def _validate_field_set(self, msg):
fields_n = sum(1 for f in (RAW, ENC, HASH) if f in msg)
if fields_n == 0:
self._raise_missed_fields(RAW, ENC, HASH)
if fields_n > 1:
self._raise_invalid_message(
"only one field from {}, {}, {} is expected".format(
RAW, ENC, HASH)
)
def __validate_raw_field(self, raw_field):
raw = self.__decode_raw_field(raw_field)
if not isinstance(raw, dict):
self._raise_invalid_fields(RAW, type(raw),
'should be a dict')
if len(raw) != 1:
self._raise_invalid_fields(RAW, raw,
'should contain one attribute')
if ENDPOINT in raw:
self.__validate_endpoint_ha_field(raw[ENDPOINT])
def __decode_raw_field(self, raw_field):
return json.loads(raw_field)
def __validate_endpoint_ha_field(self, endpoint):
if endpoint is None:
return # remove the attribute, valid case
HA_NAME = 'ha'
ha = endpoint.get(HA_NAME)
if ha is None:
return # remove ha attribute, valid case
if ':' not in ha:
self._raise_invalid_fields(ENDPOINT, endpoint,
"invalid endpoint format "
"ip_address:port")
ip, port = ha.split(':')
if not is_network_ip_address_valid(ip):
self._raise_invalid_fields('ha', ha,
'invalid endpoint address')
if not is_network_port_valid(port):
self._raise_invalid_fields('ha', ha,
'invalid endpoint port')
class ClientGetAttribOperation(ClientAttribOperation):
schema = (
(TXN_TYPE, ConstantField(GET_ATTR)),
(TARGET_NYM, IdentifierField(optional=True)),
(RAW, LimitedLengthStringField(max_length=RAW_FIELD_LIMIT, optional=True)),
(ENC, LimitedLengthStringField(max_length=ENC_FIELD_LIMIT, optional=True)),
(HASH, Sha256HexField(optional=True)),
)
def _validate_message(self, msg):
self._validate_field_set(msg)
import base64
import hashlib
from binascii import hexlify
import base58
from plenum.common.messages.fields import Sha256HexField
validator = Sha256HexField()
msg = b'some message'
def test_sha256_invalid_hex_field():
assert validator.validate(
'') == 'not a valid hash (needs to be in hex too)'
assert validator.validate(1) == "expected types 'str', got 'int'"
def test_sha256_valid_hex_field():
assert validator.validate(hashlib.sha256(msg).hexdigest()) is None
def test_only_sha256_field():
# Any other hashing algo like sha512 or md5 not allowed, only sha256
h512 = hashlib.sha512(msg)
hex_h512 = h512.hexdigest()
assert validator.validate(
hex_h512) == 'not a valid hash (needs to be in hex too)'
hmd5 = hashlib.md5(msg)
hex_hmd5 = hmd5.hexdigest()
assert validator.validate(
