Update

Author: thebentern

Meshtastic/Crypto/XEdDSASigning.cs

@@ -4,7 +4,7 @@
 using Org.BouncyCastle.Security;
 using Org.BouncyCastle.Crypto.Generators;
 using Org.BouncyCastle.Crypto;
-using System.Numerics;
+using Org.BouncyCastle.Math;
 using System.Text;
 
 namespace Meshtastic.Crypto;
@@ -116,17 +116,17 @@ public static byte[] ConvertX25519PublicKeyToEd25519(byte[] x25519PublicKey)
 
         // Encode y as 32-byte little-endian
         byte[] yBytes = y.ToByteArrayUnsigned();
-        byte[] edPublicKey = new byte[32];
+        byte[] edPublicKeyResult = new byte[32];
         // Copy yBytes into edPublicKey (little-endian)
         for (int i = 0; i < yBytes.Length && i < 32; i++)
         {
-            edPublicKey[i] = yBytes[yBytes.Length - 1 - i];
+            edPublicKeyResult[i] = yBytes[yBytes.Length - 1 - i];
         }
         // If yBytes is shorter than 32 bytes, the rest is already zero
 
         // Set the sign bit to 0 (positive x)
-        edPublicKey[31] &= 0x7F;
-        return edPublicKey;
+        edPublicKeyResult[31] &= 0x7F;
+        return edPublicKeyResult;
     }
 
     /// <summary>

Meshtastic/Data/MessageFactories/NodeInfoMessageFactory.cs

@@ -57,7 +57,7 @@ public static MeshPacket CreateNodeInfoMessage(
             {
                 AddXEdDSASignature(meshPacket, deviceStateContainer, useShortHash);
             }
-            catch (Exception ex)
+            catch (Exception)
             {
                 // Log error but don't fail packet creation
                 // Swallow exception: failed to sign NodeInfo packet, but don't fail packet creation
@@ -90,10 +90,14 @@ public static User CreateTestUser(
             Id = id,
             HwModel = hardwareModel,
             IsUnmessagable = false,
-            Macaddr = ByteString.CopyFrom([0xFF, 0xAA, 0x88, 0x99, 0x55, 0x66]),
-            PublicKey = publicKey != null ? ByteString.CopyFrom(publicKey) : null
+            // Macaddr = ByteString.CopyFrom([0xFF, 0xAA, 0x88, 0x99, 0x55, 0x66]), // Obsolete field
         };
 
+        if (publicKey != null)
+        {
+            user.PublicKey = ByteString.CopyFrom(publicKey);
+        }
+
         return user;
     }
 
@@ -175,10 +179,129 @@ private static void AddXEdDSASignature(MeshPacket meshPacket, DeviceStateContain
         return privateKey;
     }
 
+    /// <summary>
+    /// Analyze payload sizes for NodeInfo messages with and without signatures
+    /// </summary>
+    /// <param name="user">User to analyze</param>
+    /// <returns>Payload analysis</returns>
+    public static NodeInfoPayloadAnalysis AnalyzePayloadSizes(User user)
+    {
+        // Create a test device state container with proper configuration for signing
+        var testDeviceState = new DeviceStateContainer();
+        testDeviceState.MyNodeInfo = new MyNodeInfo { MyNodeNum = 0x12345678 };
+
+        // Create unsigned packet
+        var unsignedPacket = CreateNodeInfoMessage(
+            deviceStateContainer: testDeviceState,
+            user: user,
+            signPacket: false);
+
+        // Create signed packets - these will use mock signatures for testing
+        var signedSha256Packet = CreateNodeInfoMessage(
+            deviceStateContainer: testDeviceState,
+            user: user,
+            signPacket: true,
+            useShortHash: true);
+
+        var signedSha512Packet = CreateNodeInfoMessage(
+            deviceStateContainer: testDeviceState,
+            user: user,
+            signPacket: true,
+            useShortHash: false);
+
+        // Since signing currently fails silently due to no private key,
+        // we'll simulate the signature overhead by creating packets with mock signatures
+        var unsignedSize = unsignedPacket.ToByteArray().Length;
+        var userDataSize = user.ToByteArray().Length;
+        
+        // Ed25519 signatures are always 64 bytes, so we simulate the overhead
+        var signatureSizeOverhead = 64;
+        var signedSha256Size = unsignedSize + signatureSizeOverhead;
+        var signedSha512Size = unsignedSize + signatureSizeOverhead;
+
+        return new NodeInfoPayloadAnalysis
+        {
+            UserDataSize = userDataSize,
+            BasePacketSize = unsignedSize - userDataSize,
+            UnsignedTotalSize = unsignedSize,
+            SignedSha256TotalSize = signedSha256Size,
+            SignedSha512TotalSize = signedSha512Size,
+            SignatureSizeOverhead = signatureSizeOverhead,
+            Sha256HashSize = 32,
+            Sha512HashSize = 64
+        };
+    }
+
     private static uint GeneratePacketId()
     {
         var bytes = new byte[4];
         new SecureRandom().NextBytes(bytes);
         return BitConverter.ToUInt32(bytes, 0);
     }
 }
+
+/// <summary>
+/// Analysis of NodeInfo payload sizes with and without signatures
+/// </summary>
+public class NodeInfoPayloadAnalysis
+{
+    /// <summary>
+    /// Size of the User data in bytes
+    /// </summary>
+    public int UserDataSize { get; set; }
+
+    /// <summary>
+    /// Size of the base MeshPacket without User data in bytes
+    /// </summary>
+    public int BasePacketSize { get; set; }
+
+    /// <summary>
+    /// Total size of unsigned packet in bytes
+    /// </summary>
+    public int UnsignedTotalSize { get; set; }
+
+    /// <summary>
+    /// Total size of packet signed with SHA-256 in bytes
+    /// </summary>
+    public int SignedSha256TotalSize { get; set; }
+
+    /// <summary>
+    /// Total size of packet signed with SHA-512 in bytes
+    /// </summary>
+    public int SignedSha512TotalSize { get; set; }
+
+    /// <summary>
+    /// Size overhead of the signature in bytes (always 64 for Ed25519)
+    /// </summary>
+    public int SignatureSizeOverhead { get; set; }
+
+    /// <summary>
+    /// Size of SHA-256 hash in bytes
+    /// </summary>
+    public int Sha256HashSize { get; set; }
+
+    /// <summary>
+    /// Size of SHA-512 hash in bytes
+    /// </summary>
+    public int Sha512HashSize { get; set; }
+
+    /// <summary>
+    /// Signature overhead for SHA-256 (same as SignatureSizeOverhead)
+    /// </summary>
+    public int Sha256Overhead => SignatureSizeOverhead;
+
+    /// <summary>
+    /// Signature overhead for SHA-512 (same as SignatureSizeOverhead)
+    /// </summary>
+    public int Sha512Overhead => SignatureSizeOverhead;
+
+    /// <summary>
+    /// Percentage overhead for SHA-256 signatures
+    /// </summary>
+    public double Sha256OverheadPercentage => (double)Sha256Overhead / UnsignedTotalSize * 100;
+
+    /// <summary>
+    /// Percentage overhead for SHA-512 signatures
+    /// </summary>
+    public double Sha512OverheadPercentage => (double)Sha512Overhead / UnsignedTotalSize * 100;
+}