662 lines
19 KiB
Python
662 lines
19 KiB
Python
import json
|
|
from collections import OrderedDict
|
|
from typing import List, Tuple
|
|
from decimal import Decimal
|
|
from binascii import hexlify, unhexlify
|
|
from hashlib import sha256
|
|
|
|
import ecdsa
|
|
from cryptography.hazmat.backends import default_backend
|
|
from cryptography.hazmat.primitives.serialization import load_der_public_key
|
|
from cryptography.hazmat.primitives import hashes
|
|
from cryptography.hazmat.primitives.asymmetric import ec
|
|
from cryptography.hazmat.primitives.asymmetric.utils import Prehashed
|
|
from ecdsa.util import sigencode_der
|
|
|
|
from google.protobuf import json_format # pylint: disable=no-name-in-module
|
|
from google.protobuf.message import DecodeError as DecodeError_pb # pylint: disable=no-name-in-module,import-error
|
|
|
|
from torba.client.constants import COIN
|
|
|
|
from lbrynet.schema.signature import Signature
|
|
from lbrynet.schema.validator import get_validator
|
|
from lbrynet.schema.signer import get_signer
|
|
from lbrynet.schema.constants import CURVE_NAMES, SECP256k1
|
|
from lbrynet.schema.encoding import decode_fields, decode_b64_fields, encode_fields
|
|
from lbrynet.schema.error import DecodeError
|
|
from lbrynet.schema.types.v2.claim_pb2 import Claim as ClaimMessage, Fee as FeeMessage
|
|
from lbrynet.schema.base import b58decode, b58encode
|
|
from lbrynet.schema import compat
|
|
|
|
|
|
class ClaimDict(OrderedDict):
|
|
def __init__(self, claim_dict=None, detached_signature: Signature=None):
|
|
if isinstance(claim_dict, legacy_claim_pb2.Claim):
|
|
raise Exception("To initialize %s with a Claim protobuf use %s.load_protobuf" %
|
|
(self.__class__.__name__, self.__class__.__name__))
|
|
self.detached_signature = detached_signature
|
|
OrderedDict.__init__(self, claim_dict or [])
|
|
|
|
@property
|
|
def protobuf_dict(self):
|
|
"""Claim dictionary using base64 to represent bytes"""
|
|
|
|
return json.loads(json_format.MessageToJson(self.protobuf, True))
|
|
|
|
@property
|
|
def protobuf(self):
|
|
"""Claim message object"""
|
|
|
|
return LegacyClaim.load(self)
|
|
|
|
@property
|
|
def serialized(self):
|
|
"""Serialized Claim protobuf"""
|
|
if self.detached_signature:
|
|
return self.detached_signature.serialized
|
|
return self.protobuf.SerializeToString()
|
|
|
|
@property
|
|
def serialized_no_signature(self):
|
|
"""Serialized Claim protobuf without publisherSignature field"""
|
|
claim = self.protobuf
|
|
claim.ClearField("publisherSignature")
|
|
return ClaimDict.load_protobuf(claim).serialized
|
|
|
|
@property
|
|
def has_signature(self):
|
|
return self.protobuf.HasField("publisherSignature") or (
|
|
self.detached_signature and self.detached_signature.raw_signature
|
|
)
|
|
|
|
@property
|
|
def is_certificate(self):
|
|
claim = self.protobuf
|
|
return CLAIM_TYPE_NAMES[claim.claimType] == "certificate"
|
|
|
|
@property
|
|
def is_stream(self):
|
|
claim = self.protobuf
|
|
return CLAIM_TYPE_NAMES[claim.claimType] == "stream"
|
|
|
|
@property
|
|
def source_hash(self):
|
|
claim = self.protobuf
|
|
if not CLAIM_TYPE_NAMES[claim.claimType] == "stream":
|
|
return None
|
|
return binascii.hexlify(claim.stream.source.source)
|
|
|
|
@property
|
|
def has_fee(self):
|
|
claim = self.protobuf
|
|
if not CLAIM_TYPE_NAMES[claim.claimType] == "stream":
|
|
return None
|
|
if claim.stream.metadata.HasField("fee"):
|
|
return True
|
|
return False
|
|
|
|
@property
|
|
def source_fee(self):
|
|
claim = self.protobuf
|
|
if not CLAIM_TYPE_NAMES[claim.claimType] == "stream":
|
|
return None
|
|
if claim.stream.metadata.HasField("fee"):
|
|
return Fee.load_protobuf(claim.stream.metadata.fee)
|
|
return None
|
|
|
|
@property
|
|
def certificate_id(self) -> str:
|
|
if self.protobuf.HasField("publisherSignature"):
|
|
return binascii.hexlify(self.protobuf.publisherSignature.certificateId).decode()
|
|
if self.detached_signature and self.detached_signature.certificate_id:
|
|
return binascii.hexlify(self.detached_signature.certificate_id).decode()
|
|
|
|
@property
|
|
def signature(self):
|
|
if not self.has_signature:
|
|
return None
|
|
return binascii.hexlify(self.protobuf.publisherSignature.signature)
|
|
|
|
@property
|
|
def protobuf_len(self):
|
|
"""Length of serialized string"""
|
|
|
|
return self.protobuf.ByteSize()
|
|
|
|
@property
|
|
def json_len(self):
|
|
"""Length of json encoded string"""
|
|
|
|
return len(json.dumps(self.claim_dict))
|
|
|
|
@property
|
|
def claim_dict(self):
|
|
"""Claim dictionary with bytes represented as hex and base58"""
|
|
|
|
return dict(encode_fields(self, self.detached_signature))
|
|
|
|
@classmethod
|
|
def load_protobuf_dict(cls, protobuf_dict, detached_signature=None):
|
|
"""
|
|
Load a ClaimDict from a dictionary with base64 encoded bytes
|
|
(as returned by the protobuf json formatter)
|
|
"""
|
|
|
|
return cls(decode_b64_fields(protobuf_dict), detached_signature=detached_signature)
|
|
|
|
@classmethod
|
|
def load_protobuf(cls, protobuf_claim, detached_signature=None):
|
|
"""Load ClaimDict from a protobuf Claim message"""
|
|
return cls.load_protobuf_dict(json.loads(json_format.MessageToJson(protobuf_claim, True)), detached_signature)
|
|
|
|
@classmethod
|
|
def load_dict(cls, claim_dict):
|
|
"""Load ClaimDict from a dictionary with hex and base58 encoded bytes"""
|
|
try:
|
|
claim_dict, detached_signature = decode_fields(claim_dict)
|
|
return cls.load_protobuf(cls(claim_dict).protobuf, detached_signature)
|
|
except json_format.ParseError as err:
|
|
raise DecodeError(str(err))
|
|
|
|
@classmethod
|
|
def deserialize(cls, serialized):
|
|
"""Load a ClaimDict from a serialized protobuf string"""
|
|
detached_signature = Signature.flagged_parse(serialized)
|
|
|
|
temp_claim = legacy_claim_pb2.Claim()
|
|
try:
|
|
temp_claim.ParseFromString(detached_signature.payload)
|
|
except DecodeError_pb:
|
|
raise DecodeError(DecodeError_pb)
|
|
return cls.load_protobuf(temp_claim, detached_signature=detached_signature)
|
|
|
|
@classmethod
|
|
def generate_certificate(cls, private_key, curve=SECP256k1):
|
|
signer = get_signer(curve).load_pem(private_key)
|
|
return cls.load_protobuf(signer.certificate)
|
|
|
|
def sign(self, private_key, claim_address, cert_claim_id, curve=SECP256k1, name=None, force_detached=False):
|
|
signer = get_signer(curve).load_pem(private_key)
|
|
signed, signature = signer.sign_stream_claim(self, claim_address, cert_claim_id, name, force_detached)
|
|
return ClaimDict.load_protobuf(signed, signature)
|
|
|
|
def validate_signature(self, claim_address, certificate, name=None):
|
|
if isinstance(certificate, ClaimDict):
|
|
certificate = certificate.protobuf
|
|
curve = CURVE_NAMES[certificate.certificate.keyType]
|
|
validator = get_validator(curve).load_from_certificate(certificate, self.certificate_id)
|
|
return validator.validate_claim_signature(self, claim_address, name)
|
|
|
|
def validate_private_key(self, private_key, certificate_id):
|
|
certificate = self.protobuf
|
|
if CLAIM_TYPE_NAMES[certificate.claimType] != "certificate":
|
|
return
|
|
curve = CURVE_NAMES[certificate.certificate.keyType]
|
|
validator = get_validator(curve).load_from_certificate(certificate, certificate_id)
|
|
signing_key = validator.signing_key_from_pem(private_key)
|
|
return validator.validate_private_key(signing_key)
|
|
|
|
def get_validator(self, certificate_id):
|
|
"""
|
|
Get a lbrynet.schema.validator.Validator object for a certificate claim
|
|
|
|
:param certificate_id: claim id of this certificate claim
|
|
:return: None or lbrynet.schema.validator.Validator object
|
|
"""
|
|
|
|
claim = self.protobuf
|
|
if CLAIM_TYPE_NAMES[claim.claimType] != "certificate":
|
|
return
|
|
curve = CURVE_NAMES[claim.certificate.keyType]
|
|
return get_validator(curve).load_from_certificate(claim, certificate_id)
|
|
|
|
|
|
class Claim:
|
|
|
|
__slots__ = '_claim', 'signature', 'certificate_id', 'signature_type', 'unsigned_payload'
|
|
|
|
def __init__(self, claim_message=None):
|
|
self._claim = claim_message or ClaimMessage()
|
|
self.signature = None
|
|
self.signature_type = 'SECP256k1'
|
|
self.certificate_id = None
|
|
self.unsigned_payload = None
|
|
|
|
@property
|
|
def is_undetermined(self):
|
|
return self._claim.WhichOneof('type') is None
|
|
|
|
@property
|
|
def is_stream(self):
|
|
return self._claim.WhichOneof('type') == 'stream'
|
|
|
|
@property
|
|
def is_channel(self):
|
|
return self._claim.WhichOneof('type') == 'channel'
|
|
|
|
@property
|
|
def is_signed(self):
|
|
return self.signature is not None
|
|
|
|
def is_signed_by(self, channel: 'Channel', claim_address):
|
|
if self.unsigned_payload:
|
|
digest = sha256(b''.join([
|
|
claim_address, self.unsigned_payload, self.certificate_id
|
|
])).digest()
|
|
public_key = load_der_public_key(channel.public_key_bytes, default_backend())
|
|
hash = hashes.SHA256()
|
|
signature = hexlify(self.signature)
|
|
r = int(signature[:int(len(signature)/2)], 16)
|
|
s = int(signature[int(len(signature)/2):], 16)
|
|
encoded_sig = sigencode_der(r, s, len(signature)*4)
|
|
public_key.verify(encoded_sig, digest, ec.ECDSA(Prehashed(hash)))
|
|
return True
|
|
else:
|
|
digest = sha256(b''.join([
|
|
self.certificate_id.encode(),
|
|
first_input_txid_nout.encode(),
|
|
self.to_bytes()
|
|
])).digest()
|
|
|
|
def sign(self, certificate_id: str, private_key_text: str, first_input_txid_nout):
|
|
digest = sha256(b''.join([
|
|
certificate_id.encode(),
|
|
first_input_txid_nout.encode(),
|
|
self.to_bytes()
|
|
])).digest()
|
|
private_key = ecdsa.SigningKey.from_pem(private_key_text, hashfunc="sha256")
|
|
self.signature = private_key.sign_digest_deterministic(digest, hashfunc="sha256")
|
|
self.certificate_id = certificate_id
|
|
|
|
@property
|
|
def stream_message(self):
|
|
if self.is_undetermined:
|
|
self._claim.stream.SetInParent()
|
|
if not self.is_stream:
|
|
raise ValueError('Claim is not a stream.')
|
|
return self._claim.stream
|
|
|
|
@property
|
|
def stream(self) -> 'Stream':
|
|
return Stream(self)
|
|
|
|
@property
|
|
def channel_message(self):
|
|
if self.is_undetermined:
|
|
self._claim.channel.SetInParent()
|
|
if not self.is_channel:
|
|
raise ValueError('Claim is not a channel.')
|
|
return self._claim.channel
|
|
|
|
@property
|
|
def channel(self) -> 'Channel':
|
|
return Channel(self)
|
|
|
|
def to_bytes(self) -> bytes:
|
|
return self._claim.SerializeToString()
|
|
|
|
@classmethod
|
|
def from_bytes(cls, data: bytes) -> 'Claim':
|
|
claim = ClaimMessage()
|
|
if data[0] == 0:
|
|
claim.ParseFromString(data[1:])
|
|
return cls(claim)
|
|
elif data[0] == 1:
|
|
claim.ParseFromString(data[85:])
|
|
return cls(claim).from_message(payload[1:21], payload[21:85])
|
|
elif data[0] == ord('{'):
|
|
return compat.from_old_json_schema(cls(claim), data)
|
|
else:
|
|
return compat.from_types_v1(cls(claim), data)
|
|
|
|
|
|
class Video:
|
|
|
|
__slots__ = '_video',
|
|
|
|
def __init__(self, video_message):
|
|
self._video = video_message
|
|
|
|
@property
|
|
def width(self) -> int:
|
|
return self._video.width
|
|
|
|
@width.setter
|
|
def width(self, width: int):
|
|
self._video.width = width
|
|
|
|
@property
|
|
def height(self) -> int:
|
|
return self._video.height
|
|
|
|
@height.setter
|
|
def height(self, height: int):
|
|
self._video.height = height
|
|
|
|
@property
|
|
def dimensions(self) -> Tuple[int, int]:
|
|
return self.width, self.height
|
|
|
|
@dimensions.setter
|
|
def dimensions(self, dimensions: Tuple[int, int]):
|
|
self._video.width, self._video.height = dimensions
|
|
|
|
|
|
class File:
|
|
|
|
__slots__ = '_file',
|
|
|
|
def __init__(self, file_message):
|
|
self._file = file_message
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
return self._file.name
|
|
|
|
@name.setter
|
|
def name(self, name: str):
|
|
self._file.name = name
|
|
|
|
@property
|
|
def size(self) -> int:
|
|
return self._file.size
|
|
|
|
@size.setter
|
|
def size(self, size: int):
|
|
self._file.size = size
|
|
|
|
|
|
class Fee:
|
|
|
|
__slots__ = '_fee',
|
|
|
|
def __init__(self, fee_message):
|
|
self._fee = fee_message
|
|
|
|
@property
|
|
def currency(self) -> str:
|
|
return FeeMessage.Currency.Name(self._fee.currency)
|
|
|
|
@property
|
|
def address(self) -> str:
|
|
return b58encode(self._fee.address).decode()
|
|
|
|
@address.setter
|
|
def address(self, address: str):
|
|
self._fee.address = b58decode(address)
|
|
|
|
@property
|
|
def address_bytes(self) -> bytes:
|
|
return self._fee.address
|
|
|
|
@address_bytes.setter
|
|
def address_bytes(self, address: bytes):
|
|
self._fee.address = address
|
|
|
|
@property
|
|
def amount(self) -> Decimal:
|
|
if self.currency == 'LBC':
|
|
return self.lbc
|
|
if self.currency == 'USD':
|
|
return self.usd
|
|
|
|
DEWIES = Decimal(COIN)
|
|
|
|
@property
|
|
def lbc(self) -> Decimal:
|
|
if self._fee.currency != FeeMessage.LBC:
|
|
raise ValueError('LBC can only be returned for LBC fees.')
|
|
return Decimal(self._fee.amount / self.DEWIES)
|
|
|
|
@lbc.setter
|
|
def lbc(self, amount: Decimal):
|
|
self.dewies = int(amount * self.DEWIES)
|
|
|
|
@property
|
|
def dewies(self) -> int:
|
|
if self._fee.currency != FeeMessage.LBC:
|
|
raise ValueError('Dewies can only be returned for LBC fees.')
|
|
return self._fee.amount
|
|
|
|
@dewies.setter
|
|
def dewies(self, amount: int):
|
|
self._fee.amount = amount
|
|
self._fee.currency = FeeMessage.LBC
|
|
|
|
PENNIES = Decimal(100.0)
|
|
|
|
@property
|
|
def usd(self) -> Decimal:
|
|
if self._fee.currency != FeeMessage.USD:
|
|
raise ValueError('USD can only be returned for USD fees.')
|
|
return Decimal(self._fee.amount / self.PENNIES)
|
|
|
|
@usd.setter
|
|
def usd(self, amount: Decimal):
|
|
self.pennies = int(amount * self.PENNIES)
|
|
|
|
@property
|
|
def pennies(self) -> int:
|
|
if self._fee.currency != FeeMessage.USD:
|
|
raise ValueError('Pennies can only be returned for USD fees.')
|
|
return self._fee.amount
|
|
|
|
@pennies.setter
|
|
def pennies(self, amount: int):
|
|
self._fee.amount = amount
|
|
self._fee.currency = FeeMessage.USD
|
|
|
|
|
|
class Channel:
|
|
|
|
__slots__ = '_claim', '_channel'
|
|
|
|
def __init__(self, claim: Claim = None):
|
|
self._claim = claim or Claim()
|
|
self._channel = self._claim.channel_message
|
|
|
|
@property
|
|
def claim(self) -> Claim:
|
|
return self._claim
|
|
|
|
@property
|
|
def tags(self) -> List:
|
|
return self._channel.tags
|
|
|
|
@property
|
|
def public_key(self) -> str:
|
|
return hexlify(self._channel.public_key).decode()
|
|
|
|
@public_key.setter
|
|
def public_key(self, sd_public_key: str):
|
|
self._channel.public_key = unhexlify(sd_public_key.encode())
|
|
|
|
@property
|
|
def public_key_bytes(self) -> bytes:
|
|
return self._channel.public_key
|
|
|
|
@public_key_bytes.setter
|
|
def public_key_bytes(self, public_key: bytes):
|
|
self._channel.public_key = public_key
|
|
|
|
@property
|
|
def language(self) -> str:
|
|
return self._channel.language
|
|
|
|
@language.setter
|
|
def language(self, language: str):
|
|
self._channel.language = language
|
|
|
|
@property
|
|
def title(self) -> str:
|
|
return self._channel.title
|
|
|
|
@title.setter
|
|
def title(self, title: str):
|
|
self._channel.title = title
|
|
|
|
@property
|
|
def description(self) -> str:
|
|
return self._channel.description
|
|
|
|
@description.setter
|
|
def description(self, description: str):
|
|
self._channel.description = description
|
|
|
|
@property
|
|
def contact_email(self) -> str:
|
|
return self._channel.contact_email
|
|
|
|
@contact_email.setter
|
|
def contact_email(self, contact_email: str):
|
|
self._channel.contact_email = contact_email
|
|
|
|
@property
|
|
def homepage_url(self) -> str:
|
|
return self._channel.homepage_url
|
|
|
|
@homepage_url.setter
|
|
def homepage_url(self, homepage_url: str):
|
|
self._channel.homepage_url = homepage_url
|
|
|
|
@property
|
|
def thumbnail_url(self) -> str:
|
|
return self._channel.thumbnail_url
|
|
|
|
@thumbnail_url.setter
|
|
def thumbnail_url(self, thumbnail_url: str):
|
|
self._channel.thumbnail_url = thumbnail_url
|
|
|
|
@property
|
|
def cover_url(self) -> str:
|
|
return self._channel.cover_url
|
|
|
|
@cover_url.setter
|
|
def cover_url(self, cover_url: str):
|
|
self._channel.cover_url = cover_url
|
|
|
|
|
|
class Stream:
|
|
|
|
__slots__ = '_claim', '_stream'
|
|
|
|
def __init__(self, claim: Claim = None):
|
|
self._claim = claim or Claim()
|
|
self._stream = self._claim.stream_message
|
|
|
|
@property
|
|
def claim(self) -> Claim:
|
|
return self._claim
|
|
|
|
@property
|
|
def video(self) -> Video:
|
|
return Video(self._stream.video)
|
|
|
|
@property
|
|
def file(self) -> File:
|
|
return File(self._stream.file)
|
|
|
|
@property
|
|
def fee(self) -> Fee:
|
|
return Fee(self._stream.fee)
|
|
|
|
@property
|
|
def tags(self) -> List:
|
|
return self._stream.tags
|
|
|
|
@property
|
|
def hash(self) -> str:
|
|
return hexlify(self._stream.hash).decode()
|
|
|
|
@hash.setter
|
|
def hash(self, sd_hash: str):
|
|
self._stream.hash = unhexlify(sd_hash.encode())
|
|
|
|
@property
|
|
def hash_bytes(self) -> bytes:
|
|
return self._stream.hash
|
|
|
|
@hash_bytes.setter
|
|
def hash_bytes(self, hash: bytes):
|
|
self._stream.hash = hash
|
|
|
|
@property
|
|
def language(self) -> str:
|
|
return self._stream.language
|
|
|
|
@language.setter
|
|
def language(self, language: str):
|
|
self._stream.language = language
|
|
|
|
@property
|
|
def title(self) -> str:
|
|
return self._stream.title
|
|
|
|
@title.setter
|
|
def title(self, title: str):
|
|
self._stream.title = title
|
|
|
|
@property
|
|
def author(self) -> str:
|
|
return self._stream.author
|
|
|
|
@author.setter
|
|
def author(self, author: str):
|
|
self._stream.author = author
|
|
|
|
@property
|
|
def description(self) -> str:
|
|
return self._stream.description
|
|
|
|
@description.setter
|
|
def description(self, description: str):
|
|
self._stream.description = description
|
|
|
|
@property
|
|
def media_type(self) -> str:
|
|
return self._stream.media_type
|
|
|
|
@media_type.setter
|
|
def media_type(self, media_type: str):
|
|
self._stream.media_type = media_type
|
|
|
|
@property
|
|
def license(self) -> str:
|
|
return self._stream.license
|
|
|
|
@license.setter
|
|
def license(self, license: str):
|
|
self._stream.license = license
|
|
|
|
@property
|
|
def license_url(self) -> str:
|
|
return self._stream.license_url
|
|
|
|
@license_url.setter
|
|
def license_url(self, license_url: str):
|
|
self._stream.license_url = license_url
|
|
|
|
@property
|
|
def thumbnail_url(self) -> str:
|
|
return self._stream.thumbnail_url
|
|
|
|
@thumbnail_url.setter
|
|
def thumbnail_url(self, thumbnail_url: str):
|
|
self._stream.thumbnail_url = thumbnail_url
|
|
|
|
@property
|
|
def duration(self) -> int:
|
|
return self._stream.duration
|
|
|
|
@duration.setter
|
|
def duration(self, duration: int):
|
|
self._stream.duration = duration
|
|
|
|
@property
|
|
def release_time(self) -> int:
|
|
return self._stream.release_time
|
|
|
|
@release_time.setter
|
|
def release_time(self, release_time: int):
|
|
self._stream.release_time = release_time
|