Missed by the prior idiomatic-polish pass: SymmetricState had 13 Log.d
calls still using "..." + bytesToHex(...) instead of string templates.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
Address IDE/compiler warnings across the protocol/ package after the
Java to Kotlin migration:
- Replace reference-identity ByteArray checks `!=` with `!==` in
ChaChaPoly/AESGCM*CipherState (in-place encrypt/decrypt guards) to
silence the "dangerous array comparison" warning while preserving
the original semantics.
- Drop `java.util.Arrays.fill` and `Arrays`-style helpers in favour of
ByteArray.fill / copyInto / copyOfRange where appropriate. Cold paths
in NewHopeDHState, Curve25519DHState, Curve448DHState and parts of
SymmetricState now use Kotlin extensions; tight crypto inner loops
(HMAC body, ChaChaPoly) keep System.arraycopy intentionally.
- Use property access (`digestLength`) instead of `getDigestLength()`.
- Fold redundant if/else into `if-expression`, drop redundant
`val space: Int` + assignment, redundant `Companion.` qualifiers,
and unused `val cipher` re-assign in fork().
- Rename `prev_h` to `prevH` (style).
- Replace string concatenation with templates in log statements and
exception messages.
- Convert unused catch parameters `e` to `_` and remove stale local
`var index: Int` in hmac().
- Strip stale `@param secondaryKey/offset/length` KDoc block above
SymmetricState.split (the params moved to the merged doc).
- Drop dead `check(!(local == null || remote == null))` from
HandshakeState.mixDH — Kotlin types are already non-null.
Crypto behaviour is unchanged; output of every method matches the
prior Kotlin/Java implementation byte-for-byte.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
External callers must use the property form for HandshakeState
and CipherStatePair members that the protocol package now exposes
as `val`s:
- handshakeState.getLocalKeyPair() -> handshakeState.localKeyPair
- handshakeState.getAction() -> handshakeState.action
- handshakeState.getRemotePublicKey() -> handshakeState.remotePublicKey
- handshakeState.getHandshakeHash() -> handshakeState.handshakeHash
- cipherPair.getSender() / getReceiver() -> .sender / .receiver
DH operations with arguments (`setPrivateKey`, `getPublicKey`, etc.)
remain regular method calls.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
- Use Kotlin properties (`protocolName`, `handshakeHash`) and update
every getter call (`getDHName/getPublicKeyLength/getMACLength/
getSharedKeyLength/getProtocolName/getHandshakeHash`) to the new
property names exposed by the migrated DHState / SymmetricState /
CipherState interfaces.
- Initialize `pattern` non-null via `requireNotNull(lookup(...))`,
and give the other late-init `var` fields (`patternIndex`,
`preSharedKey`, `prologue`) sensible defaults so the class
compiles cleanly.
- Resolve smart-cast errors on mutable nullable fields (`prologue`,
`fixedEphemeral`, `fixedHybrid`, `localHybrid`) by copying to
local `val`s before use.
- Replace `preSharedKey != null` / `mixPreSharedKey(preSharedKey)`
guards with `?.let` blocks, and pass `localKeyPair!!` etc. into
`mixPublicKey` to satisfy its now-non-null parameter.
- Tighten the cipher/hash name locals in the protocol-name parser
from `String?` to `String` so the SymmetricState constructor
accepts them.
- Token-processing loop, fallback bookkeeping and message buffer
layout are unchanged.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
- Expose `protocolName` as a non-null Kotlin property and rename the
IDE's `mACLength` accessor to `macLength` (delegates to
`cipher.macLength`).
- Update internal `dh.getPublicKeyLength()` calls to use the new
property form.
- Rewrite the HMAC inner/outer-pad XOR loops as `for`-in-range with
an explicit `.toByte()` on the result, satisfying Kotlin's
stricter Int-vs-Byte rules.
- Keep `split()`'s `secondaryKey` parameter nullable to match the
original Java contract; an empty buffer is substituted when null
so the HKDF helper signature can stay non-null.
- HKDF/HMAC/handshake-hash logic is otherwise unchanged, including
the iOS-parity debug logging.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
- Override CipherState properties; initialize `val` fields inline.
- Rewrite the big-endian 4-byte CTR-counter increment at iv[12..15]
as an explicit `(iv[i] + 1).toByte()` chain — Kotlin rejects the
`++(iv[15])` form on Byte array elements.
- Replace `Arrays.fill(arr, 0.toByte())` with `arr.fill(0)` and fix
the GHASH-tag XOR loop to cast back to Byte explicitly.
- Rijndael CTR keystream and GHASH paths preserved byte-for-byte.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
- Override CipherState properties; tighten `initializeKey` parameter
type to non-null `ByteArray`.
- Promote the constructor to a `@Throws(NoSuchAlgorithmException)`
primary constructor with the `Cipher` instance assigned once as a
non-null `val`, removing the bogus `cipher: Cipher? = null`
initializer the IDE emitted.
- Replace `Arrays.fill(arr, 0.toByte())` with `arr.fill(0)`.
- Inline-byte XOR loop in `encryptWithAd` now casts back to `Byte`
explicitly to satisfy Kotlin's stricter type rules.
- `fork()` rethrows the (impossible) NoSuchAlgorithmException as
IllegalStateException instead of returning null — matches the
non-null contract on `CipherState.fork`.
- AES/CTR keystream and GHASH paths preserved byte-for-byte.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
- Override CipherState properties (`cipherName`, `keyLength`,
`macLength`) instead of Java-style getters.
- Initialize `val` fields inline and drop the now-empty constructor
`init` block.
- Replace `Arrays.fill(arr, 0.toByte())` with `arr.fill(0)` and
`Arrays.fill(intArr, 0)` with `intArr.fill(0)`.
- Tighten counter increments (`++input[12]`) — Kotlin no longer needs
the parenthesized form the IDE emitted.
- Crypto path (ChaCha20 keystream, Poly1305 MAC, AD padding) is
unchanged byte-for-byte.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
- Override DHState/DHStateHybrid properties idiomatically; collapse
branchy length getters via single-expression `if`.
- Replace `Arrays.fill` and `arraycopy` of in-memory key buffers
with `ByteArray.copyOf()` where the intent is "duplicate buffer".
- Use safe `?.let` / local `val` patterns for the nullable `nh`,
`publicKey`, `privateKey` fields to satisfy Kotlin smart-cast rules.
- Restructure the if/else-if chains in `calculate` and `copyFrom`
as `when` blocks for readability.
- Crypto parity preserved: `shareda` and the BobCalculated arraycopy
intentionally use offset=0 to match the original Java, which never
honored the caller's `offset` parameter; documented in a comment.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
- Override DHState properties instead of Java-style getters.
- Use `ByteArray.fill(0)` in place of `Arrays.fill(arr, 0.toByte())`.
- Preserve bit-identical crypto behavior (56-byte key sizes,
Curve448.eval call signature, constant-time null-key scan).
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
- Match the tightened `copyFrom` signature on DHState by making the
primary `other` parameter non-null while keeping `remote` nullable
(a missing peer is meaningful for hybrid algorithms).
- Note the inheritance relationship between the single- and two-arg
copyFrom overloads.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
- Convert getDHName/getPublicKeyLength/getPrivateKeyLength/getSharedKeyLength
from Java getters into idiomatic Kotlin `val` properties.
- Tighten nullability: key buffers and DH peer parameters are non-null
per the original Java @param contract; isNullPublicKey kept as a
function so existing call sites (`isNullPublicKey()`) keep resolving.
- Trim redundant KDoc; preserve upstream license header.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
- Remove `@get:JvmName("getMACLength")` — Kotlin rejects @JvmName on
interface getters and all remaining callers in this module are Kotlin.
- macLength is now exposed idiomatically as a Kotlin property.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
- Migrate `Noise.java` to `Noise.kt`.
- Refactor factory methods using Kotlin `when` expressions and destructuring.
- Use `ByteArray.fill()` and `copyOfRange()` for internal utility functions.
- Update reflection logic in `throwBadTagException` for better readability.
- Apply `@JvmStatic` and `const` to maintain compatibility with existing Java callers.
- Ported the NewHope and NewHopeTor key exchange algorithms from Java to idiomatic Kotlin.
- Maintained strict functional parity with the original verified Java implementation.
- Preserved all necessary cryptographic lookup tables (NTT Montgomery, bit-reversal) to ensure mathematical correctness.
- Converted Keccak-f[1600] and ChaCha20 core algorithms into more compact Kotlin structures while retaining constant-time execution safety.
- Ensured seamless Java interoperability by using `const val` for protocol constants like `SENDABYTES` and `SENDBBYTES`.
- Improved overall code readability and removed legacy/redundant constructs.
- Translated `Blake2bMessageDigest` and `Blake2sMessageDigest` to Kotlin.
- Replaced JVM-bound `java.util.Arrays` and `System.arraycopy` with
Kotlin's native `.fill()` and `.copyInto()`.
- Fixed nullable array type `Array<ByteArray?>` to `Array<ByteArray>`
for the `sigma` permutation matrix, removing the need for `!!` assertions.
- Refactored `while` loops into idiomatic Kotlin `for` loops in the `transform`
functions.
- Eliminated mutable parameter shadowing warnings by introducing
`currentOffset` and `remainingLen` local variables.
- Translated `SHA256MessageDigest` and `SHA512MessageDigest` to Kotlin.
- Removed `java.util.Arrays` and `System.arraycopy` dependencies, using
Kotlin's native `.fill()` and `.copyInto()`.
- Refactored legacy `while` loops into idiomatic Kotlin `for` loops.
- Improved variable scoping in the `transform` function by declaring
local variables at the point of use.
- Translated `RijndaelAES.java` to Kotlin.
- Removed JVM-specific `java.util.Arrays` dependency, utilizing Kotlin's
`.fill()`.
- Refactored C-style variable declarations, moving them closer to their
usage scope for better Kotlin idiomatics.
- Retained the original lookup tables (S-boxes) and bitwise logic to
ensure the fallback software AES implementation remains cryptographically
accurate.
* fix: add input validation for protocol decoding and fragment reassembly
* fix:subtract the old entry's size before adding the new one, so duplicate/retransmitted fragments don't inflate the counter
* fix: FragmentManager.handleFragment() can be entered concurrently (e.g., fragments for the same fragmentID arriving from multiple peers/relays). In order for this to happen multiple devices would be needed to connect to the mesh. even with a per-fragmentID byte cap, an attacker could open many fragment IDs at once and force the device to buffer lots of fragment data overall (risking memory pressure/OOM). In this fix we made fragments atomic and thread safe. When a fragment index is retransmitted, we compute the size delta (new - old) so duplicates don’t inflate counters and can’t be used to bypass limits. Under heavy load/attack the app will drop/reject fragment sets earlier instead of growing memory usage without bound to reduce risk of oom. tested on pixel 6 and pixel 8.
* fix: add fragmenttest
* Add 'Send private message' action to chat user sheet
* Change 'Send private message' action color to purple
* Fix: Resolve short ID against all participants, not just cached nicknames
* Fix: Correctly open private chat sheet for mesh peers
---------
Co-authored-by: a1denvalu3 <>
