[Release] The New Cryptography [Cast-128/Cast-5]

[chickmagnet]

Originally Posted by Mr_PoP

that's not quit correct even if it worked!

it works fine for this dont think it matters much since it allow a login which is wat its supose 2 do

[Spirited]

Originally Posted by Mr_PoP

that's not quit correct even if it worked!

There are many ways of implementing it.
This is the way that I found. ._.
Just because it's different doesn't mean that it isn't correct.

[Iron~Man]

Since what patch is this cryptography?

[lostsolder05]

Originally Posted by Iron~Man

Since what patch is this cryptography?

5509

[Mr_PoP]

Originally Posted by Fаng

There are many ways of implementing it.
This is the way that I found. ._.
Just because it's different doesn't mean that it isn't correct.

it's not correct because you're allocating mroe than cast_st needs

[Spirited]

Originally Posted by Mr_PoP

it's not correct because you're allocating mroe than cast_st needs

That doesn't have anything to do with the thread I posted.
That's their file's code.

[CØĐ£Ř||Mã©hÍñє]

not working changed them all

PHP Code:

using System;
using System.Runtime.InteropServices;

namespace Conquer_Online_Server.Network.Cryptography
{
    public class GameCryptography
    {
        Blowfish _blowfish;
        public GameCryptography(byte[] key)
        {
            _blowfish = new Blowfish(BlowfishAlgorithm.CFB64);
            _blowfish.SetKey(key);
        }

        public void Decrypt(byte[] packet)
        {
            byte[] buffer = _blowfish.Decrypt(packet);
            System.Buffer.BlockCopy(buffer, 0, packet, 0, buffer.Length);
        }

        public void Encrypt(byte[] packet)
        {
            byte[] buffer = _blowfish.Encrypt(packet);
            System.Buffer.BlockCopy(buffer, 0, packet, 0, buffer.Length);
        }

        public Blowfish Blowfish
        {
            get { return _blowfish; }
        }
        public void SetKey(byte[] k)
        {
            _blowfish.SetKey(k);
        }
        public void SetIvs(byte[] i1, byte[] i2)
        {
            _blowfish.EncryptIV = i1;
            _blowfish.DecryptIV = i2;
        }
    }

    public enum BlowfishAlgorithm
    {
        ECB,
        CBC,
        CFB64,
        OFB64,
    };

    public class Blowfish : IDisposable
    {
        [DllImport("libeay32.dll")]
        public extern static void CAST_set_key(IntPtr _key, int len, byte[] data);

        [DllImport("libeay32.dll")]
        public extern static void BF_ecb_encrypt(byte[] in_, byte[] out_, IntPtr schedule, int enc);

        [DllImport("libeay32.dll")]
        public extern static void BF_cbc_encrypt(byte[] in_, byte[] out_, int length, IntPtr schedule, byte[] ivec, int enc);

        [DllImport("libeay32.dll")]
        public extern static void CAST_cfb64_encrypt(byte[] in_, byte[] out_, int length, IntPtr schedule, byte[] ivec, ref int num, int enc);

        [DllImport("libeay32.dll")]
        public extern static void BF_ofb64_encrypt(byte[] in_, byte[] out_, int length, IntPtr schedule, byte[] ivec, out int num);

        [StructLayout(LayoutKind.Sequential)]
        struct bf_key_st
        {
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 18)]
            public UInt32[] P;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1024)]
            public UInt32[] S;
        }

        private BlowfishAlgorithm _algorithm;
        private IntPtr _key;
        private byte[] _encryptIv;
        private byte[] _decryptIv;
        private int _encryptNum;
        private int _decryptNum;

        public Blowfish(BlowfishAlgorithm algorithm)
        {
            _algorithm = algorithm;
            _encryptIv = new byte[8] { 0, 0, 0, 0, 0, 0, 0, 0 };
            _decryptIv = new byte[8] { 0, 0, 0, 0, 0, 0, 0, 0 };
            bf_key_st key = new bf_key_st();
            key.P = new UInt32[16 + 2];
            key.S = new UInt32[4 * 256];
            _key = Marshal.AllocHGlobal(key.P.Length * sizeof(UInt32) + key.S.Length * sizeof(UInt32));
            Marshal.StructureToPtr(key, _key, false);
            _encryptNum = 0;
            _decryptNum = 0;
        }

        public void Dispose()
        {
            Marshal.FreeHGlobal(_key);
        }

        public void SetKey(byte[] data)
        {
            _encryptNum = 0;
            _decryptNum = 0;
            CAST_set_key(_key, data.Length, data);
        }

        public byte[] Encrypt(byte[] buffer)
        {
            byte[] ret = new byte[buffer.Length];
            switch (_algorithm)
            {
                case BlowfishAlgorithm.ECB:
                    BF_ecb_encrypt(buffer, ret, _key, 1);
                    break;
                case BlowfishAlgorithm.CBC:
                    BF_cbc_encrypt(buffer, ret, buffer.Length, _key, _encryptIv, 1);
                    break;
                case BlowfishAlgorithm.CFB64:
                    CAST_cfb64_encrypt(buffer, ret, buffer.Length, _key, _encryptIv, ref _encryptNum, 1);
                    break;
                case BlowfishAlgorithm.OFB64:
                    BF_ofb64_encrypt(buffer, ret, buffer.Length, _key, _encryptIv, out _encryptNum);
                    break;
            }
            return ret;
        }

        public byte[] Decrypt(byte[] buffer)
        {
            byte[] ret = new byte[buffer.Length];
            switch (_algorithm)
            {
                case BlowfishAlgorithm.ECB:
                    BF_ecb_encrypt(buffer, ret, _key, 0);
                    break;
                case BlowfishAlgorithm.CBC:
                    BF_cbc_encrypt(buffer, ret, buffer.Length, _key, _decryptIv, 0);
                    break;
                case BlowfishAlgorithm.CFB64:
                    CAST_cfb64_encrypt(buffer, ret, buffer.Length, _key, _decryptIv, ref _decryptNum, 0);
                    break;
                case BlowfishAlgorithm.OFB64:
                    BF_ofb64_encrypt(buffer, ret, buffer.Length, _key, _decryptIv, out _decryptNum);
                    break;
            }
            return ret;
        }

        public byte[] EncryptIV
        {
            get { return _encryptIv; }
            set { System.Buffer.BlockCopy(value, 0, _encryptIv, 0, 8); }
        }

        public byte[] DecryptIV
        {
            get { return _decryptIv; }
            set { System.Buffer.BlockCopy(value, 0, _decryptIv, 0, 8); }
        }
    }
} 


[_DreadNought_]

If it doesnt work you've done it wrong, im not going to look thru the code you posted.

[12tails]

how did u changed why the BF is there yet?

BF_ecb_encryp???? its CAST NOT BF!!

[CØĐ£Ř||Mã©hÍñє]

Originally Posted by _DreadNought_

If it doesnt work you've done it wrong, im not going to look thru the code you posted.

nothing with your business never asked you to look out that thread got thread owner he can answer whats wrong i did and yes thanks leo

[_DreadNought_]

Originally Posted by CØĐ£Ř||Mã©hÍñє

nothing with your business never asked you to look out that thread got thread owner he can answer whats wrong i did and yes thanks leo

Not converted this to unsafe(quicker processing) or cleaned it, Just a quick sketch on actually logging in with the new algorithm.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ConquerSource.Core;
using System.Runtime.InteropServices;

namespace ConquerSource.Game.Cryptography
{
    public class GameCrypto
    {
        readonly CAST5 _Cast;
        public GameCrypto(byte[] key)
        {
            _Cast = new CAST5(CastAlgorithm.CFB64);
            _Cast.SetKey(key);
        }

        public void Decrypt(byte[] packet)
        {
            byte[] buffer = _Cast.Decrypt(packet);
            Buffer.BlockCopy(buffer, 0, packet, 0, buffer.Length);
        }

        public void Encrypt(byte[] packet)
        {
            byte[] buffer = _Cast.Encrypt(packet);
            Buffer.BlockCopy(buffer, 0, packet, 0, buffer.Length);
        }

        public CAST5 Blowfish
        {
            get { return _Cast; }
        }
        public void SetKey(byte[] k)
        {
            _Cast.SetKey(k);
        }
        public void SetIvs(byte[] i1, byte[] i2)
        {
            _Cast.EncryptIV = i1;
            _Cast.DecryptIV = i2;
        }
    }

    public enum CastAlgorithm
    {
        ECB,
        CBC,
        CFB64,
        OFB64,
    };

    public class CAST5
    {
        [StructLayout(LayoutKind.Sequential)]
        struct CAST_key_st
        {
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 18)]
            public UInt32[] P;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1024)]
            public UInt32[] S;
        }
        private CastAlgorithm _Type;
        private IntPtr Key;
        private byte[] _EncryptIV;
        private byte[] _DecryptIV;
        private int _EncryptKey;
        private int _DecryptKey;

        public CAST5(CastAlgorithm AlgorithmType)
        {
            _Type = AlgorithmType;
            _EncryptIV = new byte[8];
            _DecryptIV = new byte[8];

            CAST_key_st key = new CAST_key_st();
            key.P = new UInt32[16 + 2];
            key.S = new UInt32[4 * 256];

            Key = Marshal.AllocHGlobal(key.P.Length * sizeof(UInt32) + key.S.Length * sizeof(UInt32));
            Marshal.StructureToPtr(key, Key, false);
        }
        public void SetKey(byte[] data)
        {
            Kernel.CAST_set_key(Key, data.Length, data);
            _DecryptKey = 0;
            _EncryptKey = 0;
        }

        public byte[] Encrypt(byte[] buffer)
        {
            byte[] ret = new byte[buffer.Length];
            switch (_Type)
            {
                case CastAlgorithm.CFB64:
                    Kernel.CAST_cfb64_encrypt(buffer, ret, buffer.Length, Key, _EncryptIV, out _EncryptKey, 1);
                    break;
            }
            return ret;
        }

        public byte[] Decrypt(byte[] buffer)
        {
            byte[] ret = new byte[buffer.Length];
            switch (_Type)
            {
                case CastAlgorithm.CFB64:
                    Kernel.CAST_cfb64_encrypt(buffer, ret, buffer.Length, Key, _DecryptIV, out _DecryptKey, 0);
                    break;
            }
            return ret;
        }

        public byte[] EncryptIV
        {
            get { return _EncryptIV; }
            set { Buffer.BlockCopy(value, 0, _EncryptIV, 0, 8); }
        }

        public byte[] DecryptIV
        {
            get { return _DecryptIV; }
            set { Buffer.BlockCopy(value, 0, _DecryptIV, 0, 8); }
        }
    }
}

        #region Cast5/Cast128
        [DllImport("libeay32.dll", CallingConvention = CallingConvention.Cdecl)]
        public extern static void CAST_set_key(IntPtr _key, int len, byte[] data);

        [DllImport("libeay32.dll", CallingConvention = CallingConvention.Cdecl)]
        public extern static void CAST_cfb64_encrypt(IntPtr _key, int len, byte[] data);

        [DllImport("libeay32.dll", CallingConvention = CallingConvention.Cdecl)]
        public extern static void CAST_cfb64_encrypt(byte[] in_, byte[] out_, int length, IntPtr schedule, byte[] ivec, out int num, int enc);
        #endregion

Suck it, noob.

[dego4ever]

Is there any help ?

[pro4never]

Originally Posted by Y u k i

Lowfyr gone, John came or wtf ever his name is, Ima quote something he posted at his introduction:



Now this all happened to fang releasing something.

if that wasnt an attempt of censoring, idk.

There has been no official word back on what the final decision was on the subject but all the threads magically re-appeared so I'd just say leave the whole topic dead unless they try to implement rules like this in the future.

No reason to bring up un-needed drama into an already rather dramatic forum/section

[Spirited]

I'm not helping anyone with this... none of you should be. If they can't follow such an easy guide- they don't deserve the help. They're obviously not trying.

[dego4ever]

Originally Posted by Fаng

I'm not helping anyone with this... none of you should be. If they can't follow such an easy guide- they don't deserve the help. They're obviously not trying.

thanks any way fang