mirror of
https://github.com/trezor/trezor-firmware.git
synced 2024-12-18 04:18:10 +00:00
chore(xmr): delete unused code
[no changelog]
This commit is contained in:
grdddj
Martin Milata
parent
26711857e8
commit
fac4e2f157
@ -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:
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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:
|
||||
|
||||
@ -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]]:
|
||||
|
||||
@ -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]
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -26,5 +26,4 @@ class ECKey(BlobType):
|
||||
|
||||
|
||||
ECPoint = Hash
|
||||
ECPublicKey = ECPoint
|
||||
KeyImage = ECPoint
|
||||
|
||||
@ -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()
|
||||
|
||||
Loading…
Reference in New Issue
Block a user