clsXOREncryption.cs

// C# ClassLib
// http://csharp-classlib.sourceforge.net
//
//
// Copyright (C) 2005 Marcel Joachim Kloubert
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//

using System;
using System.Text;

namespace CSharp_ClassLib.Cryptography
{
        public class XOR : System.Object
        {
                private byte[] m_bExpression;
                private byte[] m_bKey;
                private System.Text.ASCIIEncoding m_oASCII;

                public XOR ()
                {
                        m_oASCII = new System.Text.ASCIIEncoding();
                        
                        KeyBytes = new byte[0];
                        ExpressionBytes = new byte[0];
                        
                        return;
                }
        
                public XOR (byte[] expression, byte[] key)
                {
                        this.m_oASCII = new ASCIIEncoding();
                        
                        this.KeyBytes = key;
                        ExpressionBytes = expression;
                }
                
                public XOR (byte[] expression)
                {
                        m_oASCII = new ASCIIEncoding();
                        
                        KeyBytes = new byte[0];
                        ExpressionBytes = expression;
                }
                
                public byte[] KeyBytes
                {
                        get { return this.m_bKey; }
                        set { this.m_bKey = value; }
                }
                
                public string KeyString
                {
                        get { return this.m_oASCII.GetString(KeyBytes); }
                        set { this.KeyBytes = this.m_oASCII.GetBytes(value); }
                }
                
                public string KeyHex
                {
                        get { return this.ToHexString(KeyBytes); }
                        set { this.KeyBytes = this.ToByteArray(value); }
                }

                public byte[] ExpressionBytes
                {
                        get { return this.m_bExpression; }
                        set { this.m_bExpression = value; }
                }
                
                public string ExpressionString
                {
                        get { return this.m_oASCII.GetString(this.ExpressionBytes); }
                        set { this.ExpressionBytes = this.m_oASCII.GetBytes(value); }
                }               
                
                public string ExpressionHex
                {
                        get { return this.ToHexString(this.ExpressionBytes); }
                        set { this.ExpressionBytes = this.ToByteArray(value); }
                }               
                
                public byte[] ExpressionEncryptedBytes
                {
                        get { return this.EncryptXOR(this.ExpressionBytes, this.KeyBytes); }
                        set { this.ExpressionBytes = this.EncryptXOR(value, this.KeyBytes); }
                }               
                
                public string ExpressionEncryptedHex
                {
                        get { return this.ToHexString(this.ExpressionEncryptedBytes); }
                        set { this.ExpressionEncryptedBytes = this.ToByteArray(value); }
                }               
                
                private byte[] EncryptXOR (byte[] Expression, byte[] Key)
                {
                        byte[] bResult = new byte[0];
                
                        if (null == Expression)
                                // empty expression
                                return bResult;
                        if (Expression.GetLength(0) < 1)
                                // empty expression
                                return bResult;
                
                        if (null == Key)
                                // key is null => no encryption
                                return Expression;
                        if (Key.GetLength(0) < 1)
                                // key is empty => no encryption
                                return Expression;

                        int i = 0;
                        bResult = new byte[Expression.GetLength(0)];

                        // encrypt the expression
                        for (i = 0; i < Expression.GetLength(0); i++)
                                bResult[i] = (byte)(Expression[i] ^ Key[(int)(i % Key.GetLength(0))]);
        
                        return bResult;
                }
                
                private string ToHexString (byte[] Expression)
                {
                        if (null == Expression)
                                return "";
                                
                        int i = 0;
                        byte bHigh = 0;
                        byte bLow = 0;
                        string strBuffer = "";
                        string strHexString = "0123456789ABCDEF";

                        for (i = 0; i < Expression.GetLength(0); i++)
                        {
                                // calc the high & the low byte
                                bHigh = (byte)System.Math.Floor((double)Expression[i] / 16.0);
                                bLow = (byte)(Expression[i] % 16);
        
                                // add the character as 2-character-hex-expression
                                strBuffer += strHexString.Substring(bHigh, 1) + strHexString.Substring(bLow, 1);
                        }
                
                        return strBuffer;
                }
                
                private byte[] ToByteArray (string Expression)
                {
                        byte[] bResult;
                
                        if ("" == Expression)
                        {
                                // empty expression
                        
                                bResult = new byte[0];
                                return bResult;
                        }

                        if (0 != (Expression.Length % 2))
                                // invalid format                       
                                throw (new System.ArgumentException("Wrong expression size!", "Expression"));

                        int i = 0;
                        string strHexString = "0123456789ABCDEF";
                        string strString = "";
                        bResult = new byte[(int)System.Math.Floor(Expression.Length / 2.0)];

                        for (i = 0; i < bResult.GetLength(0); i++)
                        {
                                bResult[i] = 0;
                        
                                // high byte
                                strString = Expression.Substring(i * 2, 1).ToUpper();
                                if (strHexString.IndexOf(strString) > -1)
                                        // is a hex character => set the high byte
                                        bResult[i] += (byte)(16 * strHexString.IndexOf(strString));
                                else
                                        // no hex char => exception                             
                                        throw (new System.ArgumentException("No hex string!", "Expression"));
                        
                                // low byte
                                strString = Expression.Substring(i * 2 + 1, 1).ToUpper();
                                if (strHexString.IndexOf(strString) > -1)
                                        // is a hex character => set the low byte
                                        bResult[i] += (byte)(strHexString.IndexOf(strString));
                                else
                                        // no hex char => exception
                                        throw (new System.ArgumentException("No hex string!", "Expression"));
                        }

                        return bResult;
                }
        }
}

---