public static string CreatePasswordHash(string salt, string password) { string saltAndPwd = String.Concat(password, salt); byte[] data = Encoding.UTF8.GetBytes(saltAndPwd); using (HashAlgorithm sha = new SHA256Managed()) { sha.TransformFinalBlock(data, 0, data.Length); return Convert.ToBase64String(sha.Hash); } }
public static string getHash(string input) { byte[] data = Encoding.UTF8.GetBytes(input); using (HashAlgorithm sha = new SHA256Managed()) { byte[] encryptedBytes = sha.TransformFinalBlock(data, 0, data.Length); return Convert.ToBase64String(sha.Hash); } }
/// <summary> /// Encrypts a string using the SHA256 algorithm. /// </summary> /// <param name="plainMessage"> /// The plain Message. /// </param> /// <returns> /// The hash password. /// </returns> public static string HashPassword(string plainMessage) { var data = Encoding.UTF8.GetBytes(plainMessage); using (HashAlgorithm sha = new SHA256Managed()) { sha.TransformFinalBlock(data, 0, data.Length); return Convert.ToBase64String(sha.Hash); } }
public static UInt256 ComputeHash(IChainState chainState) { using (var sha256 = new SHA256Managed()) { // add each unspent tx to hash foreach (var unspentTx in chainState.ReadUnspentTransactions()) { var unspentTxBytes = DataEncoder.EncodeUnspentTx(unspentTx); sha256.TransformBlock(unspentTxBytes, 0, unspentTxBytes.Length, unspentTxBytes, 0); } // finalize hash sha256.TransformFinalBlock(new byte[0], 0, 0); // hash again to return double-hashed utxo committment return new UInt256(SHA256Static.ComputeHash(sha256.Hash)); } }
public static string Calculate_Hash(string fileName) { long read = 0; var r = -1; const long bytesToRead = 100 * 1024 * 1024; const int bufferSize = 4096; var buffer = new byte[bufferSize]; var sha = new SHA256Managed(); using (var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read)) { while (read <= bytesToRead && r != 0) { read += (r = stream.Read(buffer, 0, bufferSize)); sha.TransformBlock(buffer, 0, r, null, 0); } } sha.TransformFinalBlock(buffer, 0, 0); return string.Join("", sha.Hash.Select(x => x.ToString("x2"))); }
/// <summary> /// Generate a Mavlink Packet and write to serial /// </summary> /// <param name="messageType">type number = MAVLINK_MSG_ID</param> /// <param name="indata">struct of data</param> void generatePacket(int messageType, object indata) { if (!BaseStream.IsOpen) { return; } if (ReadOnly) { // allow these messages if (messageType == (byte) MAVLink.MAVLINK_MSG_ID.MISSION_REQUEST_LIST || messageType == (byte) MAVLink.MAVLINK_MSG_ID.MISSION_REQUEST_PARTIAL_LIST || messageType == (byte) MAVLink.MAVLINK_MSG_ID.MISSION_REQUEST || messageType == (byte) MAVLink.MAVLINK_MSG_ID.PARAM_REQUEST_LIST || messageType == (byte) MAVLink.MAVLINK_MSG_ID.PARAM_REQUEST_READ || messageType == (byte) MAVLink.MAVLINK_MSG_ID.RALLY_FETCH_POINT || messageType == (byte) MAVLink.MAVLINK_MSG_ID.FENCE_FETCH_POINT ) { } else { return; } } lock (objlock) { byte[] data = MavlinkUtil.StructureToByteArray(indata); byte[] packet = new byte[0]; int i = 0; if (!mavlinkv2) { //Console.WriteLine(DateTime.Now + " PC Doing req "+ messageType + " " + this.BytesToRead); packet = new byte[data.Length + 6 + 2]; packet[0] = MAVLINK_STX_MAVLINK1; packet[1] = (byte) data.Length; packet[2] = (byte) packetcount; packetcount++; packet[3] = gcssysid; packet[4] = (byte) MAV_COMPONENT.MAV_COMP_ID_MISSIONPLANNER; packet[5] = (byte)messageType; i = 6; foreach (byte b in data) { packet[i] = b; i++; } ushort checksum = MavlinkCRC.crc_calculate(packet, packet[1] + 6); checksum = MavlinkCRC.crc_accumulate(MAVLINK_MESSAGE_CRCS[(uint)messageType], checksum); byte ck_a = (byte) (checksum & 0xFF); ///< High byte byte ck_b = (byte) (checksum >> 8); ///< Low byte packet[i] = ck_a; i += 1; packet[i] = ck_b; i += 1; } else if (mavlinkv2) { packet = new byte[data.Length + MAVLINK_NUM_HEADER_BYTES + MAVLINK_NUM_CHECKSUM_BYTES + MAVLINK_SIGNATURE_BLOCK_LEN]; packet[0] = MAVLINK_STX ; packet[1] = (byte)data.Length; packet[2] = 0; // incompat if (MAV.signing) // current mav packet[2] |= MAVLINK_IFLAG_SIGNED; packet[3] = 0; // compat packet[4] = (byte)packetcount; packetcount++; packet[5] = gcssysid; packet[6] = (byte)MAV_COMPONENT.MAV_COMP_ID_MISSIONPLANNER; packet[7] = (byte)(messageType & 0xff); packet[8] = (byte)((messageType >> 8) & 0xff); packet[9] = (byte)((messageType >> 16) & 0xff); i = 10; foreach (byte b in data) { packet[i] = b; i++; } ushort checksum = MavlinkCRC.crc_calculate(packet, packet[1] + MAVLINK_NUM_HEADER_BYTES); checksum = MavlinkCRC.crc_accumulate(MAVLINK_MESSAGE_CRCS[(uint)messageType], checksum); byte ck_a = (byte)(checksum & 0xFF); ///< High byte byte ck_b = (byte)(checksum >> 8); ///< Low byte packet[i] = ck_a; i += 1; packet[i] = ck_b; i += 1; if (MAV.signing) { //https://docs.google.com/document/d/1ETle6qQRcaNWAmpG2wz0oOpFKSF_bcTmYMQvtTGI8ns/edit /* 8 bits of link ID 48 bits of timestamp 48 bits of signature */ // signature = sha256_48(secret_key + header + payload + CRC + link-ID + timestamp) var timestamp = (UInt64) ((DateTime.UtcNow - new DateTime(2015, 1, 1)).TotalMilliseconds*1000); var timebytes = BitConverter.GetBytes(timestamp); var sig = new byte[7]; // 13 includes the outgoing hash sig[0] = 0; Array.Copy(timebytes, 0, sig, 1, 6); // timestamp //Console.WriteLine("gen linkid {0}, time {1} {2} {3} {4} {5} {6}", sig[0], sig[1], sig[2], sig[3], sig[4], sig[5], sig[6]); using (SHA256Managed signit = new SHA256Managed()) { signit.TransformBlock(signingKey, 0, signingKey.Length, null, 0); signit.TransformBlock(packet, 0, i, null, 0); signit.TransformFinalBlock(sig, 0, sig.Length); var ctx = signit.Hash; // trim to 48 Array.Resize(ref ctx, 6); foreach (byte b in sig) { packet[i] = b; i++; } foreach (byte b in ctx) { packet[i] = b; i++; } } } } if (BaseStream.IsOpen) { BaseStream.Write(packet, 0, i); _bytesSentSubj.OnNext(i); } try { if (logfile != null && logfile.CanWrite) { lock (logfile) { byte[] datearray = BitConverter.GetBytes( (UInt64) ((DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds*1000)); Array.Reverse(datearray); logfile.Write(datearray, 0, datearray.Length); logfile.Write(packet, 0, i); } } } catch { } } }
/// <summary> /// Serial Reader to read mavlink packets. POLL method /// </summary> /// <returns></returns> public MAVLinkMessage readPacket() { byte[] buffer = new byte[MAVLINK_MAX_PACKET_LEN + 25]; int count = 0; int length = 0; int readcount = 0; BaseStream.ReadTimeout = 1200; // 1200 ms between chars - the gps detection requires this. DateTime start = DateTime.Now; //Console.WriteLine(DateTime.Now.Millisecond + " SR0 " + BaseStream.BytesToRead); lock (readlock) { lastbad = new byte[2]; //Console.WriteLine(DateTime.Now.Millisecond + " SR1 " + BaseStream.BytesToRead); while (BaseStream.IsOpen || logreadmode) { try { if (readcount > 300) { log.Info("MAVLink readpacket No valid mavlink packets"); break; } readcount++; if (logreadmode) { buffer = readlogPacketMavlink().buffer; if (buffer.Length == 0) return new MAVLinkMessage(); } else { // time updated for internal reference MAV.cs.datetime = DateTime.Now; DateTime to = DateTime.Now.AddMilliseconds(BaseStream.ReadTimeout); // Console.WriteLine(DateTime.Now.Millisecond + " SR1a " + BaseStream.BytesToRead); while (BaseStream.IsOpen && BaseStream.BytesToRead <= 0) { if (DateTime.Now > to) { log.InfoFormat("MAVLINK: 1 wait time out btr {0} len {1}", BaseStream.BytesToRead, length); throw new TimeoutException("Timeout"); } System.Threading.Thread.Sleep(1); //Console.WriteLine(DateTime.Now.Millisecond + " SR0b " + BaseStream.BytesToRead); } //Console.WriteLine(DateTime.Now.Millisecond + " SR1a " + BaseStream.BytesToRead); if (BaseStream.IsOpen) { BaseStream.Read(buffer, count, 1); if (rawlogfile != null && rawlogfile.CanWrite) rawlogfile.WriteByte(buffer[count]); } //Console.WriteLine(DateTime.Now.Millisecond + " SR1b " + BaseStream.BytesToRead); } } catch (Exception e) { log.Info("MAVLink readpacket read error: " + e.ToString()); break; } // check if looks like a mavlink packet and check for exclusions and write to console if (buffer[0] != 0xfe && buffer[0] != 'U' && buffer[0] != 0xfd) { if (buffer[0] >= 0x20 && buffer[0] <= 127 || buffer[0] == '\n' || buffer[0] == '\r') { // check for line termination if (buffer[0] == '\r' || buffer[0] == '\n') { // check new line is valid if (buildplaintxtline.Length > 3) plaintxtline = buildplaintxtline; // reset for next line buildplaintxtline = ""; } TCPConsole.Write(buffer[0]); Console.Write((char)buffer[0]); buildplaintxtline += (char)buffer[0]; } _bytesReceivedSubj.OnNext(1); count = 0; lastbad[0] = lastbad[1]; lastbad[1] = buffer[0]; buffer[1] = 0; continue; } // reset count on valid packet readcount = 0; //Console.WriteLine(DateTime.Now.Millisecond + " SR2 " + BaseStream.BytesToRead); mavlinkv2 = buffer[0] == MAVLINK_STX ? true : false; int headerlength = mavlinkv2 ? MAVLINK_CORE_HEADER_LEN : MAVLINK_CORE_HEADER_MAVLINK1_LEN; int headerlengthstx = headerlength + 1; // check for a header if (buffer[0] == 0xfe || buffer[0] == 0xfd || buffer[0] == 'U') { // if we have the header, and no other chars, get the length and packet identifiers if (count == 0 && !logreadmode) { DateTime to = DateTime.Now.AddMilliseconds(BaseStream.ReadTimeout); while (BaseStream.IsOpen && BaseStream.BytesToRead < headerlength) { if (DateTime.Now > to) { log.InfoFormat("MAVLINK: 2 wait time out btr {0} len {1}", BaseStream.BytesToRead, length); throw new Exception("Timeout"); } System.Threading.Thread.Sleep(1); } int read = BaseStream.Read(buffer, 1, headerlength); count = read; if (rawlogfile != null && rawlogfile.CanWrite) rawlogfile.Write(buffer, 1, read); } // packet length if (buffer[0] == 0xfd) { length = buffer[1] + headerlengthstx + 2 - 2; // data + header + checksum - magic - length if ((buffer[2] & MAVLINK_IFLAG_SIGNED) > 0) { length += MAVLINK_SIGNATURE_BLOCK_LEN; } } else { length = buffer[1] + headerlengthstx + 2 - 2; // data + header + checksum - U - length } if (count >= headerlength || logreadmode) { try { if (logreadmode) { } else { DateTime to = DateTime.Now.AddMilliseconds(BaseStream.ReadTimeout); while (BaseStream.IsOpen && BaseStream.BytesToRead < (length - count)) { if (DateTime.Now > to) { log.InfoFormat("MAVLINK: 3 wait time out btr {0} len {1}", BaseStream.BytesToRead, length); break; } System.Threading.Thread.Sleep(1); } if (BaseStream.IsOpen) { int read = BaseStream.Read(buffer, headerlengthstx, length - (headerlengthstx-2)); if (rawlogfile != null && rawlogfile.CanWrite) { // write only what we read, temp is the whole packet, so 6-end rawlogfile.Write(buffer, headerlengthstx, read); } } } count = length + 2; } catch { break; } break; } } count++; if (count == 299) break; } //Console.WriteLine(DateTime.Now.Millisecond + " SR3 " + BaseStream.BytesToRead); } // end readlock // resize the packet to the correct length Array.Resize<byte>(ref buffer, count); // add byte count _bytesReceivedSubj.OnNext(buffer.Length); // update bps statistics if (bpstime.Second != DateTime.Now.Second) { long btr = 0; if (BaseStream != null && BaseStream.IsOpen) { btr = BaseStream.BytesToRead; } else if (logreadmode) { btr = logplaybackfile.BaseStream.Length - logplaybackfile.BaseStream.Position; } Console.Write("bps {0} loss {1} left {2} mem {3} \n", bps1, MAV.synclost, btr, System.GC.GetTotalMemory(false)/1024/1024.0); bps2 = bps1; // prev sec bps1 = 0; // current sec bpstime = DateTime.Now; } bps1 += buffer.Length; if (buffer.Length == 0) return new MAVLinkMessage(); MAVLinkMessage message = new MAVLinkMessage(buffer); uint msgid = message.msgid; message_info msginfo; msginfo = MAVLINK_MESSAGE_INFOS.SingleOrDefault(p => p.msgid == msgid); // calc crc var sigsize = (message.sig != null) ? MAVLINK_SIGNATURE_BLOCK_LEN : 0; ushort crc = MavlinkCRC.crc_calculate(buffer, message.Length - sigsize-MAVLINK_NUM_CHECKSUM_BYTES); // calc extra bit of crc for mavlink 1.0/2.0 if (message.header == 0xfe || message.header == 0xfd) { crc = MavlinkCRC.crc_accumulate(msginfo.crc, crc); } // check message length vs table if (message.payloadlength != msginfo.length) { if (msginfo.length == 0) // pass for unknown packets { log.InfoFormat("unknown packet type {0}", message.msgid); } else { log.InfoFormat("Mavlink Bad Packet (Len Fail) len {0} pkno {1}", buffer.Length, message.msgid); if (buffer.Length == 11 && message.header == 'U' && message.msgid == 0) // check for 0.9 hb packet { string messagehb = "Mavlink 0.9 Heartbeat, Please upgrade your AP, This planner is for Mavlink 1.0\n\n"; Console.WriteLine(messagehb); if (logreadmode) logplaybackfile.BaseStream.Seek(0, SeekOrigin.End); throw new Exception(messagehb); } return new MAVLinkMessage(); } } // check crc if ((message.crc16 >> 8) != (crc >> 8) || (message.crc16 & 0xff) != (crc & 0xff)) { if (message.msgid != -1 && buffer.Length > 5 && msginfo.name != null) log.InfoFormat("Mavlink Bad Packet (crc fail) len {0} crc {1} vs {4} pkno {2} {3}", buffer.Length, crc, message.msgid, msginfo.name.ToString(), message.crc16); if (logreadmode) log.InfoFormat("bad packet pos {0} ", logplaybackfile.BaseStream.Position); return new MAVLinkMessage(); } byte sysid = message.sysid; byte compid = message.compid; byte packetSeqNo = message.seq; //check if sig was included in packet, and we are not ignoring the signature (signing isnt checked else we wont enable signing) if (message.sig != null && !MAVlist[sysid,compid].signingignore) { using (SHA256Managed signit = new SHA256Managed()) { signit.TransformBlock(signingKey, 0, signingKey.Length, null, 0); signit.TransformFinalBlock(message.buffer, 0, message.Length - MAVLINK_SIGNATURE_BLOCK_LEN + 7); var ctx = signit.Hash; // trim to 48 Array.Resize(ref ctx, 6); //Console.WriteLine("linkid {0}, time {1} {2} {3} {4} {5} {6} - {7}", message.sig[0], message.sig[1], message.sig[2], message.sig[3], message.sig[4], message.sig[5], message.sig[6], message.sigTimestamp); for (int i = 0; i < ctx.Length; i++) { if (ctx[i] != message.sig[7 + i]) { log.InfoFormat("Packet failed signature but passed crc"); return new MAVLinkMessage(); } } MAVlist[sysid, compid].linkid = message.sig[0]; enableSigning(); } } // packet is now verified // update packet loss statistics if (!logreadmode && MAVlist[sysid, compid].packetlosttimer.AddSeconds(5) < DateTime.Now) { MAVlist[sysid, compid].packetlosttimer = DateTime.Now; MAVlist[sysid, compid].packetslost = (MAVlist[sysid, compid].packetslost*0.8f); MAVlist[sysid, compid].packetsnotlost = (MAVlist[sysid, compid].packetsnotlost*0.8f); } else if (logreadmode && MAVlist[sysid, compid].packetlosttimer.AddSeconds(5) < lastlogread) { MAVlist[sysid, compid].packetlosttimer = lastlogread; MAVlist[sysid, compid].packetslost = (MAVlist[sysid, compid].packetslost*0.8f); MAVlist[sysid, compid].packetsnotlost = (MAVlist[sysid, compid].packetsnotlost*0.8f); } // extract wp's from stream if (buffer.Length >= 5) { getWPsfromstream(ref message, sysid, compid); } // if its a gcs packet - dont process further if (buffer.Length >= 5 && (sysid == 255 || sysid == 253) && logreadmode) // gcs packet { return message; } // create a state for any sysid/compid if (!MAVlist.Contains(sysid, compid)) { // create an item - hidden MAVlist.AddHiddenList(sysid, compid); } try { if ((message.header == 'U' || message.header == 0xfe || message.header == 0xfd) && buffer.Length >= message.payloadlength) { // check if we lost pacakets based on seqno int expectedPacketSeqNo = ((MAVlist[sysid, compid].recvpacketcount + 1)%0x100); { // the seconds part is to work around a 3dr radio bug sending dup seqno's if (packetSeqNo != expectedPacketSeqNo && packetSeqNo != MAVlist[sysid, compid].recvpacketcount) { MAVlist[sysid, compid].synclost++; // actualy sync loss's int numLost = 0; if (packetSeqNo < ((MAVlist[sysid, compid].recvpacketcount + 1))) // recvpacketcount = 255 then 10 < 256 = true if was % 0x100 this would fail { numLost = 0x100 - expectedPacketSeqNo + packetSeqNo; } else { numLost = packetSeqNo - expectedPacketSeqNo; } MAVlist[sysid, compid].packetslost += numLost; WhenPacketLost.OnNext(numLost); log.InfoFormat("mav {2}-{4} seqno {0} exp {3} pkts lost {1}", packetSeqNo, numLost, sysid, expectedPacketSeqNo,compid); } MAVlist[sysid, compid].packetsnotlost++; //Console.WriteLine("{0} {1}", sysid, packetSeqNo); MAVlist[sysid, compid].recvpacketcount = packetSeqNo; } WhenPacketReceived.OnNext(1); // packet stats per mav if (double.IsInfinity(MAVlist[sysid, compid].packetspersecond[msgid])) MAVlist[sysid, compid].packetspersecond[msgid] = 0; MAVlist[sysid, compid].packetspersecond[msgid] = (((1000 / ((DateTime.Now - MAVlist[sysid, compid] .packetspersecondbuild[msgid]) .TotalMilliseconds) + MAVlist[sysid, compid].packetspersecond[ msgid]) / 2)); MAVlist[sysid, compid].packetspersecondbuild[msgid] = DateTime.Now; //Console.WriteLine("Packet {0}",temp[5]); // store packet history lock (objlock) { MAVlist[sysid, compid].packets[msgid] = message; // 3dr radio status packet are injected into the current mav if (msgid == (byte)MAVLink.MAVLINK_MSG_ID.RADIO_STATUS || msgid == (byte)MAVLink.MAVLINK_MSG_ID.RADIO) { MAVlist[sysidcurrent, compidcurrent].packets[msgid] = message; } // adsb packets are forwarded and can be from any sysid/compid if (msgid == (byte)MAVLink.MAVLINK_MSG_ID.ADSB_VEHICLE) { var adsb = message.ToStructure<MAVLink.mavlink_adsb_vehicle_t>(); MainV2.instance.adsbPlanes[adsb.ICAO_address.ToString("X5")] = new MissionPlanner.Utilities.adsb.PointLatLngAltHdg(adsb.lat / 1e7, adsb.lon / 1e7, adsb.altitude / 1000, adsb.heading * 0.01f, adsb.ICAO_address.ToString("X5"), DateTime.Now); } } // set seens sysid's based on hb packet - this will hide 3dr radio packets if (msgid == (byte)MAVLink.MAVLINK_MSG_ID.HEARTBEAT) { mavlink_heartbeat_t hb = message.ToStructure<mavlink_heartbeat_t>(); // not a gcs if (hb.type != (byte) MAV_TYPE.GCS) { // add a seen sysid if (!MAVlist.Contains(sysid, compid, false)) { // ensure its set from connect or log playback MAVlist.Create(sysid, compid); MAVlist[sysid, compid].aptype = (MAV_TYPE) hb.type; MAVlist[sysid, compid].apname = (MAV_AUTOPILOT) hb.autopilot; setAPType(sysid, compid); } // attach to the only remote device. / default to first device seen if (MAVlist.Count == 1) { sysidcurrent = sysid; compidcurrent = compid; } } } // only process for active mav if (sysidcurrent == sysid && compidcurrent == compid) PacketReceived(message); if (debugmavlink) DebugPacket(message); if (msgid == (byte)MAVLink.MAVLINK_MSG_ID.STATUSTEXT) // status text { var msg = message.ToStructure<MAVLink.mavlink_statustext_t>(); byte sev = msg.severity; string logdata = Encoding.ASCII.GetString(msg.text); int ind = logdata.IndexOf('\0'); if (ind != -1) logdata = logdata.Substring(0, ind); log.Info(DateTime.Now + " " + sev + " " + logdata); MAVlist[sysid, compid].cs.messages.Add(logdata); bool printit = false; // the change of severity and the autopilot version where introduced at the same time, so any version non 0 can be used // copter 3.4+ // plane 3.4+ if (MAVlist[sysid, compid].cs.version.Major > 0 || MAVlist[sysid, compid].cs.version.Minor >= 4) { if (sev <= (byte) MAV_SEVERITY.WARNING) { printit = true; } } else { if (sev >= 3) { printit = true; } } if (logdata.StartsWith("Tuning:")) printit = true; if (printit) { MAVlist[sysid, compid].cs.messageHigh = logdata; MAVlist[sysid, compid].cs.messageHighTime = DateTime.Now; if (MainV2.speechEngine != null && MainV2.speechEngine.IsReady && Settings.Instance["speechenable"] != null && Settings.Instance["speechenable"].ToString() == "True") { MainV2.speechEngine.SpeakAsync(logdata); } } } if (lastparamset != DateTime.MinValue && lastparamset.AddSeconds(10) < DateTime.Now) { lastparamset = DateTime.MinValue; if (BaseStream.IsOpen) { doCommand(MAV_CMD.PREFLIGHT_STORAGE, 0, 0, 0, 0, 0, 0, 0); } } getWPsfromstream(ref message, sysid, compid); try { if (logfile != null && logfile.CanWrite && !logreadmode) { lock (logfile) { byte[] datearray = BitConverter.GetBytes( (UInt64) ((DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds*1000)); Array.Reverse(datearray); logfile.Write(datearray, 0, datearray.Length); logfile.Write(buffer, 0, buffer.Length); if (msgid == 0) { // flush on heartbeat - 1 seconds logfile.Flush(); rawlogfile.Flush(); } } } } catch (Exception ex) { log.Error(ex); } try { // full rw from mirror stream if (MirrorStream != null && MirrorStream.IsOpen) { MirrorStream.Write(buffer, 0, buffer.Length); while (MirrorStream.BytesToRead > 0) { byte[] buf = new byte[1024]; int len = MirrorStream.Read(buf, 0, buf.Length); if (MirrorStreamWrite) BaseStream.Write(buf, 0, len); } } } catch { } } } catch (Exception ex) { log.Error(ex); } // update last valid packet receive time MAVlist[sysid, compid].lastvalidpacket = DateTime.Now; return new MAVLinkMessage(buffer); }
/// <summary> /// Encrypts a string using the SHA256 algorithm. /// </summary> private static string Encrypt(string plainMessage) { byte[] data = Encoding.UTF8.GetBytes(plainMessage); using (HashAlgorithm sha = new SHA256Managed()) { byte[] encryptedBytes = sha.TransformFinalBlock(data, 0, data.Length); return Convert.ToBase64String(sha.Hash); } }
public static byte[] GetBytes(byte[] password, byte[] salt, int iterations, int howManyBytes) { // round up uint cBlocks = (uint)((howManyBytes+ HASH_SIZE_IN_BYTES-1)/HASH_SIZE_IN_BYTES); // seed for the pseudo-random fcn: salt + block index byte[] saltAndIndex = new byte[salt.Length + 4]; Array.Copy(salt, 0, saltAndIndex, 0, salt.Length); byte[] output = new byte[cBlocks*HASH_SIZE_IN_BYTES]; int outputOffset = 0; SHA256Managed innerHash = new SHA256Managed(); SHA256Managed outerHash = new SHA256Managed(); // HMAC says the key must be hashed or padded with zeros // so it fits into a single block of the hash in use if (password.Length > BLOCK_SIZE_IN_BYTES) { password = innerHash.ComputeHash(password); } byte[] key = new byte[BLOCK_SIZE_IN_BYTES]; Array.Copy(password, 0, key, 0, password.Length); byte[] InnerKey = new byte[BLOCK_SIZE_IN_BYTES]; byte[] OuterKey = new byte[BLOCK_SIZE_IN_BYTES]; for (int i = 0; i < BLOCK_SIZE_IN_BYTES; ++i) { InnerKey[i] = (byte)(key[i] ^ IPAD); OuterKey[i] = (byte)(key[i] ^ OPAD); } // for each block of desired output for (int iBlock = 0; iBlock < cBlocks; ++iBlock) { // seed HMAC with salt & block index _incrementBigEndianIndex(saltAndIndex, salt.Length); byte[] U = saltAndIndex; for (int i = 0; i < iterations; ++i) { // simple implementation of HMAC-SHA-256 innerHash.Initialize(); innerHash.TransformBlock(InnerKey, 0, BLOCK_SIZE_IN_BYTES, InnerKey, 0); innerHash.TransformFinalBlock(U, 0, U.Length); byte[] temp = innerHash.Hash; outerHash.Initialize(); outerHash.TransformBlock(OuterKey, 0, BLOCK_SIZE_IN_BYTES, OuterKey, 0); outerHash.TransformFinalBlock(temp, 0, temp.Length); U = outerHash.Hash; // U = result of HMAC // xor result into output buffer _xorByteArray(U, 0, HASH_SIZE_IN_BYTES, output, outputOffset); } outputOffset += HASH_SIZE_IN_BYTES; } byte[] result = new byte[howManyBytes]; Array.Copy(output, 0, result, 0, howManyBytes); return result; }
/// <summary> /// Generate an encryption key for encrypting site parameters. /// </summary> /// <returns>A byte array containing the encryption key.</returns> private static byte[] GenerateEncryptionKey(string key) { // Generate an encryption key to encrypt with. This is based on the // machine name and username of the user, which probably aren't the best // choices, but should be unique for each user/machine. Note that we're // using the system default encoding here, rather than UTF-8; this is a bit // of legacy code, and we can't really change this without breaking existing // parameters. Since this is an internal thing, so it shouldn't be a problem. SHA256Managed hasher = new SHA256Managed(); byte[] cryptKey = Encoding.Default.GetBytes(Environment.MachineName + Environment.UserName + key); hasher.TransformFinalBlock(cryptKey, 0, cryptKey.Length); return hasher.Hash; }
/// <summary> /// Hash a string using the SHA256 algorithm. 32 bytes (hex): 64 unicode chars, 128 bytes /// </summary> public static string Sha256(this string plainMessage) { byte[] data = Encoding.UTF8.GetBytes(plainMessage); using (HashAlgorithm sha = new SHA256Managed()) { sha.TransformFinalBlock(data, 0, data.Length); var sb = new StringBuilder(); foreach (byte bit in sha.Hash) { sb.Append(bit.ToString("x2")); } return sb.ToString(); } }
/// <summary> /// Generates the play ready content key. /// </summary> /// <param name="keySeed">The key seed.</param> /// <param name="keyId">The key id.</param> /// <returns>The content key.</returns> public static byte[] GeneratePlayReadyContentKey(byte[] keySeed, Guid keyId) { if (keySeed == null) { throw new ArgumentNullException("keySeed"); } byte[] contentKey = new byte[EncryptionUtils.KeySizeInBytesForAes128]; // Truncate the key seed to 30 bytes. byte[] truncatedKeySeed = new byte[30]; if (keySeed.Length < truncatedKeySeed.Length) { throw new ArgumentOutOfRangeException("keySeed", "KeySeed must be at least 30 bytes in length"); } Array.Copy(keySeed, truncatedKeySeed, truncatedKeySeed.Length); // Get the keyId as a byte array. byte[] keyIdAsBytes = keyId.ToByteArray(); using (SHA256Managed sha_A = new SHA256Managed()) using (SHA256Managed sha_B = new SHA256Managed()) using (SHA256Managed sha_C = new SHA256Managed()) { // Create sha_A_Output buffer. It is the SHA of the truncatedKeySeed and the keyIdAsBytes. sha_A.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0); sha_A.TransformFinalBlock(keyIdAsBytes, 0, keyIdAsBytes.Length); byte[] sha_A_Output = sha_A.Hash; // Create sha_B_Output buffer. It is the SHA of the truncatedKeySeed, the keyIdAsBytes, and // the truncatedKeySeed again. sha_B.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0); sha_B.TransformBlock(keyIdAsBytes, 0, keyIdAsBytes.Length, keyIdAsBytes, 0); sha_B.TransformFinalBlock(truncatedKeySeed, 0, truncatedKeySeed.Length); byte[] sha_B_Output = sha_B.Hash; // Create sha_C_Output buffer. It is the SHA of the truncatedKeySeed, the keyIdAsBytes, // the truncatedKeySeed again, and the keyIdAsBytes again. sha_C.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0); sha_C.TransformBlock(keyIdAsBytes, 0, keyIdAsBytes.Length, keyIdAsBytes, 0); sha_C.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0); sha_C.TransformFinalBlock(keyIdAsBytes, 0, keyIdAsBytes.Length); byte[] sha_C_Output = sha_C.Hash; for (int i = 0; i < EncryptionUtils.KeySizeInBytesForAes128; i++) { contentKey[i] = Convert.ToByte(sha_A_Output[i] ^ sha_A_Output[i + EncryptionUtils.KeySizeInBytesForAes128] ^ sha_B_Output[i] ^ sha_B_Output[i + EncryptionUtils.KeySizeInBytesForAes128] ^ sha_C_Output[i] ^ sha_C_Output[i + EncryptionUtils.KeySizeInBytesForAes128]); } } return contentKey; }
static public byte[] GeneratePlayReadyContentKey(byte[] keySeed, Guid keyId) { const int DRM_AES_KEYSIZE_128 = 16; byte[] contentKey = new byte[DRM_AES_KEYSIZE_128]; // // Truncate the key seed to 30 bytes, key seed must be at least 30 bytes long. // byte[] truncatedKeySeed = new byte[30]; Array.Copy(keySeed, truncatedKeySeed, truncatedKeySeed.Length); // // Get the keyId as a byte array // byte[] keyIdAsBytes = keyId.ToByteArray(); // // Create sha_A_Output buffer. It is the SHA of the truncatedKeySeed and the keyIdAsBytes // SHA256Managed sha_A = new SHA256Managed(); sha_A.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0); sha_A.TransformFinalBlock(keyIdAsBytes, 0, keyIdAsBytes.Length); byte[] sha_A_Output = sha_A.Hash; // // Create sha_B_Output buffer. It is the SHA of the truncatedKeySeed, the keyIdAsBytes, and // the truncatedKeySeed again. // SHA256Managed sha_B = new SHA256Managed(); sha_B.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0); sha_B.TransformBlock(keyIdAsBytes, 0, keyIdAsBytes.Length, keyIdAsBytes, 0); sha_B.TransformFinalBlock(truncatedKeySeed, 0, truncatedKeySeed.Length); byte[] sha_B_Output = sha_B.Hash; // // Create sha_C_Output buffer. It is the SHA of the truncatedKeySeed, the keyIdAsBytes, // the truncatedKeySeed again, and the keyIdAsBytes again. // SHA256Managed sha_C = new SHA256Managed(); sha_C.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0); sha_C.TransformBlock(keyIdAsBytes, 0, keyIdAsBytes.Length, keyIdAsBytes, 0); sha_C.TransformBlock(truncatedKeySeed, 0, truncatedKeySeed.Length, truncatedKeySeed, 0); sha_C.TransformFinalBlock(keyIdAsBytes, 0, keyIdAsBytes.Length); byte[] sha_C_Output = sha_C.Hash; for (int i = 0; i < DRM_AES_KEYSIZE_128; i++) { contentKey[i] = Convert.ToByte(sha_A_Output[i] ^ sha_A_Output[i + DRM_AES_KEYSIZE_128] ^ sha_B_Output[i] ^ sha_B_Output[i + DRM_AES_KEYSIZE_128] ^ sha_C_Output[i] ^ sha_C_Output[i + DRM_AES_KEYSIZE_128]); } return contentKey; }