blocks|key|400675|text|作为对Hans答案的补充，这里有一个如何实现hasher的建议。Hans建议将指向非托管字符串的指针传递给哈希函数，但这意味着客户端代码(=哈希函数)需要处理非托管内存。这并不理想。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|400676|另一方面，您可以将回调替换为以下接口的实例：|400677|interface+Hasher+{
++++void+Reinitialize();
++++void+AddByte(byte+b);
++++byte[]+Result+{+get;+}
}|code-block|syntax|javascript|400678|这样，hasher+(尽管它变得稍微复杂一些)可以完全在托管区域中实现，而不会泄露安全信息。然后，您的HashSecureString将如下所示：|offset|length|style|CODE|400679|private+static+byte[]+HashSecureString(SecureString+ss,+Hasher+hasher)+{
++++IntPtr+bstr+=+Marshal.SecureStringToBSTR(ss);
++++try+{
++++++++int+length+=+Marshal.ReadInt32(bstr,+-4);

++++++++hasher.Reinitialize();

++++++++for+(int+i+=+0;+i+<+length;+i%2B%2B)
++++++++++++hasher.AddByte(Marshal.ReadByte(bstr,+i));

++++++++return+hasher.Result;
++++}
++++finally+{
++++++++Marshal.ZeroFreeBSTR(bstr);
++++}
}|400680|请注意finally块，以确保非托管内存已清零，无论哈希器实例做什么恶作剧。|400681|下面是一个简单(但不是很有用)的Hasher实现来说明该接口：|400682|sealed+class+SingleByteXor+:+Hasher+{
++++private+readonly+byte[]+data+=+new+byte[1];

++++public+void+Reinitialize()+{
++++++++data[0]+=+0;
++++}

++++public+void+AddByte(byte+b)+{
++++++++data[0]+%5E=+b;
++++}

++++public+byte[]+Result+{
++++++++get+{+return+data;+}
++++}
}|400683|entityMap^0|0|0|0|1F|G|0|0|3|7|0|G|6|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@$K|12|L|13|M|N]]|9|@]|A|$]]|$1|O|3|P|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|15|8|@$K|16|L|17|M|N]]|9|@]|A|$]]|$1|S|3|T|5|6|7|18|8|@$K|19|L|1A|M|N]]|9|@]|A|$]]|$1|U|3|V|5|F|7|1B|8|@]|9|@]|A|$G|H]]|$1|W|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|X|$]]

As a complement to Hans’ answer here’s a suggestion how to implement the hasher. Hans suggests passing the pointer to the unmanaged string to the hash function but that means that client code (= the hash function) needs to deal with unmanaged memory. That’s not ideal.

On the other hand, you can replace the callback by an instance of the following interface:

<pre><code>interface Hasher {
 void Reinitialize();
 void AddByte(byte b);
 byte[] Result { get; }
}
</code></pre>

That way the hasher (although it becomes slightly more complex) can be implemented wholly in managed land without leaking secure information. Your <code>HashSecureString</code> would then look as follows:

<pre><code>private static byte[] HashSecureString(SecureString ss, Hasher hasher) {
 IntPtr bstr = Marshal.SecureStringToBSTR(ss);
 try {
 int length = Marshal.ReadInt32(bstr, -4);

 hasher.Reinitialize();

 for (int i = 0; i &lt; length; i++)
 hasher.AddByte(Marshal.ReadByte(bstr, i));

 return hasher.Result;
 }
 finally {
 Marshal.ZeroFreeBSTR(bstr);
 }
}
</code></pre>

Note the <code>finally</code> block to make sure that the unmanaged memory is zeroed, no matter what shenanigans the hasher instance does.

Here’s a simple (and not very useful) <code>Hasher</code> implementation to illustrate the interface:

<pre><code>sealed class SingleByteXor : Hasher {
 private readonly byte[] data = new byte[1];

 public void Reinitialize() {
 data[0] = 0;
 }

 public void AddByte(byte b) {
 data[0] ^= b;
 }

 public byte[] Result {
 get { return data; }
 }
}
</code></pre>

blocks|key|182788|text|作为进一步的补充，您可以不将提供的逻辑@KonradRudolph和@HansPassant包装到自定义Stream实现中吗？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|182789|这将允许您使用HashAlgorithm.ComputeHash(Stream)方法，该方法将保持接口处于托管状态(尽管需要您及时处理流)。|182790|当然，由HashAlgorithm实现决定一次有多少数据进入内存(当然，这就是引用源的用途！)|182791|只是一个想法..。|182792|public+class+SecureStringStream+:+Stream
{
++++public+override+bool+CanRead+{+get+{+return+true;+}+}
++++public+override+bool+CanWrite+{+get+{+return+false;+}+}
++++public+override+bool+CanSeek+{+get+{+return+false;+}+}

++++public+override+long+Position
++++{
++++++++get+{+return+_pos;+}
++++++++set+{+throw+new+NotSupportedException();+}
++++}

++++public+override+void+Flush()+{+throw+new+NotSupportedException();+}
++++public+override+long+Seek(long+offset,+SeekOrigin+origin)+{+throw+new+NotSupportedException();+}
++++public+override+void+SetLength(long+value)+{+throw+new+NotSupportedException();+}
++++public+override+void+Write(byte[]+buffer,+int+offset,+int+count)+{+throw+new+NotSupportedException();+}

++++private+readonly+IntPtr+_bstr+=+IntPtr.Zero;
++++private+readonly+int+_length;
++++private+int+_pos;

++++public+SecureStringStream(SecureString+str)
++++{
++++++++if+(str+==+null)+throw+new+ArgumentNullException("str");
++++++++_bstr+=+Marshal.SecureStringToBSTR(str);

++++++++try
++++++++{
++++++++++++_length+=+Marshal.ReadInt32(_bstr,+-4);
++++++++++++_pos+=+0;
++++++++}
++++++++catch
++++++++{
++++++++++++if+(_bstr+!=+IntPtr.Zero)+Marshal.ZeroFreeBSTR(_bstr);
++++++++++++throw;
++++++++}
++++}

++++public+override+long+Length+{+get+{+return+_length;+}+}

++++public+override+int+Read(byte[]+buffer,+int+offset,+int+count)
++++{
++++++++if+(buffer+==+null)+throw+new+ArgumentNullException("buffer");
++++++++if+(offset+<+0)+throw+new+ArgumentOutOfRangeException("offset");
++++++++if+(count+<+0)+throw+new+ArgumentOutOfRangeException("count");
++++++++if+(offset+%2B+count+>+buffer.Length)+throw+new+ArgumentException("offset+%2B+count+>+buffer");

++++++++if+(count+>+0+&&+_pos%2B%2B+<+_length)+
++++++++{
++++++++++++buffer[offset]+=+Marshal.ReadByte(_bstr,+_pos%2B%2B);
++++++++++++return+1;
++++++++}
++++++++else+return+0;
++++}

++++protected+override+void+Dispose(bool+disposing)
++++{
++++++++try+{+if+(_bstr+!=+IntPtr.Zero)+Marshal.ZeroFreeBSTR(_bstr);+}
++++++++finally+{+base.Dispose(disposing);+}
++++}
}

void+RunMe()
{
++++using+(SecureString+s+=+new+SecureString())
++++{
++++++++foreach+(char+c+in+"jimbobmcgee")+s.AppendChar(c);
++++++++s.MakeReadOnly();

++++++++using+(SecureStringStream+ss+=+new+SecureStringStream(s))
++++++++using+(HashAlgorithm+h+=+MD5.Create())
++++++++{
++++++++++++Console.WriteLine(Convert.ToBase64String(h.ComputeHash(ss)));
++++++++}
++++}
}|code-block|syntax|javascript|182793|entityMap^0|1G|6|0|7|X|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|Z|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|10|8|@]|D|@]|E|$O|P]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

As a further complement, could you not wrap the logic @KonradRudolph and @HansPassant supplied into a custom <code>Stream</code> implementation?

This would allow you to use the <code>HashAlgorithm.ComputeHash(Stream)</code> method, which would keep the interface managed (although it would be down to you to dispose the stream in good time).

Of course, you are at the mercy of the HashAlgorithm implementation as to how much data ends up in memory at a time (but, of course, that's what the reference source is for!)

Just an idea...

<pre><code>public class SecureStringStream : Stream
{
 public override bool CanRead { get { return true; } }
 public override bool CanWrite { get { return false; } }
 public override bool CanSeek { get { return false; } }

 public override long Position
 {
 get { return _pos; }
 set { throw new NotSupportedException(); }
 }

 public override void Flush() { throw new NotSupportedException(); }
 public override long Seek(long offset, SeekOrigin origin) { throw new NotSupportedException(); }
 public override void SetLength(long value) { throw new NotSupportedException(); }
 public override void Write(byte[] buffer, int offset, int count) { throw new NotSupportedException(); }

 private readonly IntPtr _bstr = IntPtr.Zero;
 private readonly int _length;
 private int _pos;

 public SecureStringStream(SecureString str)
 {
 if (str == null) throw new ArgumentNullException("str");
 _bstr = Marshal.SecureStringToBSTR(str);

 try
 {
 _length = Marshal.ReadInt32(_bstr, -4);
 _pos = 0;
 }
 catch
 {
 if (_bstr != IntPtr.Zero) Marshal.ZeroFreeBSTR(_bstr);
 throw;
 }
 }

 public override long Length { get { return _length; } }

 public override int Read(byte[] buffer, int offset, int count)
 {
 if (buffer == null) throw new ArgumentNullException("buffer");
 if (offset &lt; 0) throw new ArgumentOutOfRangeException("offset");
 if (count &lt; 0) throw new ArgumentOutOfRangeException("count");
 if (offset + count &gt; buffer.Length) throw new ArgumentException("offset + count &gt; buffer");

 if (count &gt; 0 &amp;&amp; _pos++ &lt; _length) 
 {
 buffer[offset] = Marshal.ReadByte(_bstr, _pos++);
 return 1;
 }
 else return 0;
 }

 protected override void Dispose(bool disposing)
 {
 try { if (_bstr != IntPtr.Zero) Marshal.ZeroFreeBSTR(_bstr); }
 finally { base.Dispose(disposing); }
 }
}

void RunMe()
{
 using (SecureString s = new SecureString())
 {
 foreach (char c in "jimbobmcgee") s.AppendChar(c);
 s.MakeReadOnly();

 using (SecureStringStream ss = new SecureStringStream(s))
 using (HashAlgorithm h = MD5.Create())
 {
 Console.WriteLine(Convert.ToBase64String(h.ComputeHash(ss)));
 }
 }
}
</code></pre>

blocks|key|400775|text|总是有可能使用非托管CryptoApi或CNG函数。请记住，SecureString的设计考虑到了一个非托管消费者，该消费者可以完全控制内存管理。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|400776|如果你想坚持使用C#，你应该固定临时数组，以防止GC在你有机会清理它之前移动它：|400777|private+static+byte[]+HashSecureString(SecureString+input,+Func<byte[],+byte[]>+hash)
{
++++var+bstr+=+Marshal.SecureStringToBSTR(input);
++++var+length+=+Marshal.ReadInt32(bstr,+-4);
++++var+bytes+=+new+byte[length];

++++var+bytesPin+=+GCHandle.Alloc(bytes,+GCHandleType.Pinned);
++++try+{
++++++++Marshal.Copy(bstr,+bytes,+0,+length);
++++++++Marshal.ZeroFreeBSTR(bstr);

++++++++return+hash(bytes);
++++}+finally+{
++++++++for+(var+i+=+0;+i+<+bytes.Length;+i%2B%2B)+{+
++++++++++++bytes[i]+=+0;+
++++++++}

++++++++bytesPin.Free();
++++}
}|code-block|syntax|javascript|400778|entityMap|0|LINK|mutability|MUTABLE|url|https://msdn.microsoft.com/en-us/library/windows/desktop/aa380255%2528v=vs.85%2529.aspx|1|https://msdn.microsoft.com/en-us/library/windows/desktop/aa376210%2528v=vs.85%2529.aspx^0|U|C|A|9|0|K|3|1|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]|$9|12|A|13|1|14]]|E|$]]|$1|F|3|G|5|6|7|15|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

There's always the possibility of using the unmanaged <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/aa380255%28v=vs.85%29.aspx" rel="noreferrer">CryptoApi</a> or <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/aa376210%28v=vs.85%29.aspx" rel="noreferrer">CNG</a> functions.
Bear in mind that <code>SecureString</code> was designed with an unmanaged consumer which has full control over memory management in mind.

If you want to stick to C#, you should pin the temporary array to prevent the GC from moving it around before you get a chance to scrub it:

<pre><code>private static byte[] HashSecureString(SecureString input, Func&lt;byte[], byte[]&gt; hash)
{
 var bstr = Marshal.SecureStringToBSTR(input);
 var length = Marshal.ReadInt32(bstr, -4);
 var bytes = new byte[length];

 var bytesPin = GCHandle.Alloc(bytes, GCHandleType.Pinned);
 try {
 Marshal.Copy(bstr, bytes, 0, length);
 Marshal.ZeroFreeBSTR(bstr);

 return hash(bytes);
 } finally {
 for (var i = 0; i &lt; bytes.Length; i++) { 
 bytes[i] = 0; 
 }

 bytesPin.Free();
 }
}
</code></pre>

In .NET, we have the SecureString class, which is all very well until you come to try and use it, as to (for example) hash the string, you need the plaintext. I've had a go here at writing a function that will hash a SecureString, given a hash function that takes a byte array and outputs a byte array.

<pre><code>private static byte[] HashSecureString(SecureString ss, Func&lt;byte[], byte[]&gt; hash)
{
 // Convert the SecureString to a BSTR
 IntPtr bstr = Marshal.SecureStringToBSTR(ss);

 // BSTR contains the length of the string in bytes in an
 // Int32 stored in the 4 bytes prior to the BSTR pointer
 int length = Marshal.ReadInt32(bstr, -4);

 // Allocate a byte array to copy the string into
 byte[] bytes = new byte[length];

 // Copy the BSTR to the byte array
 Marshal.Copy(bstr, bytes, 0, length);

 // Immediately destroy the BSTR as we don't need it any more
 Marshal.ZeroFreeBSTR(bstr);

 // Hash the byte array
 byte[] hashed = hash(bytes);

 // Destroy the plaintext copy in the byte array
 for (int i = 0; i &lt; length; i++) { bytes[i] = 0; }

 // Return the hash
 return hashed;
}
</code></pre>

I believe this will correctly hash the string, and will correctly scrub any copies of the plaintext from memory by the time the function returns, assuming the provided hash function is well behaved and doesn't make any copies of the input that it doesn't scrub itself. Have I missed anything here?

Hashing a SecureString in .NET

哈希函数

内存管理

在.NET中，我们有SecureString类，在您尝试使用它之前，它是非常好的，至于(例如)散列字符串，您需要明文。我在这里尝试编写了一个函数，它将对SecureString进行散列，给定一个散列函数，该函数接受一个字节数组并输出一个字节数组。private static byte[] HashSecureStrin...

问在.NET中散列SecureString
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在.NET中散列SecureStringEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在.NET中散列SecureString
EN