86 lines
3 KiB
Python
86 lines
3 KiB
Python
import binascii
|
|
import logging
|
|
import hashlib
|
|
import json
|
|
import sqlite3
|
|
import asyncio
|
|
import aiohttp
|
|
|
|
from server.validation import is_signature_valid, get_encoded_signature
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
async def request_lbrynet(url, method, **params):
|
|
body = {'method': method, 'params': {**params}}
|
|
async with aiohttp.request('POST', url, json=body) as req:
|
|
try:
|
|
resp = await req.json()
|
|
finally:
|
|
if 'result' in resp:
|
|
return resp['result']
|
|
|
|
|
|
def get_comments_with_signatures(_conn: sqlite3.Connection) -> list:
|
|
with _conn:
|
|
curs = _conn.execute("SELECT * FROM COMMENTS_ON_CLAIMS WHERE signature IS NOT NULL")
|
|
return [dict(r) for r in curs.fetchall()]
|
|
|
|
|
|
def is_valid_signature(pubkey, channel_id, signature, signing_ts, data: str) -> bool:
|
|
try:
|
|
if pubkey:
|
|
claim_hash = binascii.unhexlify(channel_id.encode())[::-1]
|
|
injest = b''.join((signing_ts.encode(), claim_hash, data.encode()))
|
|
return is_signature_valid(
|
|
encoded_signature=get_encoded_signature(signature),
|
|
signature_digest=hashlib.sha256(injest).digest(),
|
|
public_key_bytes=binascii.unhexlify(pubkey.encode())
|
|
)
|
|
else:
|
|
raise Exception("Pubkey is null")
|
|
except Exception as e:
|
|
print(e)
|
|
return False
|
|
|
|
|
|
async def get_channel_pubkeys(comments: list):
|
|
urls = {c['channel_url'] for c in comments}
|
|
claims = await request_lbrynet('http://localhost:5279', 'resolve', urls=list(urls))
|
|
cids = {c['channel_id']: None for c in comments}
|
|
error_claims = []
|
|
for url, claim in claims.items():
|
|
if 'error' not in claim:
|
|
cids.update({
|
|
claim['claim_id']: claim['value']['public_key']
|
|
})
|
|
else:
|
|
error_claims.append({url: claim})
|
|
return cids, error_claims
|
|
|
|
|
|
def count_valid_signatures(cmts: list, chan_pubkeys: dict):
|
|
invalid_comments = []
|
|
for c in cmts:
|
|
pubkey = chan_pubkeys.get(c['channel_id'])
|
|
if not is_valid_signature(pubkey, c['channel_id'], c['signature'], c['signing_ts'], c['comment']):
|
|
invalid_comments.append(c)
|
|
return len(cmts) - len(invalid_comments), invalid_comments
|
|
|
|
|
|
if __name__ == '__main__':
|
|
conn = sqlite3.connect('database/default.db')
|
|
conn.row_factory = sqlite3.Row
|
|
comments = get_comments_with_signatures(conn)
|
|
loop = asyncio.get_event_loop()
|
|
chan_keys, errored = loop.run_until_complete(get_channel_pubkeys(comments))
|
|
valid_sigs, invalid_coms = count_valid_signatures(comments, chan_keys)
|
|
print(f'Total Signatures: {len(comments)}\nValid Signatures: {valid_sigs}')
|
|
print(f'Invalid Signatures: {len(comments) - valid_sigs}')
|
|
print(f'Percent Valid: {round(valid_sigs/len(comments)*100, 3)}%')
|
|
print(f'# Unresolving claims: {len(errored)}')
|
|
print(f'Num invalid comments: {len(invalid_coms)}')
|
|
print(json.dumps(errored, indent=2))
|
|
json.dump(invalid_coms, 'invalid_coms.json', indent=2)
|
|
|