arno
/
trezor-firmware
mirror of https://github.com/trezor/trezor-firmware.git
1
0
Fork 0
Code Issues Releases Wiki Activity

chore(xmr): delete unused code

Browse Source 
[no changelog]
pull/2584/head
grdddj 2 years ago committed by Martin Milata
parent 26711857e8
commit fac4e2f157
12 changed files with 4 additions and 322 deletions
Show Stats Download Patch File Download Diff File

23
core/src/apps/monero/signing/offloading_keys.py
Unescape View File

@ -3,7 +3,7 @@ from typing import TYPE_CHECKING
from trezor import utils
from apps.monero.xmr import crypto, crypto_helpers
from apps.monero.xmr import crypto_helpers
if TYPE_CHECKING:
from trezor.messages import (
@ -81,13 +81,6 @@ def hmac_key_txout(key_hmac: bytes, idx: int) -> bytes:
return _build_key(key_hmac, b"txout", idx)
def hmac_key_txout_asig(key_hmac: bytes, idx: int) -> bytes:
"""
rsig[i] hmac key. Range signature HMAC
"""
return _build_key(key_hmac, b"txout-asig", idx)
def enc_key_txin_alpha(key_enc: bytes, idx: int) -> bytes:
"""
Chacha20Poly1305 encryption key for alpha[i] used in Pedersen commitment in pseudo_outs[i]
@ -102,13 +95,6 @@ def enc_key_spend(key_enc: bytes, idx: int) -> bytes:
return _build_key(key_enc, b"txin-spend", idx)
def enc_key_cout(key_enc: bytes, idx: int | None = None) -> bytes:
"""
Chacha20Poly1305 encryption key for multisig C values from MLASG.
"""
return _build_key(key_enc, b"cout", idx)
def key_signature(master: bytes, idx: int, is_iv: bool = False) -> bytes:
"""
Generates signature offloading related offloading keys
@ -116,13 +102,6 @@ def key_signature(master: bytes, idx: int, is_iv: bool = False) -> bytes:
return _build_key(master, b"sig-iv" if is_iv else b"sig-key", idx)
def det_comm_masks(key_enc: bytes, idx: int) -> crypto.Scalar:
"""
Deterministic output commitment masks
"""
return crypto_helpers.decodeint(_build_key(key_enc, b"out-mask", idx))
def gen_hmac_vini(
key: bytes, src_entr: MoneroTransactionSourceEntry, vini_bin: bytes, idx: int
) -> bytes:

25
core/src/apps/monero/xmr/addresses.py
Unescape View File

@ -1,9 +1,6 @@
from typing import TYPE_CHECKING
from trezor.crypto import monero as tcry
from trezor.enums import MoneroNetworkType
from apps.monero.xmr.networks import net_version
if TYPE_CHECKING:
from trezor.messages import MoneroAccountPublicAddress
@ -29,28 +26,6 @@ def encode_addr(
return tcry.xmr_base58_addr_encode_check(ord(version), bytes(buf))
def decode_addr(addr: bytes) -> tuple[int, bytes, bytes]:
"""
Given address, get version and public spend and view keys.
"""
d, version = tcry.xmr_base58_addr_decode_check(bytes(addr))
pub_spend_key = d[0:32]
pub_view_key = d[32:64]
return version, pub_spend_key, pub_view_key
def public_addr_encode(
pub_addr: MoneroAccountPublicAddress,
is_sub: bool = False,
net: MoneroNetworkType = MoneroNetworkType.MAINNET,
) -> str:
"""
Encodes public address to Monero address
"""
net_ver = net_version(net, is_sub)
return encode_addr(net_ver, pub_addr.spend_public_key, pub_addr.view_public_key)
def classify_subaddresses(
tx_dests: list[MoneroTransactionDestinationEntry],
change_addr: MoneroAccountPublicAddress,

138
core/src/apps/monero/xmr/bulletproof.py
Unescape View File

@ -85,11 +85,6 @@ def _copy_key(dst: bytearray | None, src: bytes) -> bytearray:
return dst
def _init_key(val: bytes, dst: bytearray | None = None) -> bytearray:
dst = _ensure_dst_key(dst)
return _copy_key(dst, val)
def _load_scalar(dst: crypto.Scalar | None, a: ScalarDst) -> crypto.Scalar:
return (
crypto.sc_copy(dst, a)
@ -139,14 +134,6 @@ def _scalarmult8(dst: bytearray | None, P, tmp_pt: crypto.Point = _tmp_pt_1):
return dst
def _scalarmultH(dst: bytearray, x: bytes) -> bytearray:
dst = _ensure_dst_key(dst)
crypto.decodeint_into(_tmp_sc_1, x)
crypto.scalarmult_into(_tmp_pt_1, _XMR_HP, _tmp_sc_1)
crypto.encodepoint_into(dst, _tmp_pt_1)
return dst
def _scalarmult_base(dst: bytearray, x: bytes) -> bytearray:
dst = _ensure_dst_key(dst)
crypto.decodeint_into_noreduce(_tmp_sc_1, x)
@ -199,15 +186,6 @@ def _sc_mul(dst: bytearray | None, a: bytes, b: bytes | crypto.Scalar) -> bytear
return dst
def _sc_mul8(dst: bytearray | None, a: bytes) -> bytearray:
dst = _ensure_dst_key(dst)
crypto.decodeint_into_noreduce(_tmp_sc_1, a)
crypto.decodeint_into_noreduce(_tmp_sc_2, _EIGHT)
crypto.sc_mul_into(_tmp_sc_3, _tmp_sc_1, _tmp_sc_2)
crypto.encodeint_into(dst, _tmp_sc_3)
return dst
def _sc_muladd(
dst: ScalarDst | None,
a: bytes | crypto.Scalar,
@ -234,16 +212,6 @@ def _sc_muladd(
return dst
def _sc_mulsub(dst: bytearray | None, a: bytes, b: bytes, c: bytes) -> bytearray:
dst = _ensure_dst_key(dst)
crypto.decodeint_into_noreduce(_tmp_sc_1, a)
crypto.decodeint_into_noreduce(_tmp_sc_2, b)
crypto.decodeint_into_noreduce(_tmp_sc_3, c)
crypto.sc_mulsub_into(_tmp_sc_4, _tmp_sc_1, _tmp_sc_2, _tmp_sc_3)
crypto.encodeint_into(dst, _tmp_sc_4)
return dst
def _add_keys(dst: bytearray | None, A: bytes, B: bytes) -> bytearray:
dst = _ensure_dst_key(dst)
crypto.decodepoint_into(_tmp_pt_1, A)
@ -253,15 +221,6 @@ def _add_keys(dst: bytearray | None, A: bytes, B: bytes) -> bytearray:
return dst
def _sub_keys(dst: bytearray | None, A: bytes, B: bytes) -> bytearray:
dst = _ensure_dst_key(dst)
crypto.decodepoint_into(_tmp_pt_1, A)
crypto.decodepoint_into(_tmp_pt_2, B)
crypto.point_sub_into(_tmp_pt_3, _tmp_pt_1, _tmp_pt_2)
crypto.encodepoint_into(dst, _tmp_pt_3)
return dst
def _add_keys2(dst: bytearray | None, a: bytes, b: bytes, B: bytes) -> bytearray:
dst = _ensure_dst_key(dst)
crypto.decodeint_into_noreduce(_tmp_sc_1, a)
@ -447,11 +406,6 @@ class KeyVBase(Generic[T]):
def read(self, idx: int, buff: bytes, offset: int = 0) -> bytes:
raise NotImplementedError
def slice(self, res, start: int, stop: int):
for i in range(start, stop):
res[i - start] = self[i]
return res
def slice_view(self, start: int, stop: int) -> "KeyVSliced":
return KeyVSliced(self, start, stop)
@ -626,32 +580,6 @@ class KeyV(KeyVBaseType[T]):
self.size = nsize
self._set_mv()
def realloc_init_from(self, nsize, src, offset: int = 0, collect: int = False):
if not isinstance(src, KeyV):
raise ValueError("KeyV supported only")
self.realloc(nsize, collect)
if not self.chunked and not src.chunked:
assert isinstance(self.d, bytearray)
assert isinstance(src.d, (bytes, bytearray))
memcpy(self.d, 0, src.d, offset << 5, nsize << 5)
elif self.chunked and not src.chunked or self.chunked and src.chunked:
for i in range(nsize):
self.read(i, src.to(i + offset))
elif not self.chunked and src.chunked:
assert isinstance(self.d, bytearray)
assert isinstance(src.d, list)
for i in range(nsize >> _CHBITS):
memcpy(
self.d,
i << 11,
src.d[i + (offset >> _CHBITS)],
(offset & (_CHSIZE - 1)) << 5 if i == 0 else 0,
nsize << 5 if i <= nsize >> _CHBITS else (nsize & _CHSIZE) << 5,
)
class KeyVEval(KeyVBase):
"""
@ -690,40 +618,6 @@ class KeyVEval(KeyVBase):
return buff if buff else self.buff
class KeyVSized(KeyVBase):
"""
Resized vector, wrapping possibly larger vector
(e.g., precomputed, but has to have exact size for further computations)
"""
__slots__ = ("current_idx", "size", "wrapped")
def __init__(self, wrapped, new_size):
super().__init__(new_size)
self.wrapped = wrapped
def __getitem__(self, item):
return self.wrapped[self.idxize(item)]
def __setitem__(self, key, value):
self.wrapped[self.idxize(key)] = value
class KeyVConst(KeyVBase):
__slots__ = ("current_idx", "size", "elem")
def __init__(self, size, elem, copy=True):
super().__init__(size)
self.elem = _init_key(elem) if copy else elem
def __getitem__(self, item):
return self.elem
def to(self, idx: int, buff: bytearray, offset: int = 0):
memcpy(buff, offset, self.elem, 0, 32)
return buff if buff else self.elem
class KeyVPrecomp(KeyVBase):
"""
Vector with possibly large size and some precomputed prefix.
@ -1197,32 +1091,6 @@ def _hadamard_fold(v, a, b, into=None, into_offset: int = 0, vR=None, vRoff=0):
return into
def _cross_inner_product(l0, r0, l1, r1):
"""
t1 = l0 . r1 + l1 . r0
t2 = l1 . r1
"""
sc_t1 = crypto.Scalar()
sc_t2 = crypto.Scalar()
tl = crypto.Scalar()
tr = crypto.Scalar()
for i in range(len(l0)):
crypto.decodeint_into_noreduce(tl, l0.to(i))
crypto.decodeint_into_noreduce(tr, r1.to(i))
crypto.sc_muladd_into(sc_t1, tl, tr, sc_t1)
crypto.decodeint_into_noreduce(tl, l1.to(i))
crypto.sc_muladd_into(sc_t2, tl, tr, sc_t2)
crypto.decodeint_into_noreduce(tr, r0.to(i))
crypto.sc_muladd_into(sc_t1, tl, tr, sc_t1)
_gc_iter(i)
return crypto_helpers.encodeint(sc_t1), crypto_helpers.encodeint(sc_t2)
def _hash_cache_mash(dst, hash_cache, *args):
dst = _ensure_dst_key(dst)
ctx = crypto_helpers.get_keccak()
@ -1280,9 +1148,6 @@ class MultiExpSequential:
def add_pair(self, scalar, point) -> None:
self._acc(scalar, point)
def add_scalar(self, scalar) -> None:
self._acc(scalar, self.get_point(self.current_idx))
def add_scalar_idx(self, scalar, idx: int) -> None:
self._acc(scalar, self.get_point(idx))
@ -1414,9 +1279,6 @@ class BulletProofPlusBuilder:
size, self.Hprec, lambda i, d: _get_exponent_plus(d, _XMR_H, i * 2)
)
def vector_exponent(self, a, b, dst=None, a_raw=None, b_raw=None):
return _vector_exponent_custom(self.Gprec, self.Hprec, a, b, dst, a_raw, b_raw)
def prove(
self, sv: list[crypto.Scalar], gamma: list[crypto.Scalar]
) -> BulletproofPlus:

2
core/src/apps/monero/xmr/clsag.py
Unescape View File

@ -54,8 +54,6 @@ if TYPE_CHECKING:
from .serialize_messages.tx_ct_key import CtKey
from trezor.messages import MoneroRctKeyPublic
KeyM = list[list[bytes]]
T = TypeVar("T")
def list_of_type(lst: list[Any], typ: type[T]) -> TypeGuard[list[T]]:

37
core/src/apps/monero/xmr/crypto_helpers.py
Unescape View File

@ -119,43 +119,6 @@ def get_subaddress_secret_key(
return tcry.xmr_get_subaddress_secret_key(None, major, minor, secret_key)
def generate_signature(
data: bytes, priv: tcry.Scalar
) -> tuple[tcry.Scalar, tcry.Scalar, tcry.Point]:
"""
Generate EC signature
crypto_ops::generate_signature(const hash &prefix_hash, const public_key &pub, const secret_key &sec, signature &sig)
"""
pub = tcry.scalarmult_base_into(None, priv)
k = tcry.random_scalar()
comm = tcry.scalarmult_base_into(None, k)
buff = data + encodepoint(pub) + encodepoint(comm)
c = tcry.hash_to_scalar_into(None, buff)
r = tcry.sc_mulsub_into(None, priv, c, k)
return c, r, pub
def check_signature(
data: bytes, c: tcry.Scalar, r: tcry.Scalar, pub: tcry.Point
) -> bool:
"""
EC signature verification
"""
tcry.ge25519_check(pub)
if tcry.sc_check(c) != 0 or tcry.sc_check(r) != 0:
raise ValueError("Signature error")
tmp2 = tcry.point_add_into(
None, tcry.scalarmult_into(None, pub, c), tcry.scalarmult_base_into(None, r)
)
buff = data + encodepoint(pub) + encodepoint(tmp2)
tmp_c = tcry.hash_to_scalar_into(None, buff)
res = tcry.sc_sub_into(None, tmp_c, c)
return tcry.sc_iszero(res)
def xor8(buff: bytearray, key: bytes) -> bytes:
for i in range(8):
buff[i] ^= key[i]

10
core/src/apps/monero/xmr/serialize/__init__.py
Unescape View File

@ -1,4 +1,3 @@
import gc
from typing import TYPE_CHECKING
if TYPE_CHECKING:
@ -28,12 +27,3 @@ def dump_msg(
msg_type.dump(writer, msg)
return writer.get_buffer()
def dump_msg_gc(
msg: MessageType, preallocate: int | None = None, prefix: bytes | None = None
) -> bytes:
buf = dump_msg(msg, preallocate, prefix)
del msg
gc.collect()
return buf

23
core/src/apps/monero/xmr/serialize/base_types.py
Unescape View File

@ -1,11 +1,6 @@
from typing import TYPE_CHECKING
from apps.monero.xmr.serialize.int_serialize import (
dump_uint,
dump_uvarint,
load_uint,
load_uvarint,
)
from apps.monero.xmr.serialize.int_serialize import dump_uvarint, load_uvarint
if TYPE_CHECKING:
from typing import Protocol, TypeVar, Union
@ -50,19 +45,3 @@ class UVarintType:
@staticmethod
def dump(writer: Writer, n: int) -> None:
return dump_uvarint(writer, n)
class IntType:
WIDTH = 0
@classmethod
def load(cls, reader: Reader) -> int:
return load_uint(reader, cls.WIDTH)
@classmethod
def dump(cls, writer: Writer, n: int):
return dump_uint(writer, n, cls.WIDTH)
class UInt8(IntType):
WIDTH = 1

40
core/src/apps/monero/xmr/serialize/int_serialize.py
Unescape View File

@ -6,20 +6,6 @@ if TYPE_CHECKING:
_UINT_BUFFER = bytearray(1)
def load_uint(reader: Reader, width: int) -> int:
"""
Constant-width integer serialization
"""
buffer = _UINT_BUFFER
result = 0
shift = 0
for _ in range(width):
reader.readinto(buffer)
result += buffer[0] << shift
shift += 8
return result
def dump_uint(writer: Writer, n: int, width: int) -> None:
"""
Constant-width integer serialization
@ -42,20 +28,6 @@ def uvarint_size(n: int) -> int:
return bts
def load_uvarint_b(buffer: bytes) -> int:
"""
Variable int deserialization, synchronous from buffer.
"""
result = 0
idx = 0
byte = 0x80
while byte & 0x80:
byte = buffer[idx]
result += (byte & 0x7F) << (7 * idx)
idx += 1
return result
def dump_uvarint_b(n: int) -> bytearray:
"""
Serializes uvarint to the buffer
@ -79,18 +51,6 @@ def dump_uvarint_b_into(n: int, buffer: bytearray, offset: int = 0) -> bytearray
return buffer
def dump_uint_b_into(
n: int, width: int, buffer: bytearray, offset: int = 0
) -> bytearray:
"""
Serializes fixed size integer to the buffer
"""
for idx in range(width):
buffer[idx + offset] = n & 0xFF
n >>= 8
return buffer
def load_uvarint(reader: Reader) -> int:
buffer = _UINT_BUFFER
result = 0

18
core/src/apps/monero/xmr/serialize/message_types.py
Unescape View File

@ -17,24 +17,6 @@ else:
T = 0
class UnicodeType:
"""
Unicode data in UTF-8 encoding.
"""
@staticmethod
def dump(writer: Writer, s: str) -> None:
dump_uvarint(writer, len(s))
writer.write(s.encode())
@staticmethod
def load(reader: Reader) -> str:
ivalue = load_uvarint(reader)
fvalue = bytearray(ivalue)
reader.readinto(fvalue)
return str(fvalue)
class BlobType:
"""
Binary data, represented as bytearray. BlobType is only a scheme

3
core/src/apps/monero/xmr/serialize/readwriter.py
Unescape View File

@ -29,9 +29,6 @@ class MemoryReaderWriter:
self.buffer = buffer
self.woffset = len(buffer)
def is_empty(self) -> bool:
return self.offset == len(self.buffer) or self.offset == self.woffset
def preallocate(self, size: int) -> None:
self.buffer = bytearray(size)
self.offset = 0

1
core/src/apps/monero/xmr/serialize_messages/base.py
Unescape View File

@ -26,5 +26,4 @@ class ECKey(BlobType):
ECPoint = Hash
ECPublicKey = ECPoint
KeyImage = ECPoint

6
core/tests/test_apps.monero.serializer.py
Unescape View File

@ -1,11 +1,9 @@
from common import *
from trezor import log, loop, utils
from trezor import utils
if not utils.BITCOIN_ONLY:
from apps.monero.xmr.serialize.int_serialize import (
dump_uint,
dump_uvarint,
load_uint,
load_uvarint,
)
from apps.monero.xmr.serialize.readwriter import MemoryReaderWriter
@ -56,7 +54,7 @@ class TestMoneroSerializer(unittest.TestCase):
:return:
"""
msg = TxinToKey(
amount=123, key_offsets=[1, 2, 3, 2 ** 76], k_image=bytearray(range(32))
amount=123, key_offsets=[1, 2, 3, 2**76], k_image=bytearray(range(32))
)
writer = MemoryReaderWriter()

Write Preview
Loading…
Cancel
Save