Пакеты и MPPC/RC4

[krysun]

Здравствуйте.
Пытаюсь адаптировать MPPC & RC4 под другие платформы.
Для этого мне нужно удостовериться в правильности моих алгоритмов.

По возможности, поделитесь циферками
1 - зашифрованный RC4 пакет: byte[] pack1;
2 - расшифрованный пакет: byte[] pack1;

3 - запакованный MPPC пакет: byte[] pack2;
4 - распакованный пакет: : byte[] pack2;

Пакеты, для наглядности, прошу представить в виде, напр.:
[54,74,65,84,74,98,41,AD,3F,12]

Спасибо!

[Kitsune]

Цитата: Сообщение от krysun 1 - зашифрованный RC4 пакет: byte[] pack1; 2 - расшифрованный пакет: byte[] pack1;

С RC4 все просто.

Key - ключ
Packet - случайные 16 байт
RC4 - 16 байт зашифрованные при помощи RC4, который был проинициализирован ключем Key.
RC4 симметричный шифр, то есть зашифровка и расшифровка это одна и таже функция. Роль имеют только входные данные и ключ.

Key:
[5B,88,35,40,E2,B8,B9,A8,9D,AE,29,9C,3F,97,E1,8F]
Packet:
[40,21,2D,46,93,89,34,4E,01,92,86,29,27,3E,8B,BB]
RC4:
[92,06,FC,61,06,AA,37,4C,59,48,0C,7C,2B,33,3A,F7]

Key:
[8D,BD,BA,98,D5,E8,EA,E1,A2,DC,78,27,19,6F,9B,84]
Packet:
[F5,5C,92,60,6D,F3,36,D2,54,E6,3F,50,31,90,80,5F]
RC4:
[F1,03,2A,FB,9C,54,50,E5,08,DF,06,CF,6A,15,89,7D]

Key:
[23,6E,0E,81,DD,49,BA,57,37,4B,A3,B7,11,0C,34,91]
Packet:
[F7,02,33,CB,AB,2B,4E,9A,87,E7,43,EE,A9,9A,AF,11]
RC4:
[BB,DE,0E,BE,B6,8E,43,9B,F5,FA,95,B4,CF,A4,CA,7D]

Key:
[5B,18,04,AB,61,19,A6,AB,A2,3B,29,21,4F,7F,C1,47]
Packet:
[B2,AD,58,2F,5C,B5,B3,F7,20,73,FA,F5,05,CB,AE,9C]
RC4:
[39,7A,DC,C8,06,B4,9F,2A,34,92,FF,9B,06,A7,D7,A7]

Key:
[9C,92,5B,F8,07,89,30,DD,5C,88,28,70,02,2C,4A,08]
Packet:
[26,FB,3C,FB,41,80,B5,A5,65,0D,8B,ED,1E,B0,A6,D7]
RC4:
[9B,6B,FB,F2,C7,79,8E,59,7C,C7,9B,08,CC,FF,0A,A1]

Key:
[8C,8C,84,BD,23,C8,3F,28,7D,7B,D2,D4,8D,43,F5,F3]
Packet:
[29,F2,CF,09,8E,B3,5B,1B,DC,B6,93,FA,FE,43,BE,AB]
RC4:
[9F,4B,0C,9B,44,39,D8,B7,6D,7D,7C,A2,E3,A2,5E,37]

Key:
[E1,50,E3,75,A7,8C,E4,5D,BB,13,7E,C6,AD,E1,17,21]
Packet:
[17,98,C3,2C,E1,9C,48,D9,30,68,E1,6C,35,45,2A,39]
RC4:
[B4,36,B4,2D,19,4C,AE,DE,AD,1C,77,B2,FE,3F,2F,A5]

Key:
[BC,27,F2,3C,60,7F,4B,9D,0D,72,4D,7A,34,95,6E,FB]
Packet:
[9E,71,E3,66,80,92,CA,45,08,09,44,3F,AB,78,27,76]
RC4:
[75,C8,11,70,08,59,2C,63,C4,9A,E0,EE,B3,A3,8B,E0]

Key:
[E9,44,0A,86,EF,DB,C1,97,4C,26,1E,6F,4E,CD,A4,9B]
Packet:
[FA,E6,CD,C3,61,C4,B9,29,5D,AC,34,56,3A,0C,F2,95]
RC4:
[AE,D8,B7,7A,99,19,6F,16,31,79,E3,BD,9C,EF,EA,13]

Key:
[4A,D6,91,F0,8A,E8,0B,C3,B0,4B,19,5A,74,5A,F6,3A]
Packet:
[64,A9,44,C4,AA,64,15,25,8A,E1,28,42,A6,6B,5C,40]
RC4:
[54,84,90,76,EB,DB,AC,3F,FB,5C,E6,C3,58,4A,92,C6]

А вот MPPC использует буфер 8Кбайт, поэтому надо всю историю прикладывать. Лениво делать синтетические данные.

[krysun]

Т.е., как я понял, упаковщика ни у кого нет, т.к., по большому счету, он и не нужен...
Хорошо... Эти методы распаковки и расшифровки актуальны?
Инфо скопировано с (с) Zhyk.ru & [Ссылки могут видеть только зарегистрированные пользователи. ]

MPPC

public class MPPC
    {
        public byte[] decHistory = new byte[0xffff];
        private int i;
        public int j;
        public BitArray srcbinary;
        public StreamWriter writer;

        private int bitstobytes(int bits, bool complete)
        {
            int num = 0;
            if (complete)
            {
                num += Convert.ToInt32(Math.Pow(Convert.ToDouble(2), Convert.ToDouble((int)(bits + 1))));
            }
            for (int i = bits; i >= 0; i--)
            {
                if (this.srcbinary[this.i])
                {
                    num += Convert.ToInt32(Math.Pow(Convert.ToDouble(2), Convert.ToDouble(i)));
                }
                this.i++;
            }
            return num;
        }

        private byte[] BitsToBytesCompressor(BitArray target, int lenght)
        {
            int[] numArray = new int[lenght / 8];
            byte[] buffer = new byte[lenght / 8];
            for (int i = 0; i < (lenght / 8); i++)
            {
                for (int j = 7; j >= 0; j--)
                {
                    if (target[(i * 8) + j])
                    {
                        numArray[i] += Convert.ToInt32(Math.Pow(Convert.ToDouble(2), Convert.ToDouble(j)));
                    }
                }
                buffer[i] = BitConverter.GetBytes(numArray[i])[0];
            }
            return buffer;
        }

        private void Copy(BitArray inputbits, int from, BitArray outputbits, int to, int length)
        {
            for (int i = 0; i < length; i++)
            {
                outputbits[to + i] = inputbits[from + i];
            }
        }

        private void copytuple(int offsettocopy, int lenght)
        {
            int num2;
            if (offsettocopy == 1)
            {
                byte num = this.decHistory[this.j - offsettocopy];
                for (num2 = 0; num2 < lenght; num2++)
                {
                    this.decHistory[this.j] = num;
                    this.j++;
                }
            }
            else
            {
                byte[] buffer;
                if (offsettocopy >= lenght)
                {
                    buffer = new byte[lenght];
                    for (num2 = 0; num2 < lenght; num2++)
                    {
                        buffer[num2] = this.decHistory[(this.j - offsettocopy) + num2];
                    }
                    Array.Copy(buffer, 0, this.decHistory, this.j, lenght);
                    this.j += lenght;
                }
                else if (offsettocopy < lenght)
                {
                    buffer = new byte[lenght];
                    int num3 = 0;
                    for (num2 = 0; num2 < lenght; num2++)
                    {
                        if (num3 == offsettocopy)
                        {
                            num3 = 0;
                        }
                        buffer[num2] = this.decHistory[(this.j - offsettocopy) + num3];
                        num3++;
                    }
                    Array.Copy(buffer, 0, this.decHistory, this.j, lenght);
                    this.j += lenght;
                }
            }
        }

        public byte[] decompresMccp(byte[] src, int packetnumber)
        {
            if (this.j > 0x6d60)
            {
                Array.Copy(this.decHistory, 0x3fff, this.decHistory, 0, 0x3fff);
                this.j -= 0x3fff;
            }
            this.i = 0;
            int j = this.j;
            this.srcbinary = new BitArray(src);
            this.ReOrderBitArray(this.srcbinary);
            while (this.i < this.srcbinary.Length)
            {
                if (!this.srcbinary[this.i])
                {
                    try
                    {
                        this.decHistory[this.j] = Convert.ToByte(this.bitstobytes(7, false));
                    }
                    catch
                    {
                    }
                    this.j++;
                }
                else if (this.srcbinary[this.i])
                {
                    this.i++;
                    if (!this.srcbinary[this.i])
                    {
                        this.i++;
                        try
                        {
                            this.decHistory[this.j] = Convert.ToByte(this.bitstobytes(6, true));
                        }
                        catch
                        {
                        }
                        this.j++;
                    }
                    else if (this.srcbinary[this.i])
                    {
                        int num2;
                        this.i++;
                        if (this.srcbinary[this.i])
                        {
                            this.i++;
                            if (this.srcbinary[this.i])
                            {
                                this.i++;
                                num2 = this.bitstobytes(5, false);
                                if (num2 == 0)
                                {
                                    while ((this.i % 8) != 0)
                                    {
                                        this.i++;
                                    }
                                    if (this.srcbinary.Length == this.i)
                                    {
                                        break;
                                    }
                                }
                                else
                                {
                                    this.copytuple(num2, this.getlenghtofmatch());
                                }
                            }
                            else if (!this.srcbinary[this.i])
                            {
                                this.i++;
                                num2 = this.bitstobytes(7, false) + 0x40;
                                this.copytuple(num2, this.getlenghtofmatch());
                            }
                        }
                        else if (!this.srcbinary[this.i])
                        {
                            this.i++;
                            num2 = this.bitstobytes(12, false) + 320;
                            this.copytuple(num2, this.getlenghtofmatch());
                        }
                    }
                }
            }
            byte[] destinationArray = new byte[this.j - j];
            Array.Copy(this.decHistory, j, destinationArray, 0, this.j - j);
            return destinationArray;
        }

        private int getlenghtofmatch()
        {
            int bits = 0;
            while (this.srcbinary[this.i])
            {
                bits++;
                this.i++;
            }
            if (bits == 0)
            {
                this.i++;
                return 3;
            }
            this.i++;
            return this.bitstobytes(bits, true);
        }

        public byte[] PseudoCompressMppc(byte[] src)
        {
            int num3;
            BitArray outputbits = new BitArray((src.Length * 9) + 11);
            int from = 0;
            int num2 = 0;
            BitArray array2 = new BitArray(src);
            try
            {
                this.ReOrderBitArray(array2);
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception.ToString());
            }
            while (from < array2.Length)
            {
                if (array2[from])
                {
                    outputbits[from + num2] = true;
                    num2++;
                    outputbits[from + num2] = false;
                    this.Copy(array2, from + 1, outputbits, (from + num2) + 1, 7);
                    from += 8;
                }
                else
                {
                    this.Copy(array2, from, outputbits, from + num2, 8);
                    from += 8;
                }
            }
            for (num3 = 0; num3 < 4; num3++)
            {
                outputbits[(from + num2) + num3] = true;
            }
            from += 4;
            for (num3 = 0; num3 < 6; num3++)
            {
                outputbits[(from + num2) + num3] = false;
            }
            from += 6;
            outputbits.Length = (((from + num2) % 8) == 0) ? (from + num2) : ((from + num2) + (8 - ((from + num2) % 8)));
            this.ReOrderBitArray(outputbits);
            return this.BitsToBytesCompressor(outputbits, outputbits.Length);
        }

        public void ReOrderBitArray(BitArray src)
        {
            for (int i = 0; i < src.Length; i += 8)
            {
                for (int j = 0; j < 4; j++)
                {
                    bool flag = src[i + j];
                    src[i + j] = src[i + (7 - j)];
                    src[i + (7 - j)] = flag;
                }
            }
        }

        public void resetHistory()
        {
            this.decHistory = new byte[0x1fc4];
            this.j = 0;
        }
    }

Использование MPPC

MPPC Compressor = new MPPC();
// Распаковка
data = Compressor.decompresMccp(data, 0);

RC4 (C#)

 public class RC4
    {
        byte[] S = new byte[256];

        int x = 0;
        int y = 0;

        public RC4(byte[] key)
        {
            init(key);
        }

        // Key-Scheduling Algorithm 
        // Алгоритм ключевого расписания 
        private void init(byte[] key)
        {
            int keyLength = key.Length;

            for (int i = 0; i < 256; i++)
            {
                S[i] = (byte)i;
            }

            int j = 0;
            for (int i = 0; i < 256; i++)
            {
                j = (j + S[i] + key[i % keyLength]) % 256;
                S.Swap(i, j);
            }
        }

        public byte[] Encode(byte[] dataB, int size)
        {
            byte[] data = dataB.Take(size).ToArray();

            byte[] cipher = new byte[data.Length];

            for (int m = 0; m < data.Length; m++)
            {
                cipher[m] = (byte)(data[m] ^ keyItem());
            }

            return cipher;
        }
        public byte[] Decode(byte[] dataB, int size)
        {
            return Encode(dataB, size);
        }

        // Pseudo-Random Generation Algorithm 
        // Генератор псевдослучайной последовательности 
        private byte keyItem()
        {
            x = (x + 1) % 256;
            y = (y + S[x]) % 256;

            S.Swap(x, y);

            return S[(S[x] + S[y]) % 256];
        }
    }

    static class SwapExt
    {
        public static void Swap<T>(this T[] array, int index1, int index2)
        {
            T temp = array[index1];
            array[index1] = array[index2];
            array[index2] = temp;
        }
    }

RC4 (Delphi)

{
  Unit: uRC4 // RC4 Encryption
  Author: Andreas J”nsson
  Original: freevbcode.com/ShowCode.asp?ID=4398
  Ported by: steve10120
  Website: hackhound.org
}
unit uRC4;

interface

uses Windows;
function RC4(Expression, Password:string):string;

type
  TByteArray = array of Byte;

implementation

procedure Move(Destination, Source: Pointer; dLength:Cardinal);
begin
  CopyMemory(Destination, Source, dLength);
end;

function RC4(Expression, Password:string):string;
var
  RB:         array[0..255] of integer;
  X, Y, Z:    LongInt;
  Key:        TByteArray;
  ByteArray:  TByteArray;
  Temp:       Byte;
begin
  if Length(Password) = 0 then
    Exit;
  if Length(Expression) = 0 then
    Exit;
  if Length(Password) > 256 then
  begin
    SetLength(Key, 256);
    Move(@Key[0], @Password[1], 256)
  end
  else
  begin
    SetLength(Key, Length(Password));
    Move(@Key[0], @Password[1], Length(Password));
  end;
  for X := 0 to 255 do
    RB[X] := X;
  X := 0;
  Y := 0;
  Z := 0;
  for X := 0 to 255 do
  begin
    Y := (Y + RB[X] + Key[X mod Length(Password)]) mod 256;
    Temp := RB[X];
    RB[X] := RB[Y];
    RB[Y] := Temp;
  end;
  X := 0;
  Y := 0;
  Z := 0;
  SetLength(ByteArray, Length(Expression));
  Move(@ByteArray[0], @Expression[1], Length(Expression));
  for X := 0 to Length(Expression) - 1 do
  begin
    Y := (Y + 1) mod 256;
    Z := (Z + RB[Y]) mod 256;
    Temp := RB[Y];
    RB[Y] := RB[Z];
    RB[Z] := Temp;
    ByteArray[X] := ByteArray[X] xor (RB[(RB[Y] + RB[Z]) mod 256]);
  end;
  SetLength(Result, Length(Expression));
  Move(@Result[1], @ByteArray[0], Length(Expression));
end;

end.

Пример использования RC4 (C#)

byte[] key = ASCIIEncoding.ASCII.GetBytes("Key");

RC4 encoder = new RC4(key);
string testString = "Plaintext";
byte[] testBytes = ASCIIEncoding.ASCII.GetBytes(testString);
byte[] result = encoder.Encode(testBytes, testBytes.Length);

RC4 decoder = new RC4(key);
byte[] decryptedBytes = decoder.Decode(result, result.Length);
string decryptedString = ASCIIEncoding.ASCII.GetString(decryptedBytes);

Пример использования RC4 (Delphi)

procedure TForm1.Button2Click(Sender: TObject);
var
  key_str: string;
  test_string: string;
  encode_string: string;
  decode_string: string;
begin
  key_str := 'Key';
  test_string := 'Plaintext';
  encode_string := RC4(test_string,key_str);
  decode_string := RC4(encode_string, key_str);
end;

Цитата: Сообщение от TBX1n зашифровка и расшифровка это одна и та же функция.

Цитата: Сообщение от krysun public byte[] Decode(byte[] dataB, int size) { return Encode(dataB, size); }

Т.е., добавлена функция только для наглядности.
Понял, спасибо, TBX1n.


Следующий вопрос по ключам (знаю, было, видел... Но не допонял алгоритма):
S2C <- 0x02 SMKey
C2S -> 0x02 CMKey

HMACMD5(Login){Hash + EncHash} - этим ключом мы шифруем трафик (в том числе и CMKey),
А расшифровываем тем, что отправили в CMKey?

[Kitsune]

Цитата: Сообщение от krysun как я понял, упаковщика ни у кого нет

Есть. Другое дело, что его никто не даст

Цитата: Сообщение от krysun т.к., по большому счету, он и не нужен...

А как же свой сервер написать или же двойной прокси?

Цитата: Сообщение от krysun А расшифровываем тем, что отправили в CMKey?

Да. Сначала расшифровываем, а потом разжимаем.

[krysun]

Цитата: Сообщение от TBX1n Другое дело, что его никто не даст

Как найду, - всем дам =))

Цитата: Сообщение от TBX1n А как же свой сервер написать

Извращенцы!

[FreePVP)))]

Цитата: Сообщение от krysun Извращенцы!

Цитата: Сообщение от krysun Как найду, - всем дам =))

Я у ангел ему спер псевдоупаковщик
Если вы не хотите все идеализировать, то вам его хватит

[krysun]

Товарищи, не могу никак распаковать.
Расшифровать, - расшифровал, а mppc ругается
^^Индекс находился вне границ массива...
Пользуюсь mppc из 3-го топика этой темы.
bag.jpg
...
Подсобите нормальным (рабочим) унпакером =(
Я в C#, мягко говоря, "плаваю"...

[GO.BLiN]

Стартанул новый ogg-проект) на Node.js)
Есть информация по анпакеру?
Или хотя бы намекните в чем различия между оригинальным MPPC (я забросил прошлый проект на C++, решил возродить. Но с тех пор нас покинул pwlab и более я нигде не могу найти информации).

[wajskopf]

Реализацией МРРС на рнр случайно никто не владеет? Не говорите, что я извращенец))

[Smertig]

Цитата: Сообщение от wajskopf Реализацией МРРС на рнр случайно никто не владеет? Не говорите, что я извращенец))

Этот код легко можно портировать:
Спойлер

using System;
using System.Collections.Generic;
 
namespace Chrono.Network.Security
{
    public class MppcUnpacker
    {
        private int code1;
        private int code2;
        private int code3;
        private int code4;
 
        private byte packedOffset;
 
        private readonly List<byte> packedBytes;
        private readonly List<byte> unpackedBytes;
        private List<byte> unpackedChunk;
 
        public MppcUnpacker()
        {
            code3 = 0;
            code4 = 0;
 
            packedBytes = new List<byte>();
            unpackedBytes = new List<byte>();
        }
 
        public byte[] Unpack(byte packedByte)
        {
            packedBytes.Add(packedByte);
 
            unpackedChunk = new List<byte>();
 
            if (unpackedBytes.Count >= 10240)
                unpackedBytes.RemoveRange(0, 2048);
 
            for (; ; )
            {
                if (code3 == 0)
                {
                    if (HasBits(4))
                    {
                        if (GetPackedBits(1) == 0)
                        {
                            // 0-xxxxxxx
                            code1 = 1;
                            code3 = 1;
                        }
                        else
                        {
                            if (GetPackedBits(1) == 0)
                            {
                                // 10-xxxxxxx
                                code1 = 2;
                                code3 = 1;
                            }
                            else
                            {
                                if (GetPackedBits(1) == 0)
                                {
                                    // 110-xxxxxxxxxxxxx-*
                                    code1 = 3;
                                    code3 = 1;
                                }
                                else
                                {
                                    if (GetPackedBits(1) == 0)
                                    {
                                        // 1110-xxxxxxxx-*
                                        code1 = 4;
                                        code3 = 1;
                                    }
                                    else
                                    {
                                        // 1111-xxxxxx-*
                                        code1 = 5;
                                        code3 = 1;
                                    }
                                }
                            }
                        }
                    }
                    else
                        break;
                }
                else if(code3 == 1)
                {
                    if (code1 == 1)
                    {
                        if (HasBits(7))
                        {
                            var outB = (byte)GetPackedBits(7);
                            unpackedChunk.Add(outB);
                            unpackedBytes.Add(outB);
                            code3 = 0;
                        }
                        else
                            break;
                    }
                    else if (code1 == 2)
                    {
                        if (HasBits(7))
                        {
                            var outB = (byte)(GetPackedBits(7) | 0x80);
                            unpackedChunk.Add(outB);
                            unpackedBytes.Add(outB);
                            code3 = 0;
                        }
                        else
                            break;
                    }
                    else if (code1 == 3)
                    {
                        if (HasBits(13))
                        {
                            code4 = (int)GetPackedBits(13) + 0x140;
                            code3 = 2;
                        }
                        else
                            break;
                    }
                    else if (code1 == 4)
                    {
                        if (HasBits(8))
                        {
                            code4 = (int)GetPackedBits(8) + 0x40;
                            code3 = 2;
                        }
                        else
                            break;
                    }
                    else if (code1 == 5)
                    {
                        if (HasBits(6))
                        {
                            code4 = (int)GetPackedBits(6);
                            code3 = 2;
                        }
                        else 
                            break;
                    }
                }
                else if (code3 == 2)
                {
                    if (code4 == 0)
                    {
                        // Guess !!!
                        if (packedOffset != 0)
                        {
                            packedOffset = 0;
                            packedBytes.RemoveAt(0);
                        }
                        code3 = 0;
                        continue;
                    }
                    code2 = 0;
                    code3 = 3;
                }
                else if (code3 == 3)
                {
                    if (HasBits(1))
                    {
                        if (GetPackedBits(1) == 0)
                        {
                            code3 = 4;
                        }
                        else
                        {
                            code2++;
                        }
                    }
                    else
                        break;
                }
                else if (code3 == 4)
                {
                    int copySize;
 
                    if (code2 == 0)
                    {
                        copySize = 3;
                    }
                    else
                    {
                        var size = code2 + 1;
 
                        if (HasBits(size))
                        {
                            copySize = (int) GetPackedBits(size) + (1 << size);
                        }
                        else
                            break;
                    }
 
                    Copy(code4, copySize, ref unpackedChunk);
                    code3 = 0;
                }
            }
 
            return unpackedChunk.ToArray();
        }
 
        public byte[] Unpack(byte[] compressedBytes)
        {
            var rtnList = new List<byte>(compressedBytes.Length);
 
            foreach (var b in compressedBytes)
            {
                rtnList.AddRange(Unpack(b));
            }
 
            return rtnList.ToArray();
        }
 
        private void Copy(int shift, int size, ref List<byte> unpackedChunkData)
        {
            for (var i = 0; i < size; i++)
            {
                var pIndex = unpackedBytes.Count - shift;
 
                if (pIndex < 0) 
                    return;
 
                var b = unpackedBytes[pIndex];
                unpackedBytes.Add(b);
                unpackedChunkData.Add(b);
            }
        }
 
        private uint GetPackedBits(int bitCount)
        {
            if (bitCount > 16) 
                return 0;
 
            if (!HasBits(bitCount))
                throw new Exception("Unpack bit stream overflow");
 
            var alBitCount = bitCount + packedOffset;
            var alByteCount = (alBitCount + 7) / 8;
 
            uint v = 0;
 
            for (var i = 0; i < alByteCount; i++)
            {
                v |= (uint) (packedBytes[i]) << (24 - i * 8);
            }
 
            v <<= packedOffset;
            v >>= 32 - bitCount;
 
            packedOffset += (byte)bitCount;
            var freeBytes = packedOffset / 8;
 
            if (freeBytes != 0)
                packedBytes.RemoveRange(0, freeBytes);
 
            packedOffset %= 8;
            return v;
        }
 
        private bool HasBits(int count)
        {
            return (packedBytes.Count * 8 - packedOffset) >= count;
        }
    }
}

P.S.

Все мы по-своему извращенцы [Ссылки могут видеть только зарегистрированные пользователи. ]

[Nek1t]

wajskopf, переписать не сложно, тем более php по функционалу будет несколько лучше. Просто переписывайте строка за строкой используя средства вашего языка.


P.S. У нас массив байт представлен как строка. Может это вам поможет.

[wajskopf]

Покажите пожалуйста кусочек кода где вызывается вышеуказанная функция распаковки.

Цитата: Этот код легко можно портировать:

Надо вызывать public byte[] Unpack(byte packedByte)?
или public MppcUnpacker()?
Просто в РНР используются простые функции, а в шарпе классы. С классами не дружу, к сожалению, поэтому пока сложно портировать код.

[Nek1t]

Цитата: Сообщение от wajskopf Покажите пожалуйста кусочек кода где вызывается вышеуказанная функция распаковки. Надо вызывать public byte[] Unpack(byte packedByte)? или public MppcUnpacker()? Просто в РНР используются простые функции, а в шарпе классы. С классами не дружу, к сожалению, поэтому пока сложно портировать код.

В аутоит тоже простые функции
У нас сделано так:
[Ссылки могут видеть только зарегистрированные пользователи. ]

[wajskopf]

Может ли распакованный пакет совпадать с исходным (расшифрованным)?

[Nek1t]

Цитата: Сообщение от wajskopf Может ли распакованный пакет совпадать с исходным (расшифрованным)?

Ну 123456 у нас совпадал