Curve Android Java und Server c# funktionieren nicht ganz

Ministalker

Grünschnabel
C# server:
https://github.com/hanswolff/curve25519
Java Android APP:
https://code.google.com/p/curve25519-java/

Ich nutze curve25519 um den key und den IV vom hc256 unter dem Server und der Android APP auszutauschen.

Das komische dabei ist das solange ich keine Zufallzahlen nehme funktioniert auch alles.

Ich habe eine ganz starke Vermutung das es daran liegt das Java signierte bytes standartmässig nutzt.

Kann das daran liegen?

Die Bilder zeigen das Ergebnis in hex die eigentlich gleich sein sollten.

Die Ausgaben wie is littleendien ignorieren die dienten nur zum prüfen ob der Server auch alles richtig erkennt.
 

Anhänge

  • DSC_0255.JPG
    DSC_0255.JPG
    221 KB · Aufrufe: 8
  • DSC_0257.JPG
    DSC_0257.JPG
    384,8 KB · Aufrufe: 9
Zuletzt bearbeitet:

Improof

Erfahrenes Mitglied
Hi,

Java nutzt standardmäßig signed bytes, das ist korrekt. Allerdings nutzt C# standardmäßig unsigned bytes! Hast du das berücksichtigt?
Ansonsten muss ich leider passen, kennen mich mit deinem Anwendungsfall leider überhaupt nicht aus :(

Gruß
Daniel
 

Ministalker

Grünschnabel
Hier nochmal die Java klasse für die Android App:

Code:
public class CryptoManager {

    private byte[] wKey, wIV, rKey, rIV;
    private HC256Engine wCipher, rCipher;
    private Socket soc;
    private DataOutputStream out;
    private DataInputStream in;

    public CryptoManager() throws UnknownHostException, IOException{
        soc = new Socket("192.168.2.103", 3075);
        out = new DataOutputStream(soc.getOutputStream());
        in = new DataInputStream(soc.getInputStream());

        //Mode
        Write(new byte[] {0x02, 0x02});

        //Init
        byte[] privateKey, publicKey, s;
        privateKey = new byte[32];
        publicKey = new byte[32];
        s = new byte[32];
        CipherKeyGenerator key = new CipherKeyGenerator();
        key.init(new KeyGenerationParameters(new SecureRandom(), 256));
        wKey = new byte[32];
        rKey = new byte[32];
        wIV = new byte[32];
        rIV = new byte[32];

        //wKey
        privateKey = key.generateKey();
        Curve25519.keygen(publicKey, s, privateKey);
        Write(publicKey);
        publicKey = Read();
        Curve25519.curve(wKey, privateKey, publicKey);

        //rKey
        privateKey = key.generateKey();
        Curve25519.keygen(publicKey, s, privateKey);
        Write(publicKey);
        publicKey = Read();
        Curve25519.curve(rKey, privateKey, publicKey);

        //wIV
        privateKey = key.generateKey();
        Curve25519.keygen(publicKey, s, privateKey);
        Write(publicKey);
        publicKey = Read();
        Curve25519.curve(wIV, privateKey, publicKey);

        //rIV
        privateKey = key.generateKey();
        Curve25519.keygen(publicKey, s, privateKey);
        Write(publicKey);
        publicKey = Read();
        Curve25519.curve(rIV, privateKey, publicKey);

        wCipher = new HC256Engine();
        rCipher = new HC256Engine();

        wCipher.init(true, new ParametersWithIV(new KeyParameter(wKey), wIV));
        rCipher.init(false, new ParametersWithIV(new KeyParameter(rKey), rIV));

        System.out.println(new BigInteger(1, wKey).toString(16));
        System.out.println(new BigInteger(1, wIV).toString(16));
        System.out.println(new BigInteger(1, rKey).toString(16));
        System.out.println(new BigInteger(1, rIV).toString(16));
    }

    private void Write(byte[] buffer) throws IOException {
        out.write(buffer, 0, buffer.length);
        out.flush();
    }

    private byte[] Read() throws IOException {
        byte[] buffer = new byte[1024];
        in.read(buffer);

        return buffer;
    }

    public void WriteLine(Package pack) throws IOException {
        byte[] buffer = pack.getData();
        byte[] tbuffer = new byte[buffer.length];

        wCipher.processBytes(buffer, 0, buffer.length, tbuffer, 0);
        Write(buffer);
    }

    public Package ReadLine() throws IOException {
        byte[] buffer = Read();

        rCipher.processBytes(buffer, 0, buffer.length, buffer, 0);

        return new Package(buffer);
    }

    public void Close() throws IOException{
        out.close();
        in.close();
        soc.close();
    }
}
 

Ministalker

Grünschnabel
Und hier der Code vom Server in c#:

Code:
using System;
using System.Net.Sockets;
using System.Linq;

namespace MessengerServer
{
    public class CryptoManager
    {
        private NetworkStream stream;
        private byte[] wKey, wIV, rKey, rIV;
        private IStreamCipher wcipher, rcipher;
        private bool isLittleEndien;

        public CryptoManager(TcpClient client)
        {
            stream = client.GetStream();

            //Mode
            byte[] buffer = Read();
            isLittleEndien = buffer[0] == 0x01;
            bool is256 = buffer[1] == 0x02;

            //rKey
            byte[] publicKey = Read();
            byte[] privateKey = Curve25519.ClampPrivateKey (new byte[32]);//CreateRandomByteArray(new DigestRandomGenerator(), 32));
            Write(Curve25519.GetPublicKey(privateKey));
            rKey = Curve25519.GetSharedSecret(privateKey, publicKey);

            //wKey
            publicKey = Read();
            privateKey = Curve25519.ClampPrivateKey(new byte[32]);//CreateRandomByteArray(new DigestRandomGenerator(), 32));
            Write(Curve25519.GetPublicKey(privateKey));
            wKey = Curve25519.GetSharedSecret(privateKey, publicKey);

            //rIV
            publicKey = Read();
            privateKey = Curve25519.ClampPrivateKey(new byte[32]);//CreateRandomByteArray(new DigestRandomGenerator(), 32));
            Write(Curve25519.GetPublicKey(privateKey));
            rIV = Curve25519.GetSharedSecret(privateKey, publicKey);

            //wIV
            publicKey = Read();
            privateKey = Curve25519.ClampPrivateKey(new byte[32]);//CreateRandomByteArray(new DigestRandomGenerator(), 32));
            Write(Curve25519.GetPublicKey(privateKey));
            wIV = Curve25519.GetSharedSecret(privateKey, publicKey);

            Console.WriteLine(BitConverter.ToString(rKey));
            Console.WriteLine (BitConverter.ToString(publicKey));

            ChangeKey(is256);
        }

        public void ChangeKey(bool is256)
        {
            if (is256)
            {
                rcipher = new HC256Engine();
                wcipher = new HC256Engine();
            }
            else
            {
                rcipher = new HC128Engine();
                wcipher = new HC128Engine();
            }

            rcipher.Init(rKey, rIV);
            wcipher.Init(wKey, wIV);
        }

        public void WriteLine(Package pack)
        {
            byte[] buffer = pack.getData();

            wcipher.ProcessBytes(buffer);
            wcipher.Reset();

            Write(buffer);
        }

        public Package ReadLine()
        {
            byte[] buffer = Read();

            rcipher.ProcessBytes(buffer);
            rcipher.Reset();

            Package pack = new Package(buffer);

            pack.setEndienness(isLittleEndien);

            return pack;
        }

        private void Write(byte[] buffer)
        {
            stream.Write(buffer, 0, buffer.Length);
            stream.Flush();
        }

        private byte[] Read()
        {
            byte[] buffer = new byte[1024];
            int lenght = stream.Read(buffer, 0, buffer.Length);

            return buffer.Take(lenght).ToArray();
        }

        public void Close()
        {
            stream.Close();
            stream.Dispose();
            Console.WriteLine ("Connection Closed!");
        }

        private byte[] CreateRandomByteArray(DigestRandomGenerator random, int Length)
        {
            byte[] buffer = new byte[Length];
            random.NextBytes(buffer);

            return buffer;
        }

        public bool getEndieness() {
            return isLittleEndien;
        }
    }
}
 

Ministalker

Grünschnabel
OK das Problem habe ich anscheinend gelöst in dem ich die jeden Array zurückgesetzt habe mit = new byte[32] nach jedem Durchgang.
Das Problem liegt jetzt aber in hc 256 was trotz gleichem schlüssel andere Vektoren erzeugt.