TcpClient a prihlasenie na server – .NET – Fórum – Programujte.com

ahoj, vedel by mi niekto poradit? riesim prihlasenie na server prostrednictvom tcp a neviem ako poslat data na server, mam nejaky navod ale nechapem tomu, na 4bytov mam poslat velkost hesla + null, neviem ako zapisat na 4byty

# Post-authentication Client/Server communication is done via blocks of
# data. Each data block starts with the number of strings contained in
# the block, then each string, null terminated, with a 4-byte size sent
# before the string. Each 4-byte "length" is sent in unsigned long
# little-endian order.
#
# Bytes Meaning
# 1 2 3 4 Number of strings in this block
# 5 6 7 8 Size of string #1
# 9 ... String #1, with trailing NULL
# ... Size of string #2
# ... String #2, with trailing NULL
#


# Initial authentication is done via simple XOR'ing. The server sends 10
# bytes, and the client XORs the authentication information against those
# 10 bytes (and re-uses them again for each of the 10 bytes it sends to
# the server).
#
# Server->Client: 10 bytes: XOR pattern to use
# Client->Server: 4 bytes: length of user name (including the trailing NULL)
# Client->Server: X bytes: user (index-XOR'd, with trailing NULL)
# for example, if the user name was 15 "0x10" values,
# and the XOR pattern was the byte values from
# 0x00-0x09, the resulting "encrypted" user name
# would be in hex:
# 10,11,12,13,14,15,16,17,18,19,10,11,12,13,14,0
# Client->Server: 4 bytes: length of password (including the trailing NULL)
# Client->Server: X bytes: password, XOR'd like the username, with final NULL
# Server->Client: 1 byte. (value of "1" means authenticated)
#
# To start console communication, the client seems to send something that
# almost matches the description of "Post-Authentication" communication,
# but the count of strings is wrong. Where "OFFSET" is the server instance
# to talk to (0 being first, 1 for the next server on the same IP, etc) it
# sends:
#
# 4 byte block length: 2
# NULL-terminated string: ConsoleRun OFFSET
# 4 byte block length: 2
# empty NULL-terminated string
# empty NULL-terminated string
#
# and then it reads back a regular block from the server, and then "normal"
# block-at-a-time communication starts up.

Překvapivě se i čísla skládají z bajtů. Ale to jedno... http://msdn.microsoft.com/en-us/library/system.bitconverter.aspx

Diky pomohlo mi to pochopit, aspon si myslim :-)

Pripojim sa na server a ten mi posle 10Bytes kluc

prihlasovacie meno pouzijem string "meno"
dlzka pri. mena 4 a premenim to na byte
04-00-00-00
premenim to na little-endian
00-00-00-04
pridam na konic nulty bytes
00-00-00-04-00
v takom to tvare odoslem na server

prihlasovacie meno premenim na byte
ale teraz neviem ako mam pouzit XOR na kazdy byte prih. mena s klucom ktory mi poslal server
nacitam byte kluc

     

byte[] dataRead = new Byte[10];

Int32 bytes = stream.Read(dataRead, 0, dataRead.Length);

// prihlasovacie meno na byte

data1 = System.Text.Encoding.ASCII.GetBytes(txtMsg.Text);

for (int i = 0; i < data1.Length; i++)

        {

          data1[i] ^= dataRead;

        }

BitConverter ti tu hodnotu už vrací v LE (můžeš otestovat BitConverter.IsLittleEndian), takže to nemusíš otáčet. Pak ten řetězec má být ukončený NULL bytem a délka je včetně toho ukončovače. Takže pro "meno" to bude

05-00-00-00 "meno" 00

data[i] ^= key[i]

diky za pomoc, skusam vsetko mozne ale neviem kde robim chybu, data odoslem ale nepride ziadna odpoved, asi XOR nemam spravne spraveny...

takze este raz co mam

Prihlasim sa na server a server posle 10Bytes key

Server->Client : 8F-7F-94-56-51-EF-59-55-51-3A   - 10Bytes KEY

Login name ="meno" lenght + 1(null) ="5"

Bytes : 05-00-00-00-00

a odoslem velkost mena na server

Login name bytes : 6D-65-6E-6C-6F
Login name bytes XOR + add NULL byte: 86-8E-85-84-00
a odoslem XOR meno na server

Login name ="heslo" lenght + 1(null) ="6"

Bytes : 06-00-00-00-00

a odoslem velkost hesla na server

Login pass bytes : 68-65-73-6C-6F

Login pass bytes XOR + add NULL byte : 83-8E-98-87-84-00

a odoslem XOR heslo na server

a server nevrati nic...

Moj pouzity XOR, to znamena ze kazdy jeden Byte prihlasovacieho mena a hesla XORujem s kazdy jednym Byte kluca

                for (int i = 0; i < loginNameBytes.Length; i++)
                {
                    for (int j = 0; j < serverKey.Length; j++)
                    {
                        loginNameBytes[i] ^= serverKey[j];
                    }
                }

diky, ale zrejme mam este niekde chybu ak by sa niekomu chcelo na to pozriet bol by som mu velmi vdacny...
a tu je komplet zdrojak
[url]http://www.valal.sk/upload/savefile_php/uploads/6b542311ed.zip[/url]

IP na server je 46.150.221.221 a port 4711 meno je skorec a heslo je borec

tu je moj zdrojak...

System.Net.Sockets.TcpClient client = new System.Net.Sockets.TcpClient(ipText.Text, Convert.ToInt32(portText.Text));
// Get a client stream for reading and writing.
Stream stream = client.GetStream();
NetworkStream stream = client.GetStream();

byte[] serverKey = new Byte[10];
int bytes = stream.Read(serverKey, 0, serverKey.Length);
Console.WriteLine("Server->Client : " + BitConverter.ToString(serverKey) + " - 10Bytes KEY");

// ziskanie dlzky prihlasovacieho mena +1
int loginNameLength = Convert.ToInt16(loginName.Text.Length + 1);
//"skorec"+ 1 = vysledna hodnota 7
Console.WriteLine("Login name =\"" + loginName.Text + "\" lenght + 1 =\"" + loginNameLength + "\"");
// prekonvertuje dlzku prihlasovacieho mena na byty
byte[] loginNameBytesLength = BitConverter.GetBytes(loginNameLength);

Console.WriteLine("Login name lenght bytes : " + BitConverter.ToString(loginNameBytesLength));
// otocenie bytov
//if (BitConverter.IsLittleEndian) loginNameBytesLength = ReverseBytes(loginNameBytesLength);

// pridanie nulteho bytu
byte[] addNullByte = new Byte[loginNameBytesLength.Length + 1];
loginNameBytesLength.CopyTo(addNullByte, 0);
loginNameBytesLength = addNullByte;

Console.WriteLine("Bytes : " + BitConverter.ToString(loginNameBytesLength));
Console.WriteLine();

// Poslanie dlzku prihlasovacieho mena na server
stream.Write(loginNameBytesLength, 0, loginNameBytesLength.Length);
// prekonvertuje prihlasovacie meno na bytes
byte[] loginNameBytes = System.Text.Encoding.ASCII.GetBytes(loginName.Text);

Console.WriteLine("Login name bytes : " + BitConverter.ToString(loginNameBytes));
//XOR prihlasovacieho mena
for (int i = 0; i < loginNameBytes.Length; i++)
{
loginNameBytes[i] ^= serverKey[i % loginNameBytes.Length];
}

// pridanie nulteho bytu
Console.WriteLine("Bytes : " + BitConverter.ToString(loginNameBytes));
byte[] zdata = new byte[loginNameBytes.Length + 1];
loginNameBytes.CopyTo(zdata, 0);
loginNameBytes = zdata;
Console.WriteLine("Bytes : " + BitConverter.ToString(loginNameBytes));
Console.WriteLine("Login name bytes XOR + add NULL byte : " + BitConverter.ToString(loginNameBytes));

// Poslanie prihlasovacieho mena v bytoch na server
stream.Write(loginNameBytes, 0, loginNameBytes.Length);
Console.WriteLine("+++++++++++++++++++++++++++++++++++++");

// ziskanie dlzky prihlasovacieho hesla +1
int loginPassLength = Convert.ToInt16(loginPass.Text.Length + 1);
//"borec"+ 1 = vysledna hodnota 6

// prekonvertuje dlzku prihlasovacieho hesla na byty
byte[] loginPassBytesLength = BitConverter.GetBytes(loginPassLength);
// otocenie bytov
//if (BitConverter.IsLittleEndian) loginPassBytesLength = ReverseBytes(loginPassBytesLength);

// pridanie nulteho bytu
Console.WriteLine("Bytes : " + BitConverter.ToString(loginPassBytesLength));
byte[] addNullByte2 = new Byte[loginPassBytesLength.Length + 1];
loginPassBytesLength.CopyTo(addNullByte2, 0);
loginPassBytesLength = addNullByte2;

Console.WriteLine("Bytes : " + BitConverter.ToString(loginPassBytesLength));
// Poslanie dlzku prihlasovacieho mena na server
stream.Write(loginPassBytesLength, 0, loginPassBytesLength.Length);


// prekonvertuje prihlasovacie meno na bytes
byte[] loginPassBytes = System.Text.Encoding.ASCII.GetBytes(loginPass.Text);
// listbox
ListBoxLog.Items.Add("Login pass bytes : " + BitConverter.ToString(loginPassBytes));

//XOR na prihlasovacie heslo
for (int i = 0; i < loginPassBytes.Length; i++)
{
loginPassBytes[i] ^= serverKey[i % loginPassBytes.Length];
}
// pridanie nulteho bytu
Console.WriteLine("Bytes : " + BitConverter.ToString(loginPassBytes));
byte[] zdata2 = new byte[loginPassBytes.Length + 1];
loginPassBytes.CopyTo(zdata2, 0);
loginPassBytes = zdata2;
Console.WriteLine("Bytes : " + BitConverter.ToString(loginPassBytes));

// Poslanie prihlasovacieho mena v bytoch na server
stream.Write(loginNameBytes, 0, loginPassBytes.Length);
Console.WriteLine("+++++++++++++++++++++++++++++++++++++");

byte[] authenticated = new Byte[10];
String responseData = String.Empty;

int bytes3 = stream.Read(authenticated, 0, authenticated.Length);

responseData = System.Text.Encoding.ASCII.GetString(authenticated, 0, bytes3);
Console.WriteLine("Received: {0}", responseData);

System.Net.Sockets.TcpClient client; 
NetworkStream stream;
byte[] serverKey = new byte[10];

private void Connect()
{
   client = new System.Net.Sockets.TcpClient(ipText.Text, Convert.ToInt32(portText.Text));
   stream = client.GetStream();
   int bytes = stream.Read(serverKey, 0, serverKey.Length);
}

private void SendAuthData(string s)
{
   byte[] length = BitConverter.GetBytes(s.Length + 1);
   stream.Write(length, 0, length.Length);

   byte[] data = Encoding.ASCII.GetBytes(s);

   for (int i = 0; i < data.Length; i++) data[i] ^= serverKey[i % data.Length];

   Array.Resize(ref data, data.Length + 1);
   stream.Write(data, 0, data.Length);
}

// Pokud tato metoda vrati true, uzivatel byl prihlasen.
private bool Authenticate()
{
   SendAuthData(loginName.Text);//username
   SendAuthData(loginPass.Text);//password
   return (stream.ReadByte() == 1);
}

diky nervak, vo svojom kode som spravil niekde chybu a tu mam final verziu funkcnu

Jo, nejméně tři - nulový byte za délkou, jméno místo hesla a modulování délkou dat (to je špatně i v tom, co nějaká dobrá duše napsala za tebe).

jj, uz som nasiel tie chyby, 2x budem vedet ze mam kod pisat prehladnejsie, jednoduchsie a nepouzivat CTRL C a V

myslel som ze za dlzkou ma byt tiez nulovy byte ale nepochopil som co znamena modulování délkou dat

myslis toto 

for (int i = 0; i < data.Length; i++) data[i] ^= serverKey[i % data.Length];

lebo tu skom skusal aj samotne i alebo serverKey.Length a stale ma to pripoji na server spravne

Jak jsem napsal výše, musíš ošetřit situaci, když budou data delší než klíč. Takže pro třeba 7 B dat a 3 B klíč, budou ty indexy takhle:

data 0 1 2 3 4 5 6
klic 0 1 2 0 1 2 0

Většinou se k tomu používá právě modulo (%), které vrací zbytek po celočíselném dělení (5 / 3 je 1, zbytek 2), což je přesně to, co potřebuješ.

Ty máš zatím data kratší než klíč, tak se ten problém neprojevil.

Dakujem velmi pekne, program mam uz skoro funkcny pre odosielanie a prijimanie dat a coto som sa pritom naucil :-) ale nakoniec som nasiel utilitu pre spravu serveru tak to nemusim dokoncovat :-)

este raz diky