示例#1
0
    public bool PosTest1()
    {
        bool retVal = true;

        UnicodeEncoding expectedValue = new UnicodeEncoding(false,true);
        UnicodeEncoding actualValue;

        TestLibrary.TestFramework.BeginScenario("PosTest1:Create a instance");
        try
        {
            actualValue = new UnicodeEncoding();

            if (!expectedValue.Equals(actualValue))
            {
                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
                retVal = false;
            }

        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
            retVal = false;
        }
        return retVal;
    }
    public bool PosTest1()
    {
        bool retVal = true;

        UnicodeEncoding uEncoding = new UnicodeEncoding();

        int expectedValue = 0;
        int actualValue;

        TestLibrary.TestFramework.BeginScenario("PosTest1:Invoke the method with a empty String.");
        try
        {
            actualValue = uEncoding.GetByteCount("");

            if (expectedValue != actualValue)
            {
                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
                retVal = false;
            }

        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
            retVal = false;
        }
        return retVal;
    }
示例#3
0
        public static void VerifyUnicodeEncoding(UnicodeEncoding encoding, bool bigEndian, bool byteOrderMark, bool throwOnInvalidBytes)
        {
            if (byteOrderMark)
            {
                if (bigEndian)
                {
                    Assert.Equal(new byte[] { 0xfe, 0xff }, encoding.GetPreamble());
                }
                else
                {
                    Assert.Equal(new byte[] { 0xff, 0xfe }, encoding.GetPreamble());
                }
            }
            else
            {
                Assert.Empty(encoding.GetPreamble());
            }

            if (throwOnInvalidBytes)
            {
                Assert.Equal(EncoderFallback.ExceptionFallback, encoding.EncoderFallback);
                Assert.Equal(DecoderFallback.ExceptionFallback, encoding.DecoderFallback);
            }
            else
            {
                Assert.Equal(new EncoderReplacementFallback("\uFFFD"), encoding.EncoderFallback);
                Assert.Equal(new DecoderReplacementFallback("\uFFFD"), encoding.DecoderFallback);
            }
        }
 public void PosTest1()
 {
     UnicodeEncoding uEncoding = new UnicodeEncoding();
     int actualValue;
     actualValue = uEncoding.GetByteCount("");
     Assert.Equal(0, actualValue);
 }
示例#5
0
 public void PosTest1()
 {
     UnicodeEncoding expectedValue = new UnicodeEncoding(false, true);
     UnicodeEncoding actualValue;
     actualValue = new UnicodeEncoding();
     Assert.Equal(expectedValue, actualValue);
 }
 public void PosTest3()
 {
     UnicodeEncoding uEncoding = new UnicodeEncoding();
     bool actualValue;
     actualValue = uEncoding.Equals(new TimeSpan());
     Assert.False(actualValue);
 }
    public bool PosTest2()
    {
        bool retVal = true;

        int expectedValue = 2;
        int actualValue;

        UnicodeEncoding uE = new UnicodeEncoding();

        TestLibrary.TestFramework.BeginScenario("PosTest2:Invoke the method and set byteCount as 1.");
        try
        {
            actualValue = uE.GetMaxCharCount(1);

            if (expectedValue != actualValue)
            {
                TestLibrary.TestFramework.LogError("003", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
                retVal = false;
            }

        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("004", "Unexpected exception:" + e);
            retVal = false;
        }
        return retVal;
    }
    public bool PosTest1()
    {
        bool retVal = true;

        int expectedValue;
        int actualValue;

        UnicodeEncoding uE1 = new UnicodeEncoding();
        UnicodeEncoding uE2 = new UnicodeEncoding();

        TestLibrary.TestFramework.BeginScenario("PosTest1:Invoke the method.");
        try
        {
            expectedValue = uE1.GetHashCode();
            actualValue = uE2.GetHashCode();

            if (expectedValue != actualValue)
            {
                TestLibrary.TestFramework.LogError("001", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
                retVal = false;
            }

        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
            retVal = false;
        }
        return retVal;
    }
示例#9
0
    public byte[] toByteArray()
    {
        UnicodeEncoding encoding = new UnicodeEncoding();
        byte[] player_bytes = encoding.GetBytes(player);
        byte[] description_bytes = encoding.GetBytes(description);
        byte[] bytes = new byte[12 + player_bytes.Length + description_bytes.Length + image.Length];

        int array_index = 0;
        KLFCommon.intToBytes(index).CopyTo(bytes, array_index);
        array_index += 4;

        KLFCommon.intToBytes(player_bytes.Length).CopyTo(bytes, array_index);
        array_index += 4;

        player_bytes.CopyTo(bytes, array_index);
        array_index += player_bytes.Length;

        KLFCommon.intToBytes(description_bytes.Length).CopyTo(bytes, array_index);
        array_index += 4;

        description_bytes.CopyTo(bytes, array_index);
        array_index += description_bytes.Length;

        image.CopyTo(bytes, array_index);

        return bytes;
    }
    public bool PosTest2()
    {
        bool retVal = true;

        UnicodeEncoding uEncoding1 = new UnicodeEncoding();
        UnicodeEncoding uEncoding2 = new UnicodeEncoding(false, false);

        bool expectedValue = false;
        bool actualValue;

        TestLibrary.TestFramework.BeginScenario("PosTest2:Invoke the method with two instance that not equal.");
        try
        {
            actualValue = uEncoding1.Equals(uEncoding2);

            if (expectedValue != actualValue)
            {
                TestLibrary.TestFramework.LogError("003", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
                retVal = false;
            }

        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("004", "Unexpected exception:" + e);
            retVal = false;
        }
        return retVal;
    }
    public bool PosTest2()
    {
        bool retVal = true;

        UnicodeEncoding uE = new UnicodeEncoding(true, true);

        Byte[] expectedValue = new Byte[] { 0xfe,0xff};
        Byte[] actualValue;

        TestLibrary.TestFramework.BeginScenario("PosTest2:Invoke the method with bigEndian true and byteOrderMark true.");
        try
        {
            actualValue = uE.GetPreamble();

            if (expectedValue.Equals(actualValue))
            {
                TestLibrary.TestFramework.LogError("003", "ExpectedValue(" + expectedValue + ") !=ActualValue(" + actualValue + ")");
                retVal = false;
            }

        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("004", "Unexpected exception:" + e);
            retVal = false;
        }
        return retVal;
    }
示例#12
0
        public void Ctor_Bool_Bool(bool bigEndian, bool byteOrderMark)
        {
            UnicodeEncoding encoding = new UnicodeEncoding(bigEndian, byteOrderMark);
            VerifyUnicodeEncoding(encoding, bigEndian, byteOrderMark, throwOnInvalidBytes: false);

            Ctor_Bool_Bool_Bool(bigEndian, byteOrderMark, throwOnInvalidBytes: true);
            Ctor_Bool_Bool_Bool(bigEndian, byteOrderMark, throwOnInvalidBytes: false);
        }
 public void PosTest1()
 {
     Char[] chars = new Char[] { };
     UnicodeEncoding uEncoding = new UnicodeEncoding();
     int actualValue;
     actualValue = uEncoding.GetByteCount(chars, 0, 0);
     Assert.Equal(0, actualValue);
 }
示例#14
0
 public void PosTest2()
 {
     UnicodeEncoding uEncoding1 = new UnicodeEncoding();
     UnicodeEncoding uEncoding2 = new UnicodeEncoding(false, false);
     bool actualValue;
     actualValue = uEncoding1.Equals(uEncoding2);
     Assert.False(actualValue);
 }
 public void PosTest3()
 {
     String str = GetString(1);
     UnicodeEncoding uEncoding = new UnicodeEncoding();
     int actualValue;
     actualValue = uEncoding.GetByteCount(str);
     Assert.Equal(2, actualValue);
 }
 public static IEnumerable<object[]> GetCharCount_TestData()
 {
     string randomString = EncodingHelpers.GetRandomString(10);
     byte[] randomBytes = new UnicodeEncoding().GetBytes(randomString);
     yield return new object[] { randomBytes, 0, randomBytes.Length, randomBytes.Length / 2 };
     yield return new object[] { randomBytes, 0, 0, 0 };
     yield return new object[] { randomBytes, randomBytes.Length, 0, 0 };
     yield return new object[] { randomBytes, 0, 2, 1 };
 }
        public void PosTest2()
        {
            int expectedValue = 2;
            int actualValue;
            UnicodeEncoding uE = new UnicodeEncoding();

            actualValue = uE.GetMaxCharCount(1);
            Assert.Equal(expectedValue, actualValue);
        }
 public void NegTest1()
 {
     UnicodeEncoding uEncoding = new UnicodeEncoding();
     int actualValue;
     Assert.Throws<ArgumentNullException>(() =>
     {
         actualValue = uEncoding.GetByteCount(null, 0, 0);
     });
 }
        public void PosTest3()
        {
            Char[] chars = GetCharArray(1);
            UnicodeEncoding uEncoding = new UnicodeEncoding();
            int actualValue;

            actualValue = uEncoding.GetByteCount(chars, 0, 1);
            Assert.Equal(2, actualValue);
        }
        public void PosTest3()
        {
            UnicodeEncoding uE = new UnicodeEncoding(false, true);
            Byte[] expectedValue = new Byte[] { 0xff, 0xfe };
            Byte[] actualValue;

            actualValue = uE.GetPreamble();
            Assert.Equal(expectedValue, actualValue);
        }
 public void PosTest3()
 {
     Char[] chars = GetCharArray(10);
     Byte[] bytes = new Byte[20];
     UnicodeEncoding uEncoding = new UnicodeEncoding();
     int actualValue;
     actualValue = uEncoding.GetBytes(chars, 0, 0, bytes, 20);
     Assert.Equal(0, actualValue);
 }
        public void NegTest2()
        {
            int actualValue;
            UnicodeEncoding uE = new UnicodeEncoding();

            Assert.Throws<ArgumentOutOfRangeException>(() =>
            {
                actualValue = uE.GetMaxByteCount(int.MaxValue / 2);
            });
        }
        public void PosTest3()
        {
            int byteCount = _generator.GetInt32(-55);
            int expectedValue = (byteCount + 1) / 2 + 1;
            int actualValue;
            UnicodeEncoding uE = new UnicodeEncoding();

            actualValue = uE.GetMaxCharCount(byteCount);
            Assert.Equal(expectedValue, actualValue);
        }
        public void NegTest1()
        {
            int actualValue;
            UnicodeEncoding uE = new UnicodeEncoding();

            Assert.Throws<ArgumentOutOfRangeException>(() =>
            {
                actualValue = uE.GetMaxCharCount(-1);
            });
        }
 public void NegTest3()
 {
     Char[] chars = GetCharArray(10);
     UnicodeEncoding uEncoding = new UnicodeEncoding();
     int actualValue;
     Assert.Throws<ArgumentOutOfRangeException>(() =>
     {
         actualValue = uEncoding.GetByteCount(chars, 5, -1);
     });
 }
        public void PosTest2()
        {
            String str = GetString(10);
            UnicodeEncoding uEncoding = new UnicodeEncoding();
            int actualValue;

            String temp = ToString(str);
            actualValue = uEncoding.GetByteCount(str);
            Assert.Equal(20, actualValue);
        }
        public void PosTest3()
        {
            String chars = GetString(10);
            Byte[] bytes = new Byte[30];
            UnicodeEncoding uEncoding = new UnicodeEncoding();
            int actualValue;

            actualValue = uEncoding.GetBytes(chars, 0, 0, bytes, 30);
            Assert.Equal(0, actualValue);
        }
示例#28
0
        public static IEnumerable<object[]> GetString_TestData()
        {
            string randomString = EncodingHelpers.GetRandomString(10);
            byte[] randomBytes = new UnicodeEncoding().GetBytes(randomString);
            yield return new object[] { randomBytes, 0, randomBytes.Length, randomString };

            yield return new object[] { randomBytes, 0, 2, randomString.Substring(0, 1) };
            yield return new object[] { randomBytes, 0, 0, string.Empty };
            yield return new object[] { randomBytes, randomBytes.Length, 0, string.Empty };
        }
        public void PosTest3()
        {
            int charCount = (_generator.GetInt32(-55) % Int32.MaxValue + 1) / 2;
            int expectedValue = (charCount + 1) * 2;
            int actualValue;
            UnicodeEncoding uE = new UnicodeEncoding();

            actualValue = uE.GetMaxByteCount(charCount);
            Assert.Equal(expectedValue, actualValue);
        }
示例#30
0
    // Use this for initialization
    private void Start()
    {
        int count;
        byte[] byteArray;
        char[] charArray;
        UnicodeEncoding uniEncoding = new UnicodeEncoding();

        // Create the data to write to the stream. 
        byte[] firstString = uniEncoding.GetBytes(
            "Invalid file path characters are: ");
        byte[] secondString = uniEncoding.GetBytes(
            "123456789");

        using (MemoryStream memStream = new MemoryStream(100))
        {
            // Write the first string to the stream.
            memStream.Write(firstString, 0, firstString.Length);

            // Write the second string to the stream, byte by byte.
            count = 0;
            while (count < secondString.Length)
            {
                memStream.WriteByte(secondString[count++]);
            }

            // Write the stream properties to the console.
            Debug.Log(String.Format(
                "Capacity = {0}, Length = {1}, Position = {2}\n",
                memStream.Capacity.ToString(),
                memStream.Length.ToString(),
                memStream.Position.ToString()));

            // Set the position to the beginning of the stream.
            memStream.Seek(0, SeekOrigin.Begin);

            // Read the first 20 bytes from the stream.
            byteArray = new byte[memStream.Length];
            count = memStream.Read(byteArray, 0, 20);

            // Read the remaining bytes, byte by byte. 
            while (count < memStream.Length)
            {
                byteArray[count++] =
                    Convert.ToByte(memStream.ReadByte());
            }

            // Decode the byte array into a char array 
            // and write it to the console.
            charArray = new char[uniEncoding.GetCharCount(
                byteArray, 0, count)];
            uniEncoding.GetDecoder().GetChars(
                byteArray, 0, count, charArray, 0);
            Debug.Log(charArray);
        }
    }
示例#31
0
 public static string UTF16BytesToString(byte[] input_in)
 {
     System.Text.UnicodeEncoding _enc = new UnicodeEncoding();
     return(_enc.GetString(input_in));
 }
示例#32
0
 public StreamString(Stream ioStream)
 {
     this.ioStream  = ioStream;
     streamEncoding = new UnicodeEncoding();
 }
示例#33
0
 public StreamString(Stream ioStream)
 {
     _ioStream  = ioStream;
     _sEncoding = new UnicodeEncoding();
 }
        //Method for extraction
        private void ExtractTest(string directory)
        {
            PropertyItem    propertyItem;
            ASCIIEncoding   ascii = new ASCIIEncoding();
            UnicodeEncoding uni   = new UnicodeEncoding();

            int[] tagDecimal = { 40091, 50971, 40094, 40095, 40092, 36867, 270 };

            /*  tagDecimal array stores Decimal Representation of relevant Exif properties tag ID
             *  40091 XPtitle ()              0
             *  50971 Date/time ISO8601       1
             *  40094 XPkeywords (category)   2
             *  40095 XPsubject (description) 3
             *  40092 XPcomment               4
             *  36867 DateTimeOriginal
             *   270  ImageComment
             */

            DirectoryInfo directoryInfo = new DirectoryInfo(directory);

            FileInfo[] files = directoryInfo.GetFiles("*.jpg");

            string[] imageFiles = Directory.GetFiles(directory, "*.jpg").Select(Path.GetFileName).ToArray();

            string[] extensions = new[] { ".jpg", ".jpeg", ".png" };

            FileInfo[] imagefiles =
                directoryInfo.EnumerateFiles()
                .Where(f => extensions.Contains(f.Extension.ToLower()))
                .ToArray();

            var varItem = (PropertyItem)FormatterServices.GetUninitializedObject(typeof(PropertyItem));

            propertyItem = varItem;             //PropertyItem contains no constructor that can be called without arguments, has a constructor with descernable arguments

            ImageData imageData = new ImageData();

            string[] tagID    = { "FN=", "DT=", "CT=", "DS=", "CM=", };
            string[] tagArray = new string[tagID.Length - 1];
            lines = new string[imageFiles.Length];

            for (int i = 0; i < imageFiles.Length; i++)
            {
                imageData.FileName = tagID[0] + imageFiles[i];

                string filePath  = directory + "\\" + imageFiles[i];
                Image  testimage = new Bitmap(filePath);

                string extention = imageData.FileName.Substring(imageData.FileName.Length - 4, 4); // (dataExtractor.imageData[i].data[n].Equals(input, StringComparison.OrdinalIgnoreCase))
                if (extention.Equals(".jpg", StringComparison.OrdinalIgnoreCase))
                {
                    //This loop stores Exif data into lines
                    for (int j = 1; j < tagID.Length; j++)
                    {
                        foreach (string singleTag in tagID)
                        {
                            {   //Set property item id to the relevant tag decimal tag ID
                                propertyItem.Id = tagDecimal[j];
                                //The were errors transfering ascii and unicode to strings, and string arrays
                                if (j == 1)                             //these were completely avoided by storing to imageData.data[n] instead of arrays in this class
                                {
                                    try
                                    {
                                        imageData.Date  = tagID[j];                                 //tagID[n] must be stored first storing after results in corrupted data
                                        propertyItem    = testimage.GetPropertyItem(tagDecimal[j]); //ASCII
                                        imageData.Date += ascii.GetString(propertyItem.Value);      //Date tag uses ascii encoding
                                    }
                                    catch
                                    {
                                        imageData.Date += "";
                                        //set to ""
                                    }
                                }
                                else
                                {
                                    try
                                    {
                                        imageData.data[j]  = tagID[j];
                                        propertyItem       = testimage.GetPropertyItem(tagDecimal[j]); //Unicode
                                        imageData.data[j] += uni.GetString(propertyItem.Value);        //all the other tags use unicode
                                    }
                                    catch
                                    {
                                        imageData.data[j] += "";
                                        //set to ""
                                    }
                                }
                            }
                        }
                    }
                }
                lines[i] = string.Join(",", imageData.data) + ",>";     //Now tags have been stored in imageData without being corrupted the data can now be stored in lines indirectly
            }
        }
        private static void UpdateSalary(UnicodeEncoding unicodeEncoding, MemoryStream ms, decimal salary)
        {
            string newValue = salary.ToString().PadRight(SalaryLength / 2);

            Updatefield(unicodeEncoding, ms, SalaryOffset, SalaryLength, newValue);
        }
示例#36
0
        public static int FindCredentials(IntPtr hLsass, OSVersionHelper oshelper, byte[] iv, byte[] aeskey, byte[] deskey, List <Logon> logonlist)
        {
            foreach (Logon logon in logonlist)
            {
                IntPtr credmanMem = logon.pCredentialManager;
                LUID   luid       = logon.LogonId;

                IntPtr llCurrent;
                int    reference = 1;

                //Console.WriteLine("[*] Credman  CredmanListSet found at address {0:X} {1:X}", luid.LowPart, credmanMem.ToInt64());

                byte[] credmansetBytes = Utility.ReadFromLsass(ref hLsass, credmanMem, Marshal.SizeOf(typeof(KIWI_CREDMAN_SET_LIST_ENTRY)));

                IntPtr pList1 = new IntPtr(BitConverter.ToInt64(credmansetBytes, Utility.FieldOffset <KIWI_CREDMAN_SET_LIST_ENTRY>("list1")));
                IntPtr refer  = IntPtr.Add(pList1, Utility.FieldOffset <KIWI_CREDMAN_LIST_STARTER>("start"));

                byte[] credmanstarterBytes = Utility.ReadFromLsass(ref hLsass, pList1, Marshal.SizeOf(typeof(KIWI_CREDMAN_LIST_STARTER)));

                IntPtr pStart = new IntPtr(BitConverter.ToInt64(credmanstarterBytes, Utility.FieldOffset <KIWI_CREDMAN_LIST_STARTER>("start")));

                if (pStart == IntPtr.Zero)
                {
                    continue;
                }

                llCurrent = pStart;

                if (llCurrent == refer)
                {
                    continue;
                }

                do
                {
                    byte[] entryBytes             = Utility.ReadFromLsass(ref hLsass, IntPtr.Subtract(llCurrent, Utility.FieldOffset <KIWI_CREDMAN_LIST_ENTRY>("Flink")), Marshal.SizeOf(typeof(KIWI_CREDMAN_LIST_ENTRY)));
                    KIWI_CREDMAN_LIST_ENTRY entry = Utility.ReadStruct <KIWI_CREDMAN_LIST_ENTRY>(entryBytes);

                    string username = Utility.ExtractUnicodeStringString(hLsass, entry.user);
                    string domain   = Utility.ExtractUnicodeStringString(hLsass, entry.server1);

                    string passDecrypted = "";

                    byte[] msvPasswordBytes          = Utility.ReadFromLsass(ref hLsass, entry.encPassword, entry.cbEncPassword);
                    byte[] msvDecryptedPasswordBytes = BCrypt.DecryptCredentials(msvPasswordBytes, iv, aeskey, deskey);

                    if (msvDecryptedPasswordBytes != null && msvDecryptedPasswordBytes.Length > 0)
                    {
                        UnicodeEncoding encoder = new UnicodeEncoding(false, false, true);
                        try
                        {
                            passDecrypted = encoder.GetString(msvDecryptedPasswordBytes);
                        }
                        catch (Exception)
                        {
                            passDecrypted = Utility.PrintHexBytes(msvDecryptedPasswordBytes);
                        }
                    }

                    if (!string.IsNullOrEmpty(username) && username.Length > 1)
                    {
                        Credential.CredMan credmanentry = new Credential.CredMan();
                        credmanentry.Reference = reference;
                        credmanentry.UserName  = username;

                        if (!string.IsNullOrEmpty(domain))
                        {
                            credmanentry.DomainName = domain;
                        }
                        else
                        {
                            credmanentry.DomainName = "[NULL]";
                        }

                        // Check if password is present
                        if (!string.IsNullOrEmpty(passDecrypted))
                        {
                            credmanentry.Password = passDecrypted;
                        }
                        else
                        {
                            credmanentry.Password = "******";
                        }

                        Logon currentlogon = logonlist.FirstOrDefault(x => x.LogonId.HighPart == luid.HighPart && x.LogonId.LowPart == luid.LowPart);
                        if (currentlogon == null)
                        {
                            currentlogon          = new Logon(luid);
                            currentlogon.UserName = username;
                            currentlogon.Credman  = new List <Credential.CredMan>();
                            currentlogon.Credman.Add(credmanentry);
                            logonlist.Add(currentlogon);
                        }
                        else
                        {
                            if (currentlogon.Credman == null)
                            {
                                currentlogon.Credman = new List <Credential.CredMan>();
                            }

                            currentlogon.Credman.Add(credmanentry);
                        }
                    }
                    reference++;
                    llCurrent = entry.Flink;
                } while (llCurrent != IntPtr.Zero && llCurrent != refer);
            }
            return(0);
        }
示例#37
0
        public static void DoEncryption(bool PayloadMode, bool InstallerMode, bool OpenURLOnStartupMode, bool CustomIconMode)
        {
            OpenFileDialog CryptFile = new OpenFileDialog();

            if (CryptFile.ShowDialog() == true)
            {
                if (MessageBox.Show("Are you sure you want to ecrypt " + CryptFile.FileName + "? You can decrypt it later if you need to" + Environment.NewLine + "Make sure that you remember your encryption key or your files will be GONE!", "Attention!", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes)
                {
                    try
                    {
                        if (PayloadMode == false && InstallerMode == false && OpenURLOnStartupMode == false && CustomIconMode == false)
                        {
                            string          password = @DataAndResources.KeysAndData.EKey;
                            UnicodeEncoding UE       = new UnicodeEncoding();
                            byte[]          key      = UE.GetBytes(password);

                            string          CryptFileDir    = CryptFile.FileName;
                            FileStream      CryptFileStream = new FileStream(CryptFileDir + ".AntCrypted", FileMode.Create);
                            RijndaelManaged RMCrypto        = new RijndaelManaged();

                            CryptoStream CryptoStream = new CryptoStream(CryptFileStream, RMCrypto.CreateEncryptor(key, key), CryptoStreamMode.Write);

                            FileStream FileOpenStream = new FileStream(CryptFileDir, FileMode.Open);

                            int data;
                            while ((data = FileOpenStream.ReadByte()) != -1)
                            {
                                CryptoStream.WriteByte((byte)data);
                            }

                            FileOpenStream.Close();
                            CryptoStream.Close();
                            CryptFileStream.Close();

                            File.Delete(CryptFile.FileName);

                            MessageBox.Show("File was ecrypted successfully!", "Information!", MessageBoxButton.OK, MessageBoxImage.Information);
                        }
                        else
                        {
                            string          password = @DataAndResources.KeysAndData.EKey;
                            UnicodeEncoding UE       = new UnicodeEncoding();
                            byte[]          key      = UE.GetBytes(password);

                            string          CryptFileDir    = CryptFile.FileName;
                            FileStream      CryptFileStream = new FileStream(CryptFileDir + ".AntCrypted", FileMode.Create);
                            RijndaelManaged RMCrypto        = new RijndaelManaged();

                            CryptoStream CryptoStream = new CryptoStream(CryptFileStream, RMCrypto.CreateEncryptor(key, key), CryptoStreamMode.Write);

                            FileStream FileOpenStream = new FileStream(CryptFileDir, FileMode.Open);

                            int data;
                            while ((data = FileOpenStream.ReadByte()) != -1)
                            {
                                CryptoStream.WriteByte((byte)data);
                            }

                            FileOpenStream.Close();
                            CryptoStream.Close();
                            CryptFileStream.Close();

                            EncryptedContent = File.ReadAllBytes(CryptFileDir + ".AntCrypted");

                            File.Delete(CryptFileDir + ".AntCrypted");

                            MessageBox.Show("File was ecrypted successfully! Payload mode was enabled please wait for the payload confirmation message!", "Information!", MessageBoxButton.OK, MessageBoxImage.Information);

                            PayloadWorker.Payload(EncryptedContent, InstallerMode, InstallerWorker.RawDirectory, OpenURLOnStartupMode, URLOnStartupWorker.StartupURI, CustomIconMode, CustomIconWorker.CustomIconDirectory, DataAndResources.KeysAndData.EKey, InstallerWorker.AppName, InstallerWindow.RunOnStartupSelected);
                        }
                    }
                    catch (Exception exc)
                    {
                        MessageBox.Show("Encryption failed, have you used a valid RijndaelManaged encryption key?Erro info: " + exc, "Warning!", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                }
            }
        }
        /// <include file='doc\ActiveXMessageFormatter.uex' path='docs/doc[@for="ActiveXMessageFormatter.Read"]/*' />
        /// <devdoc>
        ///    This method is used to read the contents from the given message
        ///     and create an object.
        /// </devdoc>
        public object Read(Message message)
        {
            if (message == null)
            {
                throw new ArgumentNullException("message");
            }

            Stream stream;

            byte[] bytes;
            byte[] newBytes;
            int    size;
            int    variantType = message.BodyType;

            switch (variantType)
            {
            case VT_LPSTR:
                bytes = message.properties.GetUI1Vector(NativeMethods.MESSAGE_PROPID_BODY);
                size  = message.properties.GetUI4(NativeMethods.MESSAGE_PROPID_BODY_SIZE);

                if (this.internalCharBuffer == null || this.internalCharBuffer.Length < size)
                {
                    this.internalCharBuffer = new char[size];
                }

                if (asciiEncoding == null)
                {
                    this.asciiEncoding = new ASCIIEncoding();
                }

                this.asciiEncoding.GetChars(bytes, 0, size, this.internalCharBuffer, 0);
                return(new String(this.internalCharBuffer, 0, size));

            case VT_BSTR:
            case VT_LPWSTR:
                bytes = message.properties.GetUI1Vector(NativeMethods.MESSAGE_PROPID_BODY);
                size  = message.properties.GetUI4(NativeMethods.MESSAGE_PROPID_BODY_SIZE) / 2;

                if (this.internalCharBuffer == null || this.internalCharBuffer.Length < size)
                {
                    this.internalCharBuffer = new char[size];
                }

                if (unicodeEncoding == null)
                {
                    this.unicodeEncoding = new UnicodeEncoding();
                }

                this.unicodeEncoding.GetChars(bytes, 0, size * 2, this.internalCharBuffer, 0);
                return(new String(this.internalCharBuffer, 0, size));

            case VT_VECTOR | VT_UI1:
                bytes    = message.properties.GetUI1Vector(NativeMethods.MESSAGE_PROPID_BODY);
                size     = message.properties.GetUI4(NativeMethods.MESSAGE_PROPID_BODY_SIZE);
                newBytes = new byte[size];
                Array.Copy(bytes, newBytes, size);

                return(newBytes);

            case VT_BOOL:
                bytes    = message.properties.GetUI1Vector(NativeMethods.MESSAGE_PROPID_BODY);
                newBytes = new byte[1];
                Array.Copy(bytes, newBytes, 1);
                if (bytes[0] != 0)
                {
                    return(true);
                }

                return(false);

            case VT_CLSID:
                bytes    = message.properties.GetUI1Vector(NativeMethods.MESSAGE_PROPID_BODY);
                newBytes = new byte[16];
                Array.Copy(bytes, newBytes, 16);
                return(new Guid(newBytes));

            case VT_CY:
                bytes    = message.properties.GetUI1Vector(NativeMethods.MESSAGE_PROPID_BODY);
                newBytes = new byte[8];
                Array.Copy(bytes, newBytes, 8);
                return(Decimal.FromOACurrency(BitConverter.ToInt64(newBytes, 0)));

            case VT_DATE:
                bytes    = message.properties.GetUI1Vector(NativeMethods.MESSAGE_PROPID_BODY);
                newBytes = new byte[8];
                Array.Copy(bytes, newBytes, 8);
                return(new DateTime(BitConverter.ToInt64(newBytes, 0)));

            case VT_I1:
            case VT_UI1:
                stream = message.BodyStream;
                bytes  = new byte[1];
                stream.Read(bytes, 0, 1);
                return(bytes[0]);

            case VT_I2:
                stream = message.BodyStream;
                bytes  = new byte[2];
                stream.Read(bytes, 0, 2);
                return(BitConverter.ToInt16(bytes, 0));

            case VT_UI2:
                stream = message.BodyStream;
                bytes  = new byte[2];
                stream.Read(bytes, 0, 2);
                return(BitConverter.ToUInt16(bytes, 0));

            case VT_I4:
                stream = message.BodyStream;
                bytes  = new byte[4];
                stream.Read(bytes, 0, 4);
                return(BitConverter.ToInt32(bytes, 0));

            case VT_UI4:
                stream = message.BodyStream;
                bytes  = new byte[4];
                stream.Read(bytes, 0, 4);
                return(BitConverter.ToUInt32(bytes, 0));

            case VT_I8:
                stream = message.BodyStream;
                bytes  = new byte[8];
                stream.Read(bytes, 0, 8);
                return(BitConverter.ToInt64(bytes, 0));

            case VT_UI8:
                stream = message.BodyStream;
                bytes  = new byte[8];
                stream.Read(bytes, 0, 8);
                return(BitConverter.ToUInt64(bytes, 0));

            case VT_R4:
                stream = message.BodyStream;
                bytes  = new byte[4];
                stream.Read(bytes, 0, 4);
                return(BitConverter.ToSingle(bytes, 0));

            case VT_R8:
                stream = message.BodyStream;
                bytes  = new byte[8];
                stream.Read(bytes, 0, 8);
                return(BitConverter.ToDouble(bytes, 0));

            case VT_NULL:
                return(null);

            case VT_STREAMED_OBJECT:
                stream = message.BodyStream;
                ComStreamFromDataStream comStream = new ComStreamFromDataStream(stream);
                return(NativeMethods.OleLoadFromStream(comStream, ref NativeMethods.IID_IUnknown));

            case VT_STORED_OBJECT:
                throw new NotSupportedException(Res.GetString(Res.StoredObjectsNotSupported));

            default:
                throw new InvalidOperationException(Res.GetString(Res.InvalidTypeDeserialization));
            }
        }
示例#39
0
        /// <summary>
        /// Encrypt a token with an RSA public key
        /// </summary>
        /// <param name="plainText">Plaintext string</param>
        /// <returns>Encrypted string</returns>
        public string Encrypt(string plainText)
        {
            //// read pem public key
            Stream s = System.Reflection.Assembly.GetExecutingAssembly().
                       GetManifestResourceStream("KountRisSdk.kount.rsa.public.key");

            System.IO.StreamReader reader = new System.IO.StreamReader(s, Encoding.UTF8);
            string pem = reader.ReadToEnd();

            string header = String.Format("-----BEGIN PUBLIC KEY-----");
            string footer = String.Format("-----END PUBLIC KEY-----");
            int    start  = pem.IndexOf(header, StringComparison.Ordinal) + header.Length;
            int    end    = pem.IndexOf(footer, start, StringComparison.Ordinal) - start;

            byte[] key = Convert.FromBase64String(pem.Substring(start, end));

            UnicodeEncoding converter = new UnicodeEncoding();

            byte[] plainBytes = converter.GetBytes(plainText);

            RSACryptoServiceProvider rsa = null;

            //// encoded OID sequence for PKCS #1 rsaEncryption szOID_RSA_RSA = "1.2.840.113549.1.1.1"
            byte[] seqOID = { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 };

            byte[] seq = new byte[15];

            //// Read the asn.1 encoded SubjectPublicKeyInfo blob
            System.IO.MemoryStream mem  = new System.IO.MemoryStream(key);
            System.IO.BinaryReader binr = new System.IO.BinaryReader(mem);
            byte   bt       = 0;
            ushort twobytes = 0;

            try
            {
                twobytes = binr.ReadUInt16();
                if (twobytes == 0x8130)
                {
                    //// data read as little endian order
                    //// (actual data order for Sequence is 30 81)
                    binr.ReadByte(); //// advance 1 byte
                }
                else if (twobytes == 0x8230)
                {
                    binr.ReadInt16(); //// advance 2 bytes
                }
                else
                {
                    return(null);
                }

                seq = binr.ReadBytes(15); //// read the Sequence OID
                if (!this.CompareBytearrays(seq, seqOID))
                {
                    //// make sure Sequence for OID is correct
                    return(null);
                }

                twobytes = binr.ReadUInt16();
                if (twobytes == 0x8103)
                {
                    //// data read as little endian order (actual data order for Bit String is 03 81)
                    binr.ReadByte(); //// advance 1 byte
                }
                else if (twobytes == 0x8203)
                {
                    binr.ReadInt16(); //// advance 2 bytes
                }
                else
                {
                    return(null);
                }

                bt = binr.ReadByte();
                if (bt != 0x00)
                {
                    //// expect null byte next
                    return(null);
                }

                twobytes = binr.ReadUInt16();
                if (twobytes == 0x8130)
                {
                    //// data read as little endian order (actual data order for Sequence is 30 81)
                    binr.ReadByte(); //// advance 1 byte
                }
                else if (twobytes == 0x8230)
                {
                    binr.ReadInt16(); //// advance 2 bytes
                }
                else
                {
                    return(null);
                }

                twobytes = binr.ReadUInt16();
                byte lowbyte  = 0x00;
                byte highbyte = 0x00;

                if (twobytes == 0x8102)
                {
                    //// data read as little endian order
                    //// (actual data order for Integer is 02 81)
                    lowbyte = binr.ReadByte();  //// read next bytes which is bytes in modulus
                }
                else if (twobytes == 0x8202)
                {
                    highbyte = binr.ReadByte(); //// advance 2 bytes
                    lowbyte  = binr.ReadByte();
                }
                else
                {
                    return(null);
                }

                byte[] modint =
                {
                    lowbyte, highbyte, 0x00, 0x00
                };

                int modsize = BitConverter.ToInt32(modint, 0);

                int firstbyte = binr.PeekChar();
                if (firstbyte == 0x00)
                {
                    //// if first byte (highest order) of modulus is zero, don't include it
                    binr.ReadByte(); //// skip this null byte
                    modsize -= 1;    //// reduce modulus buffer size by 1
                }

                byte[] modulus = binr.ReadBytes(modsize); //// read the modulus bytes
                if (binr.ReadByte() != 0x02)
                {
                    //// expect an Integer for the exponent data
                    return(null);
                }

                int    expbytes = (int)binr.ReadByte();
                byte[] exponent = binr.ReadBytes(expbytes);

                //// create RSACryptoServiceProvider instance and initialize public key
                rsa = new RSACryptoServiceProvider();
                RSAParameters rsaKeyInfo = new RSAParameters();
                rsaKeyInfo.Modulus  = modulus;
                rsaKeyInfo.Exponent = exponent;
                rsa.ImportParameters(rsaKeyInfo);
            }
            finally
            {
                binr.Close();
            }

            byte[] encryptedBytes = rsa.Encrypt(plainBytes, false);
            return(Convert.ToBase64String(encryptedBytes));
        }
示例#40
0
        public static string ByteToString(byte[] byteValue)
        {
            UnicodeEncoding ByteConverter = new UnicodeEncoding();

            return(ByteConverter.GetString(byteValue));
        }
示例#41
0
        public static byte[] StringToByte(string strValue)
        {
            UnicodeEncoding ByteConverter = new UnicodeEncoding();

            return(ByteConverter.GetBytes(strValue));
        }
示例#42
0
        public static void dotnetRSA()
        {
            try
            {
                Console.Clear();
                Console.Write("Введите сообщение: \n");
                string          message       = Console.ReadLine();
                UnicodeEncoding ByteConverter = new UnicodeEncoding();
                byte[]          dataToEncrypt = ByteConverter.GetBytes(message),
                encryptedData,
                decryptedData;
                string pathPrivateKey = "privateKey.xml",
                       pathPublicKey  = "publicKey.xml",
                       privateKey     = string.Empty,
                       publicKey      = string.Empty;
                using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
                {
                    RSAParameters RSAParametersPublic  = RSA.ExportParameters(false);
                    RSAParameters RSAParametersPrivate = RSA.ExportParameters(true);
                    if (File.Exists(pathPrivateKey) && File.Exists(pathPublicKey))
                    {
                        using (FileStream fs = File.OpenRead(pathPrivateKey))
                        {
                            byte[] array = new byte[fs.Length];
                            fs.Read(array, 0, array.Length);
                            privateKey = Encoding.Default.GetString(array);
                        }
                        using (FileStream fs = File.OpenRead(pathPublicKey))
                        {
                            byte[] array = new byte[fs.Length];
                            fs.Read(array, 0, array.Length);
                            publicKey = Encoding.Default.GetString(array);
                        }
                        RSA.FromXmlString(publicKey);
                        RSAParametersPublic = RSA.ExportParameters(false);
                        RSA.FromXmlString(privateKey);
                        RSAParametersPrivate = RSA.ExportParameters(true);
                    }
                    else
                    {
                        privateKey = RSA.ToXmlString(true);
                        publicKey  = RSA.ToXmlString(false);
                        using (FileStream fs = new FileStream(pathPrivateKey, FileMode.Create, FileAccess.Write))
                        {
                            byte[] array = Encoding.Default.GetBytes(privateKey);
                            fs.Write(array, 0, array.Length);
                        }
                        using (FileStream fs = new FileStream(pathPublicKey, FileMode.Create, FileAccess.Write))
                        {
                            byte[] array = Encoding.Default.GetBytes(publicKey);
                            fs.Write(array, 0, array.Length);
                        }
                        RSAParametersPublic  = RSA.ExportParameters(false);
                        RSAParametersPrivate = RSA.ExportParameters(true);
                    }

                    encryptedData = RSAdotnet.RSAEncrypt(dataToEncrypt, RSAParametersPublic, false);
                    Console.WriteLine("Зашифрованное сообщение:");
                    for (int i = 0; i < encryptedData.Length; i++)
                    {
                        Console.Write("{0} ", encryptedData[i]);
                    }

                    decryptedData = RSAdotnet.RSADecrypt(encryptedData, RSAParametersPrivate, false);
                    Console.WriteLine();
                    Console.WriteLine("Расшифрованное сообщение: {0}", ByteConverter.GetString(decryptedData));
                    Console.ReadKey();
                }
            }
            catch (ArgumentNullException)
            {
                Console.WriteLine("Ошибка шифрвоания!");
                Console.ReadKey();
            }
        }
        /// <include file='doc\ActiveXMessageFormatter.uex' path='docs/doc[@for="ActiveXMessageFormatter.Write"]/*' />
        /// <devdoc>
        ///    This method is used to write the given object into the given message.
        ///     If the formatter cannot understand the given object, an exception is thrown.
        /// </devdoc>
        public void Write(Message message, object obj)
        {
            if (message == null)
            {
                throw new ArgumentNullException("message");
            }

            Stream stream;
            int    variantType;

            if (obj is string)
            {
                int size = ((string)obj).Length * 2;
                if (this.internalBuffer == null || this.internalBuffer.Length < size)
                {
                    this.internalBuffer = new byte[size];
                }

                if (unicodeEncoding == null)
                {
                    this.unicodeEncoding = new UnicodeEncoding();
                }

                this.unicodeEncoding.GetBytes(((string)obj).ToCharArray(), 0, size / 2, this.internalBuffer, 0);
                message.properties.SetUI1Vector(NativeMethods.MESSAGE_PROPID_BODY, this.internalBuffer);
                message.properties.AdjustSize(NativeMethods.MESSAGE_PROPID_BODY, size);
                message.properties.SetUI4(NativeMethods.MESSAGE_PROPID_BODY_SIZE, size);
                message.properties.SetUI4(NativeMethods.MESSAGE_PROPID_BODY_TYPE, VT_LPWSTR);
                return;
            }
            else if (obj is byte[])
            {
                byte[] bytes = (byte[])obj;
                if (this.internalBuffer == null || this.internalBuffer.Length < bytes.Length)
                {
                    this.internalBuffer = new byte[bytes.Length];
                }

                Array.Copy(bytes, this.internalBuffer, bytes.Length);
                message.properties.SetUI1Vector(NativeMethods.MESSAGE_PROPID_BODY, this.internalBuffer);
                message.properties.AdjustSize(NativeMethods.MESSAGE_PROPID_BODY, bytes.Length);
                message.properties.SetUI4(NativeMethods.MESSAGE_PROPID_BODY_SIZE, bytes.Length);
                message.properties.SetUI4(NativeMethods.MESSAGE_PROPID_BODY_TYPE, VT_UI1 | VT_VECTOR);
                return;
            }
            else if (obj is char[])
            {
                char[] chars = (char[])obj;
                int    size  = chars.Length * 2;
                if (this.internalBuffer == null || this.internalBuffer.Length < size)
                {
                    this.internalBuffer = new byte[size];
                }

                if (unicodeEncoding == null)
                {
                    this.unicodeEncoding = new UnicodeEncoding();
                }

                this.unicodeEncoding.GetBytes(chars, 0, size / 2, this.internalBuffer, 0);
                message.properties.SetUI1Vector(NativeMethods.MESSAGE_PROPID_BODY, this.internalBuffer);
                message.properties.SetUI4(NativeMethods.MESSAGE_PROPID_BODY_SIZE, size);
                message.properties.SetUI4(NativeMethods.MESSAGE_PROPID_BODY_TYPE, VT_LPWSTR);
                return;
            }
            else if (obj is byte)
            {
                stream = new MemoryStream(1);
                stream.Write(new byte[] { (byte)obj }, 0, 1);
                variantType = VT_UI1;
            }
            else if (obj is bool)
            {
                stream = new MemoryStream(1);
                if ((bool)obj)
                {
                    stream.Write(new byte[] { 0xff }, 0, 1);
                }
                else
                {
                    stream.Write(new byte[] { 0x00 }, 0, 1);
                }
                variantType = VT_BOOL;
            }
            else if (obj is char)
            {
                stream = new MemoryStream(2);
                byte[] bytes = BitConverter.GetBytes((Char)obj);
                stream.Write(bytes, 0, 2);
                variantType = VT_UI2;
            }
            else if (obj is Decimal)
            {
                stream = new MemoryStream(8);
                byte[] bytes = BitConverter.GetBytes(Decimal.ToOACurrency((Decimal)obj));
                stream.Write(bytes, 0, 8);
                variantType = VT_CY;
            }
            else if (obj is DateTime)
            {
                stream = new MemoryStream(8);
                byte[] bytes = BitConverter.GetBytes(((DateTime)obj).Ticks);
                stream.Write(bytes, 0, 8);
                variantType = VT_DATE;
            }
            else if (obj is Double)
            {
                stream = new MemoryStream(8);
                byte[] bytes = BitConverter.GetBytes((Double)obj);
                stream.Write(bytes, 0, 8);
                variantType = VT_R8;
            }
            else if (obj is Int16)
            {
                stream = new MemoryStream(2);
                byte[] bytes = BitConverter.GetBytes((short)obj);
                stream.Write(bytes, 0, 2);
                variantType = VT_I2;
            }
            else if (obj is UInt16)
            {
                stream = new MemoryStream(2);
                byte[] bytes = BitConverter.GetBytes((UInt16)obj);
                stream.Write(bytes, 0, 2);
                variantType = VT_UI2;
            }
            else if (obj is Int32)
            {
                stream = new MemoryStream(4);
                byte[] bytes = BitConverter.GetBytes((int)obj);
                stream.Write(bytes, 0, 4);
                variantType = VT_I4;
            }
            else if (obj is UInt32)
            {
                stream = new MemoryStream(4);
                byte[] bytes = BitConverter.GetBytes((UInt32)obj);
                stream.Write(bytes, 0, 4);
                variantType = VT_UI4;
            }
            else if (obj is Int64)
            {
                stream = new MemoryStream(8);
                byte[] bytes = BitConverter.GetBytes((Int64)obj);
                stream.Write(bytes, 0, 8);
                variantType = VT_I8;
            }
            else if (obj is UInt64)
            {
                stream = new MemoryStream(8);
                byte[] bytes = BitConverter.GetBytes((UInt64)obj);
                stream.Write(bytes, 0, 8);
                variantType = VT_UI8;
            }
            else if (obj is Single)
            {
                stream = new MemoryStream(4);
                byte[] bytes = BitConverter.GetBytes((float)obj);
                stream.Write(bytes, 0, 4);
                variantType = VT_R4;
            }
            else if (obj is IPersistStream)
            {
                IPersistStream          pstream   = (IPersistStream)obj;
                ComStreamFromDataStream comStream = new ComStreamFromDataStream(new MemoryStream());
                NativeMethods.OleSaveToStream(pstream, comStream);
                stream      = comStream.GetDataStream();
                variantType = VT_STREAMED_OBJECT;
            }
            else if (obj == null)
            {
                stream      = new MemoryStream();
                variantType = VT_NULL;
            }
            else
            {
                throw new InvalidOperationException(Res.GetString(Res.InvalidTypeSerialization));
            }

            message.BodyStream = stream;
            message.BodyType   = variantType;
        }
示例#44
0
    public static void Main()
    {
        try
        {
            IPAddress ipAd = IPAddress.Parse("127.0.0.1");
            // use local m/c IP address, and
            // use the same in the client

            /* Initializes the Listener */
            TcpListener myList = new TcpListener(ipAd, 8888);

            /* Start Listeneting at the specified port */
            myList.Start();

            Console.WriteLine("The server is running at port 8888...");
            Console.WriteLine("The local End point is  :" +
                              myList.LocalEndpoint);
            Console.WriteLine("Waiting for a connection.....");

            Socket s = myList.AcceptSocket();
            Console.WriteLine("Connection accepted from " + s.RemoteEndPoint);

            RSAServer    rsa  = new RSAServer();
            UTF8Encoding Asen = new UTF8Encoding();
            //sending N and D these two public key to client
            s.Send(Asen.GetBytes(Convert.ToString(rsa.getN())));
            s.Send(Asen.GetBytes(Convert.ToString(rsa.getD())));
            byte[] b;


            while (true)
            {
                b = new byte[80000];
                int    k = s.Receive(b);
                char[] c = new char[k];
                //Console.WriteLine("Recieved... {0}", k);
                for (int i = 0; i < k; i++)
                {
                    c[i] = Convert.ToChar(b[i]);
                }

                string S = new string(c);
                S = rsa.decryptMsg(S);
                Console.WriteLine("client send msg: '{0}'", S);

                if (string.Compare(S, "exit") == 0)
                {
                    break;
                }

                UnicodeEncoding asen = new UnicodeEncoding();
                //s.Send(asen.GetBytes("The string was recieved by the server."));
                //Console.WriteLine("\nSent Acknowledgement");
            }

            /* clean up */
            s.Close();
            myList.Stop();
        }
        catch (Exception e)
        {
            Console.WriteLine("Error.....\n" + e.ToString());
        }
    }
示例#45
0
    static void Main()
    {
        UnicodeEncoding uniEncoding    = new UnicodeEncoding();
        string          lastRecordText =
            "The last processed record number was: ";
        int textLength   = uniEncoding.GetByteCount(lastRecordText);
        int recordNumber = 13;
        int byteCount    =
            uniEncoding.GetByteCount(recordNumber.ToString());
        string tempString;

        // <Snippet2>
        using (FileStream fileStream = new FileStream(
                   "Test#@@#.dat", FileMode.OpenOrCreate,
                   FileAccess.ReadWrite, FileShare.ReadWrite))
        // </Snippet2>
        {
            // <Snippet3>
            // Write the original file data.
            if (fileStream.Length == 0)
            {
                tempString =
                    lastRecordText + recordNumber.ToString();
                fileStream.Write(uniEncoding.GetBytes(tempString),
                                 0, uniEncoding.GetByteCount(tempString));
            }
            // </Snippet3>

            // Allow the user to choose the operation.
            char   consoleInput = 'R';
            byte[] readText     = new byte[fileStream.Length];
            while (consoleInput != 'X')
            {
                Console.Write(
                    "\nEnter 'R' to read, 'W' to write, 'L' to " +
                    "lock, 'U' to unlock, anything else to exit: ");

                if ((tempString = Console.ReadLine()).Length == 0)
                {
                    break;
                }
                consoleInput = char.ToUpper(tempString[0]);
                switch (consoleInput)
                {
                // Read data from the file and
                // write it to the console.
                case 'R':
                    try
                    {
                        fileStream.Seek(0, SeekOrigin.Begin);
                        fileStream.Read(
                            readText, 0, (int)fileStream.Length);
                        tempString = new String(
                            uniEncoding.GetChars(
                                readText, 0, readText.Length));
                        Console.WriteLine(tempString);
                        recordNumber = int.Parse(
                            tempString.Substring(
                                tempString.IndexOf(':') + 2));
                    }

                    // Catch the IOException generated if the
                    // specified part of the file is locked.
                    catch (IOException e)
                    {
                        Console.WriteLine("{0}: The read " +
                                          "operation could not be performed " +
                                          "because the specified part of the " +
                                          "file is locked.",
                                          e.GetType().Name);
                    }
                    break;

                // <Snippet4>
                // Update the file.
                case 'W':
                    try
                    {
                        fileStream.Seek(textLength,
                                        SeekOrigin.Begin);
                        fileStream.Read(
                            readText, textLength - 1, byteCount);
                        tempString = new String(
                            uniEncoding.GetChars(
                                readText, textLength - 1, byteCount));
                        recordNumber = int.Parse(tempString) + 1;
                        fileStream.Seek(
                            textLength, SeekOrigin.Begin);
                        fileStream.Write(uniEncoding.GetBytes(
                                             recordNumber.ToString()),
                                         0, byteCount);
                        fileStream.Flush();
                        Console.WriteLine(
                            "Record has been updated.");
                    }
                    // </Snippet4>

                    // <Snippet6>
                    // Catch the IOException generated if the
                    // specified part of the file is locked.
                    catch (IOException e)
                    {
                        Console.WriteLine(
                            "{0}: The write operation could not " +
                            "be performed because the specified " +
                            "part of the file is locked.",
                            e.GetType().Name);
                    }
                    // </Snippet6>
                    break;

                // Lock the specified part of the file.
                case 'L':
                    try
                    {
                        fileStream.Lock(textLength - 1, byteCount);
                        Console.WriteLine("The specified part " +
                                          "of file has been locked.");
                    }
                    catch (IOException e)
                    {
                        Console.WriteLine(
                            "{0}: The specified part of file is" +
                            " already locked.", e.GetType().Name);
                    }
                    break;

                // <Snippet5>
                // Unlock the specified part of the file.
                case 'U':
                    try
                    {
                        fileStream.Unlock(
                            textLength - 1, byteCount);
                        Console.WriteLine("The specified part " +
                                          "of file has been unlocked.");
                    }
                    catch (IOException e)
                    {
                        Console.WriteLine(
                            "{0}: The specified part of file is " +
                            "not locked by the current process.",
                            e.GetType().Name);
                    }
                    break;
                // </Snippet5>

                // Exit the program.
                default:
                    consoleInput = 'X';
                    break;
                }
            }
        }
    }
示例#46
0
        public static byte[] UnicodeStringToByteArray(String str)
        {
            UnicodeEncoding encoding = new UnicodeEncoding();

            return(encoding.GetBytes(str));
        }
        private static void UpdateIsManager(UnicodeEncoding unicodeEncoding, MemoryStream ms, bool isManager)
        {
            string newValue = isManager.ToString().PadRight(IsManagerLength / 2);

            Updatefield(unicodeEncoding, ms, IsManagerOffset, IsManagerLength, newValue);
        }
        /// <summary>
        /// byte数组转换为string
        /// </summary>
        /// <param name="bytes">byte数组</param>
        /// <returns></returns>
        public static string ConvertToString(this byte[] bytes)
        {
            UnicodeEncoding converter = new UnicodeEncoding();

            return(converter.GetString(bytes));
        }
示例#49
0
        ///////////////////////////////////////////////////////////////////////////////
        // Saves BAS file
        public bool Save(Stream in_stream, ProgramStorage in_storage)
        {
            Encoding encoding;

            // set open options based on encoding type
            switch (Encoding)
            {
            case EncodingType.Ansi:
                encoding = new ASCIIEncoding();
                break;

            case EncodingType.Auto:
            case EncodingType.Utf8:
                encoding = new UTF8Encoding();
                break;

            case EncodingType.Unicode:
                encoding = new UnicodeEncoding();
                break;

            default:
                encoding = null;
                break;
            }


            using (StreamWriter bas_file = new StreamWriter(in_stream, encoding))
            {
                // start processing of the memory
                int        current_pos   = 0;
                int        next_line_pos = 0;
                int        line_data_end;
                StatusCode state = StatusCode.Tokenizing;

                BasicLineHeader current_line = new BasicLineHeader();
                current_line.ReadFromMemory(current_pos, in_storage);

                while (current_pos < in_storage.Length && current_line.Length != BAS_PRGEND)
                {
                    // check basic format
                    if (current_line.Length < BasicLineHeader.Size)
                    {
                        bas_file.Write("\n*** Broken BASIC program\n");
                        break;
                    }

                    // set next line pointer
                    next_line_pos = current_pos + current_line.Length;

                    // write line number
                    bas_file.Write("{0,4:d} ", current_line.Number);

                    // decode  line
                    current_pos  += BasicLineHeader.Size;
                    line_data_end = next_line_pos;
                    if (current_pos <= line_data_end - 1 && in_storage.Data[line_data_end - 1] == BAS_LINEND)
                    {
                        line_data_end--;
                    }

                    state = StatusCode.Tokenizing;
                    while (current_pos < line_data_end)
                    {
                        char current_char = (char)in_storage.Data[current_pos];

                        // decode token or character
                        if (state == StatusCode.Tokenizing)
                        {
                            // store tokenized item
                            if (Encoding == EncodingType.Ansi)
                            {
                                bas_file.Write(m_ansi_tokenized_map[current_char]);
                            }
                            else
                            {
                                bas_file.Write(m_unicode_tokenized_map[current_char]);
                            }
                        }
                        else
                        {
                            // store non tokenized item
                            if (Encoding == EncodingType.Ansi)
                            {
                                if (current_char < 0x80)
                                {
                                    bas_file.Write(m_ansi_tokenized_map[current_char]);
                                }
                                else
                                {
                                    bas_file.Write("\\x{0:X2}", current_char);
                                }
                            }
                            else
                            {
                                if (current_char < 0x80)
                                {
                                    bas_file.Write(m_unicode_tokenized_map[current_char]);
                                }
                                else
                                {
                                    bas_file.Write("\\x{0:X2}", current_char);
                                }
                            }
                        }

                        // update status
                        if (current_char == '"')
                        {
                            state ^= StatusCode.Quotation;
                        }
                        else
                        {
                            if (!state.HasFlag(StatusCode.Quotation))
                            {
                                if (current_char == BAS_TOKEN_DATA)
                                {
                                    state |= StatusCode.Data;
                                }
                                else
                                {
                                    if (current_char == BAS_TOKEN_COLON)
                                    {
                                        state &= ~StatusCode.Data;
                                    }
                                    else
                                    {
                                        if (current_char == BAS_TOKEN_COMMENT || current_char == BAS_TOKEN_REM)
                                        {
                                            state |= StatusCode.Remark;
                                        }
                                    }
                                }
                            }
                        }

                        current_pos++;
                    }

                    bas_file.WriteLine();

                    current_pos = next_line_pos;

                    current_line.ReadFromMemory(current_pos, in_storage);
                }

                // write remaining data offset
                int remaining_byte_index = current_pos + 1;                 // +1 beacuse of the BAS_PRGEND byte
                if (remaining_byte_index < in_storage.Length)
                {
                    bas_file.WriteLine("BYTESOFFSET {0}", remaining_byte_index);
                }

                // write remaining data
                int bytes_in_a_line = 0;
                while (remaining_byte_index < in_storage.Length)
                {
                    if (bytes_in_a_line == 0)
                    {
                        bas_file.Write("BYTES ");
                    }

                    bas_file.Write("\\x{0:X2}", in_storage.Data[remaining_byte_index]);

                    remaining_byte_index++;
                    bytes_in_a_line++;

                    // write new line
                    if (bytes_in_a_line > MAX_BYTES_IN_A_LINE)
                    {
                        bas_file.WriteLine();
                        bytes_in_a_line = 0;
                    }
                }
                // new line
                if (bytes_in_a_line > 0)
                {
                    bas_file.WriteLine();
                }

                // write autostart
                if (in_storage.AutoStart)
                {
                    bas_file.WriteLine("AUTOSTART");
                }
            }

            return(true);
        }
示例#50
0
        public static byte[] ConvertToByteArray(string plainText)
        {
            UnicodeEncoding ByteConverter = new UnicodeEncoding();

            return(ByteConverter.GetBytes(plainText));
        }
示例#51
0
        protected void btnSave_Click(object sender, EventArgs e)
        {
            string strErr = "";

            if (this.txtUSER_CODE.Text.Trim().Length == 0)
            {
                strErr += "USER_CODE不能为空!\\n";
            }
            if (this.txtCOMPANY_CODE.Text.Trim().Length == 0)
            {
                strErr += "COMPANY_CODE不能为空!\\n";
            }
            if (this.txtCOMPANY_NAME.Text.Trim().Length == 0)
            {
                strErr += "COMPANY_NAME不能为空!\\n";
            }
            if (this.txtUSER_NAME.Text.Trim().Length == 0)
            {
                strErr += "USER_NAME不能为空!\\n";
            }
            if (this.txtSTOCK_CODE.Text.Trim().Length == 0)
            {
                strErr += "STOCK_CODE不能为空!\\n";
            }
            if (this.txtSTOCK_NAME.Text.Trim().Length == 0)
            {
                strErr += "STOCK_NAME不能为空!\\n";
            }
            if (this.txtDEPARTMENT_CODE.Text.Trim().Length == 0)
            {
                strErr += "DEPARTMENT_CODE不能为空!\\n";
            }
            if (this.txtDEPARTMENT_NAME.Text.Trim().Length == 0)
            {
                strErr += "DEPARTMENT_NAME不能为空!\\n";
            }
            if (this.txtdepartment.Text.Trim().Length == 0)
            {
                strErr += "department不能为空!\\n";
            }
            if (this.txtPARENT_DEPARTMENT_CODE.Text.Trim().Length == 0)
            {
                strErr += "PARENT_DEPARTMENT_CODE不能为空!\\n";
            }
            if (this.txtPASSWORD.Text.Trim().Length == 0)
            {
                strErr += "PASSWORD不能为空!\\n";
            }
            if (this.txtDescription.Text.Trim().Length == 0)
            {
                strErr += "Description不能为空!\\n";
            }
            if (this.txtEmployeeCode.Text.Trim().Length == 0)
            {
                strErr += "EmployeeCode不能为空!\\n";
            }
            if (this.txtAllowUsed.Text.Trim().Length == 0)
            {
                strErr += "AllowUsed不能为空!\\n";
            }
            if (this.txtisLicenceAudit.Text.Trim().Length == 0)
            {
                strErr += "isLicenceAudit不能为空!\\n";
            }
            if (this.txtUserType.Text.Trim().Length == 0)
            {
                strErr += "UserType不能为空!\\n";
            }
            if (!PageValidate.IsDateTime(txtAuditDate.Text))
            {
                strErr += "AuditDate格式错误!\\n";
            }

            if (strErr != "")
            {
                MessageBox.Show(this, strErr);
                return;
            }
            string USER_CODE              = this.txtUSER_CODE.Text;
            string COMPANY_CODE           = this.txtCOMPANY_CODE.Text;
            string COMPANY_NAME           = this.txtCOMPANY_NAME.Text;
            string USER_NAME              = this.txtUSER_NAME.Text;
            string STOCK_CODE             = this.txtSTOCK_CODE.Text;
            string STOCK_NAME             = this.txtSTOCK_NAME.Text;
            string DEPARTMENT_CODE        = this.txtDEPARTMENT_CODE.Text;
            string DEPARTMENT_NAME        = this.txtDEPARTMENT_NAME.Text;
            string department             = this.txtdepartment.Text;
            string PARENT_DEPARTMENT_CODE = this.txtPARENT_DEPARTMENT_CODE.Text;
            bool   PPRICE_SHOW            = this.chkPPRICE_SHOW.Checked;
            string PASSWORD       = this.txtPASSWORD.Text;
            string Description    = this.txtDescription.Text;
            string EmployeeCode   = this.txtEmployeeCode.Text;
            string AllowUsed      = this.txtAllowUsed.Text;
            string isLicenceAudit = this.txtisLicenceAudit.Text;
            string UserType       = this.txtUserType.Text;

            byte[]   LastEdit  = new UnicodeEncoding().GetBytes(this.txtLastEdit.Text);
            DateTime AuditDate = DateTime.Parse(this.txtAuditDate.Text);

            MyERP.Model.SYS_USER model = new MyERP.Model.SYS_USER();
            model.USER_CODE              = USER_CODE;
            model.COMPANY_CODE           = COMPANY_CODE;
            model.COMPANY_NAME           = COMPANY_NAME;
            model.USER_NAME              = USER_NAME;
            model.STOCK_CODE             = STOCK_CODE;
            model.STOCK_NAME             = STOCK_NAME;
            model.DEPARTMENT_CODE        = DEPARTMENT_CODE;
            model.DEPARTMENT_NAME        = DEPARTMENT_NAME;
            model.department             = department;
            model.PARENT_DEPARTMENT_CODE = PARENT_DEPARTMENT_CODE;
            model.PPRICE_SHOW            = PPRICE_SHOW;
            model.PASSWORD       = PASSWORD;
            model.Description    = Description;
            model.EmployeeCode   = EmployeeCode;
            model.AllowUsed      = AllowUsed;
            model.isLicenceAudit = isLicenceAudit;
            model.UserType       = UserType;
            model.LastEdit       = LastEdit;
            model.AuditDate      = AuditDate;

            MyERP.BLL.SYS_USER bll = new MyERP.BLL.SYS_USER();
            bll.Add(model);
            Maticsoft.Common.MessageBox.ShowAndRedirect(this, "保存成功!", "add.aspx");
        }
示例#52
0
        public static string ConvertToString(byte[] bytes, string encoding)
        {
            if (bytes == null)
            {
                return(PdfObject.NOTHING);
            }
            if (encoding == null || encoding.Length == 0)
            {
                char[] c = new char[bytes.Length];
                for (int k = 0; k < bytes.Length; ++k)
                {
                    c[k] = (char)(bytes[k] & 0xff);
                }
                return(new String(c));
            }
            IExtraEncoding extra = (IExtraEncoding)extraEncodings[encoding.ToLower(System.Globalization.CultureInfo.InvariantCulture)];

            if (extra != null)
            {
                String text = extra.ByteToChar(bytes, encoding);
                if (text != null)
                {
                    return(text);
                }
            }
            char[] ch = null;
            if (encoding.Equals(BaseFont.WINANSI))
            {
                ch = winansiByteToChar;
            }
            else if (encoding.Equals(PdfObject.TEXT_PDFDOCENCODING))
            {
                ch = pdfEncodingByteToChar;
            }
            if (ch != null)
            {
                int    len = bytes.Length;
                char[] c   = new char[len];
                for (int k = 0; k < len; ++k)
                {
                    c[k] = ch[bytes[k] & 0xff];
                }
                return(new String(c));
            }
            String nameU  = encoding.ToUpper(System.Globalization.CultureInfo.InvariantCulture);
            bool   marker = false;
            bool   big    = false;
            int    offset = 0;

            if (bytes.Length >= 2)
            {
                if (bytes[0] == (byte)254 && bytes[1] == (byte)255)
                {
                    marker = true;
                    big    = true;
                    offset = 2;
                }
                else if (bytes[0] == (byte)255 && bytes[1] == (byte)254)
                {
                    marker = true;
                    big    = false;
                    offset = 2;
                }
            }
            Encoding enc = null;

            if (nameU.Equals("UNICODEBIGUNMARKED") || nameU.Equals("UNICODEBIG"))
            {
                enc = new UnicodeEncoding(marker ? big : true, false);
            }
            if (nameU.Equals("UNICODELITTLEUNMARKED") || nameU.Equals("UNICODELITTLE"))
            {
                enc = new UnicodeEncoding(marker ? big : false, false);
            }
            if (enc != null)
            {
                return(enc.GetString(bytes, offset, bytes.Length - offset));
            }
            return(IanaEncodings.GetEncodingEncoding(encoding).GetString(bytes));
        }
示例#53
0
        /// <summary>
        /// Converts the string to byte array.
        /// </summary>
        /// <param name="stringToConvert">The string to convert.</param>
        /// <returns></returns>
        public static byte[] ConvertStringToByteArray(string stringToConvert)
        {
            var encoder = new UnicodeEncoding();

            return(encoder.GetBytes(stringToConvert));
        }
示例#54
0
        public unsafe static Module[] GetModules(IntPtr ProcessHandle)
        {
            int           tmpbaseaddr = 0;
            List <Module> ModuleList  = new List <Module>();

            win32.MemoryBasicInformation mbi = new win32.MemoryBasicInformation();

            //win32.UNICODE_STRING usSectionName = new win32.UNICODE_STRING("");
            win32.MEMORY_SECTION_NAME usSectionName = new win32.MEMORY_SECTION_NAME();
            int dwStartAddr = 0x00000000;


            do
            {
                int rt1 = 0;
                if (win32.ZwQueryVirtualMemory(ProcessHandle, dwStartAddr, win32.MemoryInformationClass.MemoryBasicInformation,
                                               &mbi, Marshal.SizeOf(mbi), out rt1) >= 0)
                {
                    //if ((int)mbi.AllocationBase == 0)
                    //    goto JMPNEXT;



                    if (mbi.lType == (int)win32.MbiType.MEM_IMAGE)
                    {
                        byte[] bt     = new byte[260 * 2];
                        int    rt     = 0;
                        int    result = win32.ZwQueryVirtualMemory(ProcessHandle, dwStartAddr,
                                                                   win32.MemoryInformationClass.MemorySectionName,
                                                                   out usSectionName, bt.Length,
                                                                   //out usSectionName,
                                                                   //Marshal.SizeOf(usSectionName),
                                                                   out rt);
                        if (result >= 0 &&
                            tmpbaseaddr != (int)mbi.AllocationBase)
                        {
                            UnicodeEncoding une  = new UnicodeEncoding();
                            string          path = une.GetString(usSectionName.bt).TrimEnd('\0');
                            Module          md   = new Module();
                            md.baseAddress = (int)mbi.AllocationBase;
                            tmpbaseaddr    = (int)mbi.AllocationBase;
                            md.fullName    = win32.DeviceName2Path(path);


                            ModuleList.Add(md);
                        }

                        dwStartAddr += (int)mbi.RegionSize;
                        dwStartAddr -= ((int)mbi.RegionSize % 0x10000);
                    }                    //end of if Type == MEM_IMAGE

                    //JMPNEXT:
                    //   dwStartAddr += (int)mbi.RegionSize;
                    //   dwStartAddr -= ((int)mbi.RegionSize % 0x10000);
                }                 // end of getmbi


                dwStartAddr += 0x10000;
            } while (dwStartAddr < 0x7ffeffff);

            //去除重复
//			int tmpbase = -1;
//			Module mod;
//			for (int i = 0; i < ModuleList.Count; i++)
//			{
//				mod = ModuleList[i];
//				try
//				{
//					while (tmpbase == mod.baseAddress)
//					{
//						ModuleList.RemoveAt(i);
//
//						mod = ModuleList[i];
//
//					}
//				}
//				catch (ArgumentOutOfRangeException)
//				{ break; }
//				tmpbase = mod.baseAddress;
//
//			}
            return(ModuleList.ToArray());
        }
示例#55
0
 /// <summary>
 /// UTF-16 编码数组转换为字符串
 /// </summary>
 /// <param name="input">UTF-16 编码数组</param>
 /// <returns>UTF-16 编码数组转换后的字符串</returns>
 public static string UTF16BytesToString(this byte[] input)
 {
     System.Text.UnicodeEncoding enc = new UnicodeEncoding();
     return(enc.GetString(input));
 }
示例#56
0
        public static string PingNetwork(ActiveUser UserPing)
        {
            UnicodeEncoding ByteConverter = new UnicodeEncoding();

            byte[] Decrypted = Security.RSAImplementation.Decrypt(UserPing.EncryptedMessage, Security.RSAImplementation.LoadParameters());
            if (ByteConverter.GetString(Decrypted) != "APPLICATION")
            {
                return(JsonConvert.SerializeObject(new { Error = true, Message = "Invalid Signature" }));
            }

            List <ActiveUser> activeUsers = new List <ActiveUser>();
            List <ActiveUser> removeUsers = new List <ActiveUser>();
            var conn = Connection.Connect();

            conn.Open();
            var getActiveCommand = conn.CreateCommand();

            getActiveCommand.CommandText = "select * from active_user";
            using (var reader = getActiveCommand.ExecuteReader())
            {
                while (reader.Read())
                {
                    ActiveUser user = new ActiveUser();
                    user.Id        = (int)reader["id"];
                    user.IpAddress = (string)reader["ip_address"];
                    user.Ticks     = (long)reader["time_stamp"];
                    activeUsers.Add(user);
                }
            }
            var command = conn.CreateCommand();

            command.CommandText = String.Format("UPDATE `active_user` SET `time_stamp` = '{0}' WHERE `active_user`.`ip_address` = '{1}';", DateTime.UtcNow.Ticks, UserPing.IpAddress);
            int rowsAffected = command.ExecuteNonQuery();

            if (rowsAffected == 0)
            {
                command.CommandText = String.Format("insert into active_user (`id`, `ip_address`, `time_stamp`) values (NULL, '{0}', '{1}')", UserPing.IpAddress, DateTime.UtcNow.Ticks);
                command.ExecuteNonQuery();
            }
            Security.Randomizer.Randomize(activeUsers);
            int           countMax      = 0;
            List <string> usersToReturn = new List <string>();

            foreach (ActiveUser user in activeUsers)
            {
                if (user.IpAddress == UserPing.IpAddress)
                {
                    continue;
                }
                if (DateTime.UtcNow.Ticks - user.Ticks > TimeSpan.TicksPerSecond * 20)
                {
                    //removeUsers.Add(user);
                    continue;
                }
                usersToReturn.Add(user.IpAddress);
                countMax += 1;
                if (countMax == 6)
                {
                    break;
                }
            }
            DeleteItems(removeUsers);
            return(JsonConvert.SerializeObject(new { ActiveUsers = usersToReturn }));
        }
示例#57
0
        public static void Main(string[] args)
        {
            try
            {
                using (var server = new NetServer())
                {
                    server.Listen((self) =>
                    {
                        System.Console.WriteLine("Server is listening on: " + self.Address.ToString());
                    });
                    server.Connect((channel) =>
                    {
                        System.Console.WriteLine("Client connected.");

                        channel.Fault((c, exception) =>
                        {
                            System.Console.WriteLine(((MiniNet.Exceptions.SocketException)exception).StatusCode.ToString());
                            System.Console.WriteLine(exception.ToString());
                        });

                        var encoding = Encoding.Unicode;
                        var decoder  = new StringDecoder(encoding);
                        var encoder  = new StringEncoder(encoding);

                        //channel.Authenticate();
                        channel.Start();

                        channel.Message((self, buffer) =>
                        {
                            if (buffer.Size > 0)
                            {
                                var str = decoder.Process(buffer);
                                System.Console.WriteLine(str + "-" + buffer.Size + "-");
                                System.Console.WriteLine(buffer.DumpHex(int.MaxValue));
                            }
                        });

                        /*var payload = "Server: Hello Client";
                         * var message = MiniNet.Buffers.Buffer.Create(encoding.GetByteCount(payload));
                         *
                         * encoder.Process(message, payload);
                         * channel.SendAsync(message);*/

                        Thread.Sleep(1000);
                        //channel.Close();
                    });
                    server.Fault((exception) =>
                    {
                        System.Console.WriteLine(exception.ToString());
                    });
                    server.Bind(8080, "localhost");

                    using (var client = new TcpClient())
                    {
                        client.NoDelay = true;
                        client.Connect(server.Address.Host, server.Address.Port);
                        Thread.Sleep(100);

                        var encoding = new UnicodeEncoding(false, false, true);
                        var stream   = client.GetStream();
                        //var reader = new StreamReader(stream, encoding);
                        var writer = new StreamWriter(stream, encoding)
                        {
                            AutoFlush = true
                        };

                        for (int i = 1; i <= 4; i++)
                        {
                            /*var bytesReceived = new byte[1024];
                             * var lengthReceived = client.GetStream().Read(bytesReceived, 0, bytesReceived.Length);
                             * if (lengthReceived > 0)
                             * {
                             *  var message = encoding.GetString(bytesReceived, 0, lengthReceived);
                             *  System.Console.WriteLine(MiniNet.Buffers.Buffer.DumpHex(bytesReceived, 0, lengthReceived, int.MaxValue));
                             *  System.Console.WriteLine("'" + message + "'" + lengthReceived);
                             * }*/

                            writer.Write("Client: Hello Server");
                        }

                        Thread.Sleep(100);
                        System.Console.WriteLine("Press ENTER to quit");
                        System.Console.ReadLine();
                        client.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                System.Console.WriteLine(ex.ToString());
                System.Console.WriteLine(ex.StackTrace);
            }
        }
示例#58
0
        protected void btnSave_Click(object sender, EventArgs e)
        {
            string strErr = "";

            if (this.txtITEM_INTERNAL_CODE.Text.Trim().Length == 0)
            {
                strErr += "ITEM_INTERNAL_CODE不能为空!\\n";
            }
            if (this.txtCUSTOM_CODE.Text.Trim().Length == 0)
            {
                strErr += "CUSTOM_CODE不能为空!\\n";
            }
            if (this.txtCUSTOM_NAME.Text.Trim().Length == 0)
            {
                strErr += "CUSTOM_NAME不能为空!\\n";
            }
            if (this.txtITEM_NO.Text.Trim().Length == 0)
            {
                strErr += "ITEM_NO不能为空!\\n";
            }
            if (this.txtITEM_CODE.Text.Trim().Length == 0)
            {
                strErr += "ITEM_CODE不能为空!\\n";
            }
            if (this.txtITEM_CODE_old.Text.Trim().Length == 0)
            {
                strErr += "ITEM_CODE_old不能为空!\\n";
            }
            if (this.txtITEM_NAME.Text.Trim().Length == 0)
            {
                strErr += "ITEM_NAME不能为空!\\n";
            }
            if (this.txtITEM_COLOR.Text.Trim().Length == 0)
            {
                strErr += "ITEM_COLOR不能为空!\\n";
            }
            if (this.txtPARENT_ITEM_CODE.Text.Trim().Length == 0)
            {
                strErr += "PARENT_ITEM_CODE不能为空!\\n";
            }
            if (this.txtITEM_TYPE.Text.Trim().Length == 0)
            {
                strErr += "ITEM_TYPE不能为空!\\n";
            }
            if (this.txtSPECIFICATIONS.Text.Trim().Length == 0)
            {
                strErr += "SPECIFICATIONS不能为空!\\n";
            }
            if (this.txtMEASURE_UNIT.Text.Trim().Length == 0)
            {
                strErr += "MEASURE_UNIT不能为空!\\n";
            }
            if (this.txtTYPE_NAME.Text.Trim().Length == 0)
            {
                strErr += "TYPE_NAME不能为空!\\n";
            }
            if (!PageValidate.IsDecimal(txtNET_PRICE.Text))
            {
                strErr += "NET_PRICE格式错误!\\n";
            }
            if (!PageValidate.IsDecimal(txtPRICE.Text))
            {
                strErr += "PRICE格式错误!\\n";
            }
            if (this.txtPOSITION.Text.Trim().Length == 0)
            {
                strErr += "POSITION不能为空!\\n";
            }
            if (this.txtIMAGE_NAME.Text.Trim().Length == 0)
            {
                strErr += "IMAGE_NAME不能为空!\\n";
            }
            if (!PageValidate.IsDecimal(txtActual_Qty.Text))
            {
                strErr += "Actual_Qty格式错误!\\n";
            }
            if (this.txtBARCODE.Text.Trim().Length == 0)
            {
                strErr += "BARCODE不能为空!\\n";
            }
            if (this.txtCREATE_NAME.Text.Trim().Length == 0)
            {
                strErr += "CREATE_NAME不能为空!\\n";
            }
            if (!PageValidate.IsDateTime(txtCREATE_DATE.Text))
            {
                strErr += "CREATE_DATE格式错误!\\n";
            }
            if (this.txtUPDATE_NAME.Text.Trim().Length == 0)
            {
                strErr += "UPDATE_NAME不能为空!\\n";
            }
            if (!PageValidate.IsDateTime(txtUPDATE_DATE.Text))
            {
                strErr += "UPDATE_DATE格式错误!\\n";
            }
            if (this.txtREMARK.Text.Trim().Length == 0)
            {
                strErr += "REMARK不能为空!\\n";
            }

            if (strErr != "")
            {
                MessageBox.Show(this, strErr);
                return;
            }
            string  ITEM_INTERNAL_CODE = this.txtITEM_INTERNAL_CODE.Text;
            string  CUSTOM_CODE        = this.txtCUSTOM_CODE.Text;
            string  CUSTOM_NAME        = this.txtCUSTOM_NAME.Text;
            string  ITEM_NO            = this.txtITEM_NO.Text;
            string  ITEM_CODE          = this.txtITEM_CODE.Text;
            string  ITEM_CODE_old      = this.txtITEM_CODE_old.Text;
            string  ITEM_NAME          = this.txtITEM_NAME.Text;
            string  ITEM_COLOR         = this.txtITEM_COLOR.Text;
            string  PARENT_ITEM_CODE   = this.txtPARENT_ITEM_CODE.Text;
            string  ITEM_TYPE          = this.txtITEM_TYPE.Text;
            string  SPECIFICATIONS     = this.txtSPECIFICATIONS.Text;
            string  MEASURE_UNIT       = this.txtMEASURE_UNIT.Text;
            string  TYPE_NAME          = this.txtTYPE_NAME.Text;
            decimal NET_PRICE          = decimal.Parse(this.txtNET_PRICE.Text);
            decimal PRICE    = decimal.Parse(this.txtPRICE.Text);
            string  POSITION = this.txtPOSITION.Text;

            byte[]   IMAGE       = new UnicodeEncoding().GetBytes(this.txtIMAGE.Text);
            string   IMAGE_NAME  = this.txtIMAGE_NAME.Text;
            decimal  Actual_Qty  = decimal.Parse(this.txtActual_Qty.Text);
            string   BARCODE     = this.txtBARCODE.Text;
            string   CREATE_NAME = this.txtCREATE_NAME.Text;
            DateTime CREATE_DATE = DateTime.Parse(this.txtCREATE_DATE.Text);
            string   UPDATE_NAME = this.txtUPDATE_NAME.Text;
            DateTime UPDATE_DATE = DateTime.Parse(this.txtUPDATE_DATE.Text);
            string   REMARK      = this.txtREMARK.Text;

            MyERP.Model.PUB_ITEM_DA model = new MyERP.Model.PUB_ITEM_DA();
            model.ITEM_INTERNAL_CODE = ITEM_INTERNAL_CODE;
            model.CUSTOM_CODE        = CUSTOM_CODE;
            model.CUSTOM_NAME        = CUSTOM_NAME;
            model.ITEM_NO            = ITEM_NO;
            model.ITEM_CODE          = ITEM_CODE;
            model.ITEM_CODE_old      = ITEM_CODE_old;
            model.ITEM_NAME          = ITEM_NAME;
            model.ITEM_COLOR         = ITEM_COLOR;
            model.PARENT_ITEM_CODE   = PARENT_ITEM_CODE;
            model.ITEM_TYPE          = ITEM_TYPE;
            model.SPECIFICATIONS     = SPECIFICATIONS;
            model.MEASURE_UNIT       = MEASURE_UNIT;
            model.TYPE_NAME          = TYPE_NAME;
            model.NET_PRICE          = NET_PRICE;
            model.PRICE       = PRICE;
            model.POSITION    = POSITION;
            model.IMAGE       = IMAGE;
            model.IMAGE_NAME  = IMAGE_NAME;
            model.Actual_Qty  = Actual_Qty;
            model.BARCODE     = BARCODE;
            model.CREATE_NAME = CREATE_NAME;
            model.CREATE_DATE = CREATE_DATE;
            model.UPDATE_NAME = UPDATE_NAME;
            model.UPDATE_DATE = UPDATE_DATE;
            model.REMARK      = REMARK;

            MyERP.BLL.PUB_ITEM_DA bll = new MyERP.BLL.PUB_ITEM_DA();
            bll.Add(model);
            Maticsoft.Common.MessageBox.ShowAndRedirect(this, "保存成功!", "add.aspx");
        }
示例#59
0
        void ServeriDinle()
        {
            while (true)
            {
                string serverdanGelenMesaj = serverReader.ReadLine(); // Okunan deger

                if (cbChoose.SelectedIndex == 1)
                {
                    if (!isSecretKey)
                    {
                        isSecretKey = true;
                        label3.Text = Crypto1.DecryptSecretKey(serverdanGelenMesaj);
                        simetricKey = label3.Text;
                        lstMesajlarClient.Items.Add("SecretKey başarılı şekilde alındı.");
                        LogWriter("SecretKey başarılı şekilde alındı.");
                    }
                    else
                    {
                        Crypto1 crypto1 = new Crypto1();
                        MessageBox.Show("Desifrelenecek verinin çozulecegi yolu seciniz.");

                        UnicodeEncoding ue        = new UnicodeEncoding();
                        Byte[]          buffer    = Convert.FromBase64String(serverdanGelenMesaj);
                        byte[]          plainText = crypto1.DecryptToByteArray(buffer, simetricKey);

                        //File.WriteAllBytes(@"C:\Users\Hknaksoyy\Desktop\cipherText.jpg", plainText);
                        //linkFilePath_LinkClicked(true);
                        File.WriteAllBytes(dataPath, plainText);
                        lstMesajlarClient.Items.Add("Desifreleme islemi tamamlandi");
                        LogWriter("Desifreleme islemi tamamlandi");
                    }
                }
                else if (cbChoose.SelectedIndex == 2)
                {
                    if (!isSecretKey)
                    {
                        isSecretKey = true;
                        label3.Text = Crypto2.DecryptSecretKey(serverdanGelenMesaj);
                        simetricKey = label3.Text;
                        LogWriter("Serverdan Gelen Mesaj: " + serverdanGelenMesaj);
                        LogWriter("Cozumlenmis Simetrik Sifre: " + simetricKey);
                        lstMesajlarClient.Items.Add("SecretKey başarılı şekilde alındı.");
                        LogWriter("SecretKey başarılı şekilde alındı.");
                    }
                    else
                    {
                        Crypto2 crypto2      = new Crypto2();
                        string  decryptoHash = serverdanGelenMesaj.Substring((serverdanGelenMesaj.Length - 64), 64);
                        string  data         = serverdanGelenMesaj.Substring(0, (serverdanGelenMesaj.Length - 64));
                        if (decryptoHash == ComputeSha256Hash(data))
                        {
                            lstMesajlarClient.Items.Add("Server: " + crypto2.DecryptKey(data, simetricKey));
                            label3.Text = serverdanGelenMesaj;
                            LogWriter(serverdanGelenMesaj);
                        }
                    }
                }
                else if (cbChoose.SelectedIndex == 3)
                {
                    Crypto3 crypto3 = new Crypto3();
                    lstMesajlarClient.Items.Add("Server: " + crypto3.Decrypto(serverdanGelenMesaj));
                    label3.Text = serverdanGelenMesaj;
                    LogWriter(serverdanGelenMesaj);
                }
                else
                {
                    lstMesajlarClient.Items.Add("Server: " + serverdanGelenMesaj);
                    LogWriter("Server: " + serverdanGelenMesaj);
                }
            }
        }
示例#60
0
        /// <summary>
        /// 对加密密文进行解密

        /// </summary>
        /// <param name="encryptText">待解密的密文</param>
        /// <param name="key">密钥</param>
        /// <returns>明文字符串</returns>
        public static string DecryptStringReverse(string encryptText, string key)
        {
            string result = "";

            if (string.IsNullOrEmpty(encryptText))
            {
                return(result);
            }

            try
            {
                //如无,取默认值

                string keyStr = string.IsNullOrEmpty(key) ? VariableName.DefaultEncryptKey : key;

                //密文
                byte[] encData = System.Convert.FromBase64String(encryptText);

                //将密文写入内存

                MemoryStream sin = new MemoryStream(encData);

                MemoryStream sout = new MemoryStream();

                DES des = new DESCryptoServiceProvider();

                //得到密钥
                string sTemp;
                if (des.LegalKeySizes.Length > 0)
                {
                    int lessSize = 0, moreSize = des.LegalKeySizes[0].MinSize;

                    while (keyStr.Length * 8 > moreSize &&
                           des.LegalKeySizes[0].SkipSize > 0 &&
                           moreSize < des.LegalKeySizes[0].MaxSize)
                    {
                        lessSize  = moreSize;
                        moreSize += des.LegalKeySizes[0].SkipSize;
                    }

                    if (keyStr.Length * 8 > moreSize)
                    {
                        sTemp = keyStr.Substring(0, (moreSize / 8));
                    }
                    else
                    {
                        sTemp = keyStr.PadRight(moreSize / 8, ' ');
                    }
                }
                else
                {
                    sTemp = keyStr;
                }

                //设置密钥
                des.Key = ASCIIEncoding.ASCII.GetBytes(sTemp);


                //设置初始化向量

                if (keyStr.Length > des.IV.Length)
                {
                    des.IV = ASCIIEncoding.ASCII.GetBytes(keyStr.Substring(0, des.IV.Length));
                }
                else
                {
                    des.IV = ASCIIEncoding.ASCII.GetBytes(keyStr.PadRight(des.IV.Length, ' '));
                }

                //解密流

                CryptoStream decStream = new CryptoStream(sin, des.CreateDecryptor(), CryptoStreamMode.Read);

                //密文流的长度
                long lLen = sin.Length;
                //已经读取长度
                int nReadTotal = 0;

                //读入块

                byte[] buf = new byte[8];

                int nRead;

                //从密文流读到解密流中
                while (nReadTotal < lLen)
                {
                    nRead = decStream.Read(buf, 0, buf.Length);
                    if (0 == nRead)
                    {
                        break;
                    }

                    sout.Write(buf, 0, nRead);
                    nReadTotal += nRead;
                }
                decStream.Close();

                //明文
                //ASCIIEncoding ascEnc = new ASCIIEncoding();
                UnicodeEncoding ascEnc = new UnicodeEncoding();
                result = ascEnc.GetString(sout.ToArray());
            }
            catch { }

            return(result);
        }