static void Main(string[] args) { Console.WriteLine("loading options..."); options = LoadOptions("options.csv"); mmmOptions = LoadOptions("mmm_candidates.csv"); Console.WriteLine("loading voters..."); var lines = File.ReadAllLines("voters.csv").Skip(1).Select(line => line.Split(';')).ToList(); Console.WriteLine("parsing voters..."); deactivated = lines.ToDictionary(parts => parts[0] + parts[2].Substring(3), parts => parts[3].Contains("Deactivated")); voters = lines.ToDictionary(parts => parts[0] + parts[2].Substring(3), parts => parts[1]); //id+phone => datetime Console.WriteLine("voters: {0}", voters.Count); Console.WriteLine("decrypting..."); var decrypted = new Blowfish(File.ReadAllText("key.txt")).decryptString(File.ReadAllText("protocol.csv")); File.WriteAllText("decrypted.csv", decrypted); Console.WriteLine("filtering..."); var voteLines = decrypted.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Skip(1).Select(line => line.Split(';')); var votes = voteLines .Select( parts => new { voter = parts[0] + parts[1], //id + phone candidates = parts[2].Split(',').ToArray() }).ToList(); Console.WriteLine("deactivated count: " + deactivated.Count(kv => kv.Value)); // не 0 Console.WriteLine("Votes by deactivated: " + votes.Count(v => deactivated[v.voter])); //0 Console.WriteLine("Voters with more than 45 votes: " + votes.Count(v => v.candidates.Count() > 45)); //0 Console.WriteLine("Voters with duplicated votes: " + votes.Count(v => v.candidates.Distinct().Count() != v.candidates.Count())); //0 Console.WriteLine("Voters with more than 45 UNIQUE votes: " + votes.Count(v => v.candidates.Distinct().Count() > 45)); //0 Console.WriteLine("Banned MMMs: " + votes.Count(v => IsMmm(v.voter, v.candidates))); var results = votes .Where(v => !IsMmm(v.voter, v.candidates) && !deactivated[v.voter]) .SelectMany(v => v.candidates.Distinct()) .GroupBy(cand => cand) .ToDictionary(g => g.Key, g => g.Count()); Console.WriteLine("results:"); foreach (var res in results.OrderByDescending(kv => kv.Value)) { Console.WriteLine(res.Value + "\t" + options[res.Key]); } Console.WriteLine("Elliminate ALL MMM:"); Console.WriteLine("Banned ALL MMMs: " + votes.Count(v => IsMmmAll(v.voter, v.candidates))); Console.WriteLine("results:"); var results2 = votes .Where(v => !IsMmmAll(v.voter, v.candidates) && !deactivated[v.voter]) .SelectMany(v => v.candidates.Distinct()) .GroupBy(cand => cand) .ToDictionary(g => g.Key, g => g.Count()); foreach (var res in results2.OrderByDescending(kv => kv.Value)) { Console.WriteLine(res.Value + "\t" + options[res.Key]); } }
private void encryptFile() { FileStream originalStream = File.OpenRead(path + filename); //Change to your file name Blowfish alg = new Blowfish(Encoding.Unicode.GetBytes(myKey)); m_originalLength = originalStream.Length; Byte[] buffer = new byte[originalStream.Length + (8 - (originalStream.Length % 8))]; originalStream.Read(buffer, 0, buffer.Length); originalStream.Close(); alg.Encipher(buffer, buffer.Length); FileStream stream = new FileStream(path + "Enc_" + filename, FileMode.Create); stream.Write(buffer, 0, buffer.Length); stream.Close(); File.Delete(path + filename); }
public string EnCrypt(string sStringToEncrypt) { //the "EncryptionKey" in the web.config is an encrypted version of the actual user-defined key //EncryptionKey is encrypted using our hardcoded, proprietary key. string sKey = Blowfish.DecryptFromBase64(BLOWFISH_KEY, DatabaseSettings.EnvironmentKey); if (!string.IsNullOrEmpty(sKey) && !string.IsNullOrEmpty(sStringToEncrypt)) { return(EnCryptUsingKey(sKey, sStringToEncrypt)); } else { return(""); } }
static MemoryStream Decrypt(uint[] h, Blowfish fish) { var decrypted = fish.Decrypt(h); var ms = new MemoryStream(); var writer = new BinaryWriter(ms); foreach (var t in decrypted) { writer.Write(t); } writer.Flush(); ms.Seek(0, SeekOrigin.Begin); return(ms); }
/// <summary> /// Decrypt a buffer containing MH4U DLC /// </summary> /// <param name="buffer"></param> /// <returns>Decrypted DLC</returns> public byte[] Decrypt(byte[] buffer) { _cipher = new Blowfish(Key); var b = new byte[8]; //var hash = new byte[20]; using (var m = new MemoryStream(buffer, true)) { while (m.Position < m.Length - 4) //0x1c //4 //28=24+4 { //Endian swap 2 sets of 4 bytes for (int i = 3; i >= 0; i--) { b[i] = (byte)m.ReadByte(); } for (int i = 7; i >= 4; i--) { b[i] = (byte)m.ReadByte(); } //Decrypt the 8 bytes _cipher.Decipher(b, 8); //Reset stream position to prepare for writing. m.Position -= 8; //Endian swap 4 bytes twice for (int i = 3; i >= 0; i--) { m.WriteByte(b[i]); } for (int i = 7; i >= 4; i--) { m.WriteByte(b[i]); } } //m.Position -= 24; ////capture sh1 hash //m.Read(hash, 0, 20); //var sh1 = System.Security.Cryptography.SHA1.Create(); sh1.ComputeHash(buffer, 0, buffer.Length - 28); //if (!sh1.Hash.SequenceEqual(hash)) //{ // MessageBox.Show("Invalid SHA1 hash in footer."); // return; //} } //Trim the hash (24) and other useless data (4) by cloning into a new array. return(StripJunk(buffer)); }
private byte[] FindKey(BinReader reader, TellTaleFileStructureInfo fileInfo, IEnumerable <TellTaleKeyInfo> keys) { const int decompressSize = 4; const int readSize = 4096; byte[] readBytes = new byte[readSize]; byte[] testBytes = new byte[readSize]; byte[] deflateBytes = new byte[decompressSize]; reader.Position = fileInfo.VirtualBlocksOffset; reader.Read(readBytes, 0, readSize); using (MemoryStream stream = new MemoryStream(testBytes)) { foreach (var info in keys) { var testBlowfish = new Blowfish(info.Key, true); testBlowfish.Decipher(readBytes, testBytes, readSize); stream.Position = 0; using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress, true)) { try { int bytesRead = 0; // FIXME: Sometimes DeflateStream.Read reads 0 bytes... while (bytesRead == 0) { bytesRead = deflateStream.Read(deflateBytes, 0, decompressSize); } } catch (InvalidDataException) { // Since a wrong key may cause invalid zlib input, // we catch the exception for that, and continue to the next key continue; } } if (deflateBytes[0] == '3' && deflateBytes[1] == 'A' && deflateBytes[2] == 'T' && deflateBytes[3] == 'T') { return(info.Key); } } } return(null); }
public static void LayCauHinh() { byte[] key = Blowfish.GetBytes("ThinhPhat@JSC@123").Clone() as byte[]; Blowfish blowfish = new Blowfish(key); StringReader reader = new StringReader(blowfish.ReadFromFile(Application.StartupPath + @"\Config.tps")); DataSet ds = new DataSet(); ds.ReadXml(reader); if (ds.Tables[0].Rows.Count < 1) { throw new Exception("File cấu hình không có kết nối nào"); } _dbname = Convert.ToString(ds.Tables["KetNoi"].Rows[0]["DBName"]); _server = Convert.ToString(ds.Tables["KetNoi"].Rows[0]["ServerName"]); _username = Convert.ToString(ds.Tables["KetNoi"].Rows[0]["UserName"]); _pass = Convert.ToString(ds.Tables["KetNoi"].Rows[0]["Password"]); //ConnectDb.Connect(xml.db_server, xml.db_name, xml.db_username, xml.db_password); }
public static bool Decrypt(byte[] data, int offset, int length, ClientCryptData cryptData) { if (length % 8 != 0) { throw new ArgumentOutOfRangeException(nameof(length), "The lenght must be a multiple of 8!"); } var uintData = new uint[length / 4]; Buffer.BlockCopy(data, offset, uintData, 0, length); var x = SwitchEndianInt(BitConverter.ToUInt32(cryptData.MD5, 0)); var y = SwitchEndianInt(BitConverter.ToUInt32(cryptData.MD5, 4)); for (var i = 0; i < (length / 8); ++i) { //Switch endian first var a2 = i * 2; uintData[a2] = SwitchEndianInt(uintData[a2]); uintData[a2 + 1] = SwitchEndianInt(uintData[a2 + 1]); //Store new XOR var x2 = uintData[a2]; var y2 = uintData[a2 + 1]; Blowfish.Decrypt(uintData, a2, cryptData.Key); uintData[a2] ^= x; uintData[a2 + 1] ^= y; //Update XOR x = x2; y = y2; //Switch endian now uintData[a2] = SwitchEndianInt(uintData[a2]); uintData[a2 + 1] = SwitchEndianInt(uintData[a2 + 1]); } Buffer.BlockCopy(uintData, 0, data, offset, length); return(true); }
static int GetVersionFromSvt(byte[] svtContents) { byte[] bfKey = ASCIIEncoding.ASCII.GetBytes("SILKROAD"); Blowfish bf = new Blowfish(); bf.Initialize(bfKey); byte[] toDecode = new byte[8]; Buffer.BlockCopy(svtContents, 4, toDecode, 0, 8); byte[] decoded = bf.Decode(toDecode); string verStr = ASCIIEncoding.ASCII.GetString(decoded); int firstZeroTermAt = verStr.IndexOf('\0'); verStr = verStr.Remove(firstZeroTermAt, verStr.Length - firstZeroTermAt); byte[] verStrBytes = ASCIIEncoding.ASCII.GetBytes(verStr); return(int.Parse(verStr)); }
private ArcFile OpenEncrypted(ArcView file, int entry_count, uint main_key) { if (1 == entry_count) { return(null); // empty archive } long current_offset = 8; uint seed = file.View.ReadUInt32(current_offset + 0x44); var twister = new MersenneTwister(seed); byte[] blowfish_key = BitConverter.GetBytes(twister.Rand()); if (!BitConverter.IsLittleEndian) { Array.Reverse(blowfish_key); } var blowfish = new Blowfish(blowfish_key); var dir = new List <Entry> (entry_count - 1); byte[] name_buffer = new byte[0x40]; for (int i = 1; i < entry_count; ++i) { current_offset += 0x48; file.View.Read(current_offset, name_buffer, 0, 0x40); uint offset = file.View.ReadUInt32(current_offset + 0x40) + (uint)i; uint size = file.View.ReadUInt32(current_offset + 0x44); blowfish.Decipher(ref offset, ref size); twister.SRand(main_key + (uint)i); uint name_key = twister.Rand(); string name = DecipherName(name_buffer, name_key); var entry = FormatCatalog.Instance.Create <Entry> (name); entry.Offset = offset; entry.Size = size; if (!entry.CheckPlacement(file.MaxOffset)) { return(null); } dir.Add(entry); } return(new FrontwingArchive(file, this, dir, blowfish)); }
private IndexEntry[] ReadHeader(Stream stream, out int body_offset) { BinaryReader reader = new BinaryReader(stream); uint flags = (this.version == MixFileVersion.CNC) ? 0 : reader.ReadUInt32(); int nfiles = 0; IndexEntry[] index; // The mix is encrypted. if ((flags & FlagEncrypted) != 0) { // Read the Mix key and convert it to a Blowfish key. byte[] key_source = reader.ReadBytes(80); byte[] key = new BlowfishKeyProvider().DecryptKey(key_source); Blowfish bf = new Blowfish(key); // Parse the header. byte[] header_buf = stream.ReadBytes(8); bf.Decipher(header_buf, 8); this.ParseHeader(header_buf, out nfiles); // Parse the index. int index_size = (12 * nfiles + 5) & ~7; byte[] index_buf = stream.ReadBytes(index_size); bf.Decipher(index_buf, index_size); Array.Copy(index_buf, 0, index_buf, 2, index_size - 2); Array.Copy(header_buf, 6, index_buf, 0, 2); this.ParseIndex(index_buf, nfiles, out index); } else { byte[] header_buf = new byte[6]; stream.Read(header_buf, 0, 6); this.ParseHeader(header_buf, out nfiles); byte[] index_buf = new byte[12 * nfiles]; stream.Read(index_buf, 0, 12 * nfiles); this.ParseIndex(index_buf, nfiles, out index); } body_offset = (int)stream.Position; return(index); }
internal static byte[] Cipher(byte[] buffer, ref byte[] key, bool decrypt) { var cipher = new Blowfish(key); var b = new byte[8]; using (var m = new MemoryStream(buffer, true)) { while (m.Position < m.Length) { //Endian swap 2 sets of 4 bytes for (int i = 3; i >= 0; i--) { b[i] = (byte)m.ReadByte(); } for (int i = 7; i >= 4; i--) { b[i] = (byte)m.ReadByte(); } //cipher the 8 bytes if (decrypt) { cipher.Decipher(b, 8); } else { cipher.Encipher(b, 8); } //Reset stream position to prepare for writing. m.Position -= 8; //Endian swap 4 bytes twice for (int i = 3; i >= 0; i--) { m.WriteByte(b[i]); } for (int i = 7; i >= 4; i--) { m.WriteByte(b[i]); } } } return(buffer); }
private MemoryStream DecryptHeader(long offset, out long headerEnd) { rawStream.Seek(offset, SeekOrigin.Begin); // Decrypt blowfish key var keyblock = rawStream.ReadBytes(80); var blowfishKey = new BlowfishKeyProvider().DecryptKey(keyblock); var fish = new Blowfish(blowfishKey); // Decrypt first block to work out the header length var ms = new BinaryReader(Decrypt(ReadBlocks(offset + 80, 1), fish)); var numFiles = ms.ReadUInt16(); // Decrypt the full header - round bytes up to a full block var blockCount = (13 + numFiles * 12) / 8; headerEnd = offset + 80 + blockCount * 8; return(Decrypt(ReadBlocks(offset + 80, blockCount), fish)); }
static MemoryStream DecryptHeader(Stream s, long offset, out long headerEnd) { s.Seek(offset, SeekOrigin.Begin); // Decrypt blowfish key var keyblock = s.ReadBytes(80); var blowfishKey = new BlowfishKeyProvider().DecryptKey(keyblock); var fish = new Blowfish(blowfishKey); // Decrypt first block to work out the header length var ms = Decrypt(ReadBlocks(s, offset + 80, 1), fish); var numFiles = ms.ReadUInt16(); // Decrypt the full header - round bytes up to a full block var blockCount = (13 + numFiles * PackageEntry.Size) / 8; headerEnd = offset + 80 + blockCount * 8; return(Decrypt(ReadBlocks(s, offset + 80, blockCount), fish)); }
MemoryStream DecryptHeader(VirtualFile reader) { byte[] keyblock = reader.Read(80); byte[] blowfishKey = new BlowfishKeyProvider().DecryptKey(keyblock); // Decrypt just the 1st block to determine the number of items, and thereby the length of the header var fish = new Blowfish(blowfishKey); uint[] h = fish.Decrypt(ReadUints(reader, 2)); // First 2 decrypted bytes indicate number of files defined in header ushort numFiles = (ushort)(h[0] & 0xFFFF); // now we can determine the actual header length, rounded up to full number of blocks const int blockSize = 8; int headerLength = (6 + numFiles * MixEntry.Size + (blockSize - 1)) & ~(blockSize - 1); // Decrypt full header reader.Position = 84; return(Decrypt(ReadUints(reader, headerLength / 4), fish)); }
/// <summary> /// Parse certain executable resources for encryption passphrase. /// Returns null if no passphrase found. /// </summary> public static string GetPassFromExe(string filename) { var exe = NativeMethods.LoadLibraryEx(filename, IntPtr.Zero, 0x20); // LOAD_LIBRARY_AS_IMAGE_RESOURCE if (IntPtr.Zero == exe) { throw new Win32Exception(Marshal.GetLastWin32Error()); } try { var code = GetResource(exe, "DATA", "V_CODE2"); if (null == code || code.Length < 8) { return(null); } var key = GetResource(exe, "KEY", "KEY_CODE"); if (null != key) { for (int i = 0; i < key.Length; ++i) { key[i] ^= 0xCD; } } else { key = Encoding.ASCII.GetBytes("windmill"); } var blowfish = new Blowfish(key); blowfish.Decipher(code, code.Length / 8 * 8); int length = Array.IndexOf <byte> (code, 0); if (-1 == length) { length = code.Length; } return(Encodings.cp932.GetString(code, 0, length)); } finally { NativeMethods.FreeLibrary(exe); } }
public byte[] Encrypt(byte[] buffer) { _cipher = new Blowfish(_key); var checksum = BitConverter.GetBytes(CalcChecksum(buffer)); var buff = new byte[buffer.Length + 4]; checksum.CopyTo(buff, 0); buffer.CopyTo(buff, 4); //Why we actually bother to randomise this is beyond me, might as well be 0, oh well. var seed = (ushort)((new Random()).Next() >> 16); //XOR! buffer = XOR(buff, seed); //Write seed buff = new byte[buffer.Length + 4]; (BitConverter.GetBytes((seed << 16) + 0x10)).CopyTo(buff, 0); buffer.CopyTo(buff, 4); //Encrypt buffer = Functions.Cipher(buff, ref _key, false); return(buffer); }
public static PacketResult Process(BinaryReader reader, Blowfish blowfish, out SubPacket subPacket) { subPacket = null; Header header = Header.UnMarshal(reader); // not enough data to cover length specified in header if (reader.BaseStream.Length - reader.BaseStream.Position < header.Size - Header.Length) { return(PacketResult.Malformed); } byte[] payload = reader.ReadBytes((int)(header.Size - Header.Length)); if (header.Type != SubPacketType.KeepAliveRequest && header.Type != SubPacketType.KeepAliveResponse) { blowfish?.Decipher(payload, 0, payload.Length); } using (var stream = new MemoryStream(payload)) { using (var subReader = new BinaryReader(stream)) { MessageHeader messageHeader = new MessageHeader(); if (header.Type == SubPacketType.Message) { messageHeader = MessageHeader.UnMarshal(subReader); Array.Copy(payload, MessageHeader.Length, payload, 0, payload.Length - MessageHeader.Length); Array.Resize(ref payload, payload.Length - (int)MessageHeader.Length); stream.Position = 0L; } subPacket = PacketManager.GetSubPacket(header.Type, (SubPacketClientOpcode)messageHeader.Opcode, SubPacketServerOpcode.None) ?? new SubPacket(); subPacket.Initialise(header, messageHeader); subPacket.Read(subReader); } } return(PacketResult.Ok); }
static void Main(string[] args) { int exit = 1; string value; string key = "{123ABC9F-AFBC-36DC-8FF8-00BDAFF1584DGFQQ}"; string encrypted; string decipher; do { Console.Clear(); Console.WriteLine("Input value: "); value = Convert.ToString(Console.ReadLine()); Blowfish blowfish = new Blowfish(key); encrypted = blowfish.Encipher(value); Console.WriteLine("Encrypted value: " + encrypted); decipher = blowfish.Decipher(encrypted); Console.WriteLine("Decipher value: " + decipher); Console.WriteLine("Input 0 to exit: "); exit = Convert.ToInt32(Console.ReadLine()); }while (exit != 0); }
private static byte[] DetermineKeyByInfoTable(BinReader reader, TellTaleFileStructureInfo fileInfo, IEnumerable <TellTaleKeyInfo> keys) { byte[] encryptedTable = fileInfo.ReadInfoBlock(reader, null); byte[] decryptedTable = new byte[encryptedTable.Length]; foreach (var info in keys) { var blowfish = new Blowfish(info.Key, fileInfo.FileVersion >= 7); blowfish.Decipher(encryptedTable, decryptedTable, (uint)(encryptedTable.Length / 8) * 8); // Now we do our assertions which should be true if the key was right: using (MemoryStream infoStream = new MemoryStream(decryptedTable)) { using (var infoReader = new BinReader(infoStream)) { uint folderCount = infoReader.ReadU32LE(); // The maximum number of folders is somewhat arbitrary. // In games tested, I haven't seen folder counts this high. if (folderCount > 128) { Trace.TraceInformation("Key check - folder count: {0}", folderCount); continue; } // We just check the first folder: uint nameSize = infoReader.ReadU32LE(); if (nameSize > 300) { Trace.TraceInformation("Key check - folder name size: {0}", nameSize); continue; } return(info.Key); } } } return(null); }
public static string Decrypt3(string cipherText, string encryptionKey1, string encryptionKey2, out Exception exData) { exData = null; try { var mainKey = encryptionKey1 + encryptionKey2; var blowFish = new Blowfish(mainKey); return(blowFish.Decipher(cipherText)); } catch (Exception ex) { if (InnerExceptionList == null) { InnerExceptionList = new List <Exception>(); } InnerExceptionList.Add(ex); exData = ex; return("NULL"); } }
public byte[] Build(Blowfish blowfish, uint source, uint target) { SubPacketAttribute attribute = (SubPacketAttribute)Attribute.GetCustomAttribute(GetType(), typeof(SubPacketAttribute)); byte[] payload; using (var stream = new MemoryStream()) { using (var writer = new BinaryWriter(stream)) Write(writer); payload = stream.ToArray(); } if (attribute.ServerOpcode != SubPacketServerOpcode.None) { SubMessageHeader = new MessageHeader { Unknown1 = 0x14, Opcode = (ushort)attribute.ServerOpcode, Timestamp = (uint)DateTimeOffset.Now.ToUnixTimeSeconds() }; payload = SubMessageHeader.Marshal().Concat(payload).ToArray(); } blowfish?.Encipher(payload, 0, payload.Length); SubHeader = new Header { Size = (ushort)(Header.Length + payload.Length), Type = attribute.ServerOpcode != SubPacketServerOpcode.None ? SubPacketType.Message : attribute.Type, Source = source, Target = target }; return(SubHeader.Marshal().Concat(payload).ToArray()); }
public void EncryptDecryptArray() { #region init int dataLength = 13107200; ulong[] dataArray = new ulong[dataLength]; ulong[] originalDataArray = new ulong[dataLength]; int keyLength = 56; byte[] key = new byte[keyLength]; Random rnd = new Random(); rnd.NextBytes(key); for (var i = 0; i < dataLength; i++) { uint r = (uint)rnd.Next(); ulong l = (uint)rnd.Next(); dataArray[i] = (l << 32) | r; originalDataArray[i] = dataArray[i]; } #endregion Blowfish blowfish = new Blowfish(key); blowfish.EncryptArray(dataArray); for (var i = 0; i < dataLength; i++) { Assert.IsFalse(dataArray[i] == originalDataArray[i]); } blowfish.DecryptArray(dataArray); for (var i = 0; i < dataLength; i++) { Assert.IsTrue(dataArray[i] == originalDataArray[i]); } }
public void DecryptString() { Blowfish blowfish = new Blowfish(salt); Assert.AreEqual(blowfish.Decipher(encrypted), value); }
public static void BlowfishTest() { Console.WriteLine("Enter text: "); string text = Console.ReadLine(); Blowfish b = new Blowfish(); string encr = b.Encrypt(text); Console.WriteLine("Encrypted text " + encr); Console.WriteLine("Decrypted text " + b.Decrypt(encr)); Console.ReadKey(); }
/// <summary> /// bcrypt_pbkdf (pkcs #5 pbkdf2 implementation using the "bcrypt" hash) /// </summary> /// <param name="pass">password</param> /// <param name="salt">salt</param> /// <param name="rounds">rounds</param> /// <param name="keylen">key length</param> /// <returns>key</returns> public byte[] BcryptPbkdf(string pass, byte[] salt, uint rounds, int keylen) { // this code is based on OpenBSD's bcrypt_pbkdf.c if (rounds < 1) { return null; } if (pass.Length == 0 || salt.Length == 0 || keylen <= 0 || keylen > 1024) { return null; } byte[] key = new byte[keylen]; int stride = (keylen + 32 - 1) / 32; int amt = (keylen + stride - 1) / stride; var blowfish = new Blowfish(); using (var sha512 = new SHA512CryptoServiceProvider()) { // collapse password byte[] passData = Encoding.UTF8.GetBytes(pass); byte[] sha2pass = sha512.ComputeHash(passData); // generate key, sizeof(out) at a time byte[] countsalt = new byte[4]; for (int count = 1; keylen > 0; ++count) { countsalt[0] = (byte)(count >> 24); countsalt[1] = (byte)(count >> 16); countsalt[2] = (byte)(count >> 8); countsalt[3] = (byte)(count); // first round, salt is salt sha512.Initialize(); sha512.TransformBlock(salt, 0, salt.Length, null, 0); sha512.TransformFinalBlock(countsalt, 0, countsalt.Length); byte[] sha2salt = sha512.Hash; byte[] tmpout = BcryptHash(blowfish, sha2pass, sha2salt); byte[] output = (byte[])tmpout.Clone(); for (uint r = rounds; r > 1; --r) { // subsequent rounds, salt is previous output sha512.Initialize(); sha2salt = sha512.ComputeHash(tmpout); tmpout = BcryptHash(blowfish, sha2pass, sha2salt); for (int i = 0; i < output.Length; ++i) { output[i] ^= tmpout[i]; } } // pbkdf2 deviation: output the key material non-linearly. amt = Math.Min(amt, keylen); int k; for (k = 0; k < amt; ++k) { int dest = k * stride + (count - 1); if (dest >= key.Length) { break; } key[dest] = output[k]; } keylen -= k; } } return key; }
public void EncryptString() { Blowfish blowfish = new Blowfish(salt); Assert.AreEqual(blowfish.Encipher(value), encrypted); }
public FrontwingArchive(ArcView arc, ArchiveFormat impl, ICollection <Entry> dir, Blowfish cipher) : base(arc, impl, dir) { Encryption = cipher; }
static void TestBlowfish() { if (!Blowfish.SelfTest()) { System.Console.WriteLine("selftest failed."); return; } System.Console.WriteLine("selftest passed."); byte[] key = new byte[16]; for (byte bI = 0; bI < key.Length; bI++) { key[bI] = bI; } Blowfish bf = new Blowfish(key); System.Console.WriteLine((bf.IsWeakKey) ? "weak key detected." : "no weak key."); String sTest = "this is something to encrypt"; System.Console.WriteLine(sTest); byte[] plainText = StringToBlocks(sTest); byte[] cipherText = new byte[plainText.Length]; bf.Encrypt(plainText, cipherText, 0, 0, plainText.Length); System.Console.WriteLine(BlocksToString(cipherText)); bf.Decrypt(cipherText, cipherText, 0, 0, cipherText.Length); System.Console.WriteLine(BlocksToString(cipherText)); int nI, nSize = Blowfish.BLOCKSIZE * BIGBUFDIM; byte[] bigBuf = new byte[nSize]; for (nI = 0; nI < nSize; nI++) { bigBuf[nI] = (byte)nI; } System.Console.WriteLine("benchmark running ..."); long lTm = DateTime.Now.Ticks; for (nI = 0; nI < TESTLOOPS; nI++) { bf.Encrypt(bigBuf, bigBuf, 0, 0, nSize); if ((nI & 0x0f) == 0) { System.Console.Write("."); } } lTm = DateTime.Now.Ticks - lTm; lTm /= 10000; System.Console.WriteLine("\n{0} bytes in {1} millisecs", TESTLOOPS * nSize, lTm); long lSize = (long)nSize * 1000 * TESTLOOPS; lSize /= lTm; System.Console.WriteLine("(average of {0} bytes per second)", lSize); bf.Burn(); }
/// <summary> /// bcrypt_hash /// </summary> /// <param name="blowfish">blowfish object to use</param> /// <param name="sha2pass">SHA512 of password</param> /// <param name="sha2salt">SHA512 of salt</param> /// <returns></returns> private byte[] BcryptHash(Blowfish blowfish, byte[] sha2pass, byte[] sha2salt) { // this code is based on OpenBSD's bcrypt_pbkdf.c const int BLOCKSIZE = 8; // key expansion blowfish.InitializeState(); blowfish.ExpandState(sha2pass, sha2salt); for (int i = 0; i < 64; ++i) { blowfish.ExpandState(sha2salt); blowfish.ExpandState(sha2pass); } // encryption byte[] cdata = (byte[])_bcryptCipherText.Clone(); for (int i = 0; i < 64; ++i) { for (int j = 0; j < 32; j += BLOCKSIZE) { blowfish.BlockEncrypt(cdata, j, cdata, j); } } // copy out for (int i = 0; i < 32; i += 4) { byte b0 = cdata[i + 0]; byte b1 = cdata[i + 1]; byte b2 = cdata[i + 2]; byte b3 = cdata[i + 3]; cdata[i + 3] = b0; cdata[i + 2] = b1; cdata[i + 1] = b2; cdata[i + 0] = b3; } return cdata; }
public static Ticket EncryptAuthSessionTicket(byte[] ticket, uint time) { time -= 5; time -= time % 60; // Time should be rounded to nearest minute. var ticketString = BitConverter.ToString(ticket).Replace("-", "").ToLower(); var rawTicketBytes = Encoding.ASCII.GetBytes(ticketString); var rawTicket = new byte[rawTicketBytes.Length + 1]; Array.Copy(rawTicketBytes, rawTicket, rawTicketBytes.Length); rawTicket[rawTicket.Length - 1] = 0; Log.Debug(Util.ByteArrayToHex(rawTicket)); var blowfishKey = $"{time:x08}#un@e=x>"; using var memorySteam = new MemoryStream(); using var binaryWriter = new BinaryWriter(memorySteam); /* REGULAR SUM + TICKET */ ushort ticketSum = 0; foreach (byte b in rawTicket) { ticketSum += b; } binaryWriter.Write(ticketSum); binaryWriter.Write(rawTicket); /* GARBAGE */ int castTicketSum = unchecked ((short)ticketSum); Log.Information($"{castTicketSum:X}"); var seed = time ^ castTicketSum; var rand = new CrtRand((uint)seed); var numRandomBytes = ((ulong)(rawTicket.Length + 9) & 0xFFFFFFFFFFFFFFF8) - 2 - (ulong)rawTicket.Length; var garbage = new byte[numRandomBytes]; uint fuckedSum = BitConverter.ToUInt32(memorySteam.ToArray(), 0); for (var i = 0u; i < numRandomBytes; i++) { var randChar = FUCKED_GARBAGE_ALPHABET[(int)(fuckedSum + rand.Next()) & 0x3F]; garbage[i] = (byte)randChar; fuckedSum += randChar; } binaryWriter.Write(garbage); memorySteam.Seek(0, SeekOrigin.Begin); binaryWriter.Write(fuckedSum); Log.Information("[STEAM] time: {Time}, bfKey: {FishKey}, rawTicket.Length: {TicketLen}, ticketSum: {TicketSum}, fuckedSum: {FuckedSum}, seed: {Seed}, numRandomBytes: {NumRandomBytes}", time, blowfishKey, rawTicket.Length, ticketSum, fuckedSum, seed, numRandomBytes); /* ENC + SPLIT */ var finalBytes = memorySteam.ToArray(); var t = finalBytes[0]; finalBytes[0] = finalBytes[1]; finalBytes[1] = t; var keyBytes = Encoding.ASCII.GetBytes(blowfishKey); Log.Debug(Util.ByteArrayToHex(keyBytes)); var blowfish = new Blowfish(keyBytes); var ecb = new Ecb <Blowfish>(blowfish); Log.Debug(Util.ByteArrayToHex(finalBytes)); var encBytes = new byte[finalBytes.Length]; Debug.Assert(encBytes.Length % 8 == 0); ecb.Encrypt(finalBytes, encBytes); var encString = Util.ToMangledSeBase64(encBytes); Log.Debug(Util.ByteArrayToHex(encBytes)); const int SPLIT_SIZE = 300; var parts = ChunksUpto(encString, SPLIT_SIZE).ToArray(); var finalString = string.Join(",", parts); return(new Ticket(finalString, finalString.Length - (parts.Length - 1))); }
public IRCSession( string serverAddress, uint port, string nick, string user, string ident, string channel, byte[] encryptionKey) { m_ircServerAddress = serverAddress; m_ircServerPort = port; m_ircPrimaryChannelName = channel; m_ircChannelName = m_ircPrimaryChannelName; m_ircPrimaryNick = nick; m_ircNick = m_ircPrimaryNick; m_ircUser = user; m_ircFullIdentity = ident; m_irc = new IRCEventDispatcher(); m_irc.AddEventListener(IRCEvent.EVENT_STATUSMESSAGE, StatusMessageEventHandler); m_irc.AddEventListener(IRCEvent.EVENT_SOCKOPEN, SockOpenEventHandler); m_irc.AddEventListener(IRCEvent.EVENT_ERROR, ErrorEventHandler); m_irc.AddEventListener(IRCEvent.EVENT_SOCKERROR, SockErrorEventHandler); m_irc.AddEventListener(IRCEvent.EVENT_ACTIVEMESSAGE, ActiveMessageEventHandler); m_irc.AddEventListener(IRCEvent.EVENT_PING, PingEventHandler); m_irc.AddEventListener(IRCEvent.EVENT_WELCOME, WelcomeEventHandler); m_irc.AddEventListener(IRCEvent.EVENT_NOTICE, NoticeEventHandler); m_irc.AddEventListener(IRCEvent.EVENT_JOIN, JoinEventHandler); m_irc.AddEventListener(IRCEvent.EVENT_PRIVMSG, PrivmsgEventHandler); m_irc.AddEventListener(IRCEvent.EVENT_TOPIC, TopicEventHandler); m_irc.AddEventListener(IRCEvent.EVENT_MODE, ModeEventHandler); m_irc.AddEventListener(IRCEvent.EVENT_NICK, NickEventHandler); m_irc.AddEventListener(IRCEvent.EVENT_KICK, KickEventHandler); m_irc.AddEventListener(IRCEvent.EVENT_QUIT, QuitEventHandler); if (encryptionKey != null) { // TODO: Generate a real random number for IV, pass it to other clients // Blowfish needs an initialization vector. // Normally this would be a cryptographically secure random number. // This value can be transmitted in public somehow, but I don't feel // like doing the plumbing for that yet. // So, for now, we make a pseudo-random IV seeded by the IRC port. System.Random rng = new System.Random((int)port); byte[] initialization_vector= new byte[8]; rng.NextBytes(initialization_vector); m_encryptor = new Blowfish(encryptionKey); m_encryptor.IV= initialization_vector; // The IRC channel key all users use to access the channel is the // channel name encrypted using the IRC encryption key in Base64 encoding m_ircChannelKey = EncryptAndBase64Encode(channel); } else { m_ircChannelKey = ""; } m_outputStreams = new List<OutputStreamDelegate>(); m_gameEventStreams = new List<GameEventStreamDelegate>(); m_loggingStreams = new List<LogStreamDelegate>(); m_state = eState.disconnected; ClearIrcNickToCharacterIdMap(); }
public BlowfishCipher2(byte[] key) { Debug.Assert(key.Length == 32); _bf = new Blowfish(); _bf.initializeKey(key); }
public BlowfishCipher2(byte[] key, byte[] iv) { _bf = new Blowfish(); _bf.SetIV(iv); _bf.initializeKey(key); }
// Test using test vector // https://www.schneier.com/code/vectors.txt internal static void Test() { // Test ECB using (var reader = new System.IO.StreamReader(@"vectors.txt")) { string line; do { line = reader.ReadLine(); } while (line != null && !line.StartsWith("key bytes")); var blowfish = new Blowfish(); int count = 0; while (true) { line = reader.ReadLine(); if (line == null) { break; } string[] w = System.Text.RegularExpressions.Regex.Split(line, @"\s\s+"); if (w.Length < 3 || w[0].Length != 16 || w[1].Length != 16 || w[2].Length != 16) { break; } byte[] key = BigIntegerConverter.ParseHex(w[0]); byte[] clear = BigIntegerConverter.ParseHex(w[1]); byte[] cipher = BigIntegerConverter.ParseHex(w[2]); ++count; System.Diagnostics.Debug.WriteLine("Test ECB #{0}", count); blowfish.InitializeKey(key); for (int tries = 1; tries <= 3; ++tries) { byte[] encrypted = new byte[cipher.Length]; blowfish.BlockEncrypt(clear, 0, encrypted, 0); for (int i = 0; i < cipher.Length; ++i) { if (encrypted[i] != cipher[i]) { throw new Exception("encryption failed"); } } } for (int tries = 1; tries <= 3; ++tries) { byte[] decrypted = new byte[clear.Length]; blowfish.BlockDecrypt(cipher, 0, decrypted, 0); for (int i = 0; i < cipher.Length; ++i) { if (decrypted[i] != clear[i]) { throw new Exception("decryption failed"); } } } } } // Test CBC { byte[] key = BigIntegerConverter.ParseHex("0123456789ABCDEFF0E1D2C3B4A59687"); byte[] iv = BigIntegerConverter.ParseHex("FEDCBA9876543210"); // data: 37363534333231204E6F77206973207468652074696D6520666F722000 (29 bytes) + padding bytes (3 bytes) byte[] data = BigIntegerConverter.ParseHex("37363534333231204E6F77206973207468652074696D6520666F722000000000"); byte[] cipher = BigIntegerConverter.ParseHex("6B77B4D63006DEE605B156E27403979358DEB9E7154616D959F1652BD5FF92CC"); System.Diagnostics.Debug.WriteLine("Test CBC"); { Blowfish blowfish = new Blowfish(); blowfish.InitializeKey(key); blowfish.SetIV(iv); byte[] encrypted = new byte[cipher.Length]; blowfish.EncryptCBC(data, 0, data.Length, encrypted, 0); for (int i = 0; i < cipher.Length; ++i) { if (encrypted[i] != cipher[i]) { throw new Exception("encryption failed"); } } } { Blowfish blowfish = new Blowfish(); blowfish.InitializeKey(key); blowfish.SetIV(iv); byte[] decrypted = new byte[data.Length]; for (int i = 0; i < decrypted.Length; ++i) { decrypted[i] = 0xff; } blowfish.DecryptCBC(cipher, 0, cipher.Length, decrypted, 0); for (int i = 0; i < data.Length; ++i) { if (decrypted[i] != data[i]) { throw new Exception("decryption failed"); } } } } }
public override ArcFile TryOpen(ArcView file) { int version; if (file.View.AsciiEqual(4, "1.00")) { version = 100; } else if (file.View.AsciiEqual(4, "1.10")) { version = 110; } else { return(null); } int count = file.View.ReadInt32(0x14); if (!IsSaneCount(count)) { return(null); } int bucket_count = file.View.ReadInt32(0x18); uint index_size = file.View.ReadUInt32(0x1C); uint arc_seed = file.View.ReadUInt32(0x20); long index_offset = version >= 110 ? 0x2C : 0x24; long base_offset = index_offset + index_size; var blowfish = new Blowfish(IndexKey); var packed_bytes = file.View.ReadBytes(index_offset, index_size); blowfish.Decipher(packed_bytes, packed_bytes.Length & ~7); using (var input = new MemoryStream(packed_bytes)) using (var unpacked = new ZLibStream(input, CompressionMode.Decompress)) using (var index = new BinaryReader(unpacked)) { var file_map = BuildFileNameMap(arc_seed); var dir_table = new List <TacBucket> (bucket_count); for (int i = 0; i < bucket_count; ++i) { var entry = new TacBucket(); entry.Hash = index.ReadUInt16(); entry.Count = index.ReadUInt16(); entry.Index = index.ReadInt32(); dir_table.Add(entry); } var dir = new List <Entry> (count); for (int i = 0; i < count; ++i) { var entry = new TacEntry(); entry.Hash = index.ReadUInt64(); entry.IsPacked = index.ReadInt32() != 0; entry.UnpackedSize = index.ReadUInt32(); entry.Offset = base_offset + index.ReadUInt32(); entry.Size = index.ReadUInt32(); if (!entry.CheckPlacement(file.MaxOffset)) { return(null); } dir.Add(entry); } var buffer = new byte[8]; foreach (var bucket in dir_table) { for (int i = 0; i < bucket.Count; ++i) { var entry = dir[bucket.Index + i] as TacEntry; entry.Hash = entry.Hash << 16 | bucket.Hash; bool known_name = file_map.ContainsKey(entry.Hash); if (known_name) { entry.Name = file_map[entry.Hash]; entry.Type = FormatCatalog.Instance.GetTypeFromName(entry.Name); } else { entry.Name = string.Format("{0:X16}", entry.Hash); } if (entry.IsPacked) { continue; } entry.Key = Encoding.ASCII.GetBytes(string.Format("{0}_tlib_secure_", entry.Hash)); if (!known_name) { var bf = new Blowfish(entry.Key); file.View.Read(entry.Offset, buffer, 0, 8); bf.Decipher(buffer, 8); var res = AutoEntry.DetectFileType(buffer.ToUInt32(0)); if (res != null) { entry.ChangeType(res); } } if ("image" == entry.Type) { entry.EncryptedSize = Math.Min(10240, entry.Size); } else { entry.EncryptedSize = entry.Size; } } } return(new ArcFile(file, this, dir)); } }
public BlowfishCipher2(byte[] key) { Debug.Assert(key.Length==32); _bf = new Blowfish(); _bf.initializeKey(key); }