C#

using System;
using System.Text;
using System.Security.Cryptography;
using System.Runtime.InteropServices;
using System.Security;
using System.IO;

namespace UtilityControls
    {
    /// <summary>
    /// Supports SHA2 hash processing
    /// NOTE: SHA3 is under developemnt and the specification is due in 2012
    /// </summary>
    public class SHA2Hash
        {
        #region Fields
        private byte[] _SHA2Data;
        /// <summary>
        /// Bits in an SHA2 hash
        /// </summary>
        public const int SHA2Bits = 512;
        /// <summary>
        /// Bytes in an SHA2 hash
        /// </summary>
        public const int SHA2Bytes = SHA2Bits / 8;
        /// <summary>
        /// Size of SHA2Hash string
        /// </summary>
        public const int Length = SHA2Bytes * 2;     // As in SHA2 as a string...
        #endregion

        #region Properties
        /// <summary>
        /// Returns the SHA2 hash as a string
        /// </summary>
        public string SHA2data
            {
            get
                {
                StringBuilder sb = new StringBuilder(Length);
                foreach (byte b in _SHA2Data)
                    {
                    sb.Append(b.ToString("x2"));
                    }
                return sb.ToString();
                }
            }
        #endregion

        #region Constructors
        /// <summary>
        /// Constructs an SHA2 hash from a stream
        /// </summary>
        /// <param name="s">stream, data to construct SHA2 from</param>
        public SHA2Hash(Stream s)
            {
            SHA512 shaM = new SHA512Managed();
            _SHA2Data = shaM.ComputeHash(s);
            }

        /// <summary>
        /// Constructs an SHA2 hash from a SecureString
        /// </summary>
        /// <param name="ss">SecureString, data to construct SHA2 from</param>
        public SHA2Hash(SecureString ss)
            {
            SHA512 shaM = new SHA512Managed();
            if (ss != null)
                {
                IntPtr ptr = Marshal.SecureStringToBSTR(ss);
                byte[] bs = Encoding.UTF8.GetBytes(Marshal.PtrToStringAuto(ptr));
                _SHA2Data = shaM.ComputeHash(bs);
                Marshal.ZeroFreeBSTR(ptr);
                }
            }

        /// <summary>
        /// Constructs an SHA2 hash from a string
        /// </summary>
        /// <param name="s">string, data to construct SHA2 from</param>
        public SHA2Hash(string s)
            {
            SHA512 shaM = new SHA512Managed();
            byte[] bs = Encoding.UTF8.GetBytes(s);
            _SHA2Data = shaM.ComputeHash(bs);
            }

        /// <summary>
        /// Constructs an SHA2 hash from a string containing an SHA2 hash
        /// </summary>
        /// <param name="s">string containing hash</param>
        /// <param name="bRestore">Always true</param>
        public SHA2Hash(string s, bool bRestore)
            {
            if (!bRestore)
                {
                throw new ApplicationException("Invalid Restore Constructor parameter");
                }
            if (s.Length == SHA2Hash.Length)
                {
                byte[] bytes = new byte[SHA2Hash.SHA2Bytes];
                char[] chars = s.ToCharArray();
                int i = 0;
                while ((i >= 0) && (i < SHA2Hash.SHA2Bytes))
                    {
                    if (StaticMethods.IsHex(chars[(i * 2) + 0]) && StaticMethods.IsHex(chars[(i * 2) + 1]))
                        {
                        byte b1 = StaticMethods.ByteHex(chars[(i * 2) + 0]);
                        byte b2 = StaticMethods.ByteHex(chars[(i * 2) + 1]);
                        bytes[i] = (byte) ((b1 << 4) | b2);
                        i++;
                        }
                    else
                        {
                        i = -1;
                        }
                    }
                if (i > 0)
                    {
                    _SHA2Data = bytes;
                    return;
                    }
                }
            throw new ApplicationException("Bad restore hash data");
            }

        /// <summary>
        /// Constructs an SHA2 hash from an array of bytes
        /// </summary>
        /// <param name="bytes">byte[], data to construct SHA2 from</param>
        public SHA2Hash(byte[] bytes)
            {
            SHA512 shaM = new SHA512Managed();
            _SHA2Data = shaM.ComputeHash(bytes);
            }

        /// <summary>
        /// Constructs an SHA2 hash from an array of chars
        /// </summary>
        /// <param name="chars">char[], data to construct SHA2 from</param>
        public SHA2Hash(char[] chars)
            {
            SHA512 shaM = new SHA512Managed();
            byte[] bs = Encoding.UTF8.GetBytes(chars);
            _SHA2Data = shaM.ComputeHash(bs);
            }
        #endregion

        #region Overrides
        /// <summary>
        /// Overridden to let HashTable and ArryList work
        /// </summary>
        /// <returns>Hash code for instance</returns>
        public override int GetHashCode()
            {
            int hash = 0;
            for (int i = 0; i < SHA2Bytes; i += 4)
                {
                hash ^= StaticMethods.LittleEndian(_SHA2Data[i + 0],
                                                   _SHA2Data[i + 1], 
                                                   _SHA2Data[i + 2], 
                                                   _SHA2Data[i + 3]);
                }
            return base.GetHashCode() ^ hash;
            }

        /// <summary>
        /// Performs an equality test between two SHA2Hashes
        /// </summary>
        /// <param name="obj">SHA2Hash to compare</param>
        /// <returns>true if the instances are the same</returns>
        public override bool Equals(object obj)
            {
            return (this == (SHA2Hash)obj);
            }
        #endregion

        #region Public methods
        /// <summary>
        /// Performs an equality test between two SHA2Hashes
        /// </summary>
        /// <param name="m1">LHS of == test</param>
        /// <param name="m2">RHS of == test</param>
        /// <returns>true if the SHA2Hashes are the same</returns>
        public static bool operator ==(SHA2Hash m1, SHA2Hash m2)
            {
            if ((object)m1 == null)
                {
                if ((object)m2 == null)
                    {
                    // Both null - i.e. if (instance == null)...
                    return true;
                    }
                }
            if (((object)m1 == null) || ((object)m2 == null))
                {
                return false;
                }
            for (int i = 0; i < SHA2Bytes; i++)
                {
                if (m1._SHA2Data[i] != m2._SHA2Data[i])
                    {
                    return false;
                    }
                }
            return true;
            }

        /// <summary>
        /// Performs an inequality test between two SHA2Hashes
        /// </summary>
        /// <param name="m1">LHS of == test</param>
        /// <param name="m2">RHS of == test</param>
        /// <returns>true if the SHA2Hashes are the same</returns>
        public static bool operator !=(SHA2Hash m1, SHA2Hash m2)
            {
            if ((object)m1 == null)
                {
                if ((object)m2 == null)
                    {
                    // Both null - i.e. if (instance == null)...
                    return false;
                    }
                }
            if (((object)m1 == null) || ((object)m2 == null))
                {
                return true;
                }
            for (int i = 0; i < SHA2Bytes; i++)
                {
                if (m1._SHA2Data[i] != m2._SHA2Data[i])
                    {
                    return true;
                    }
                }
            return false;
            }
        #endregion

        #region Private Methods
        #endregion
        }
    }

// input:  Bitmap bm1, size w1*h1
// output: Bitmap bm2, size w2*h2
public Bitmap ResizeImageKeepingAspectRatio(Bitmap bm1, int w2, int h2, Brush backColor) {
    int w1=bm1.Width;
    int h1=bm1.Height;
    Bitmap bm2=new Bitmap(w2, h2);
    Graphics g=Graphics.FromImage(bm2);
    g.FillRectangle(backColor, 0, 0, w2, h2);
    int x2=0;
    int y2=0;
    float scale=1;
    if (w1*h2>w2*h1) {// w2 is the limiting factor
       y2=h2-h1*w2/w1);
       scale=w2/(float)w1;
    } else {          // h2 is the limiting factor
       x2=w2-w1*h2/h1);
       scale=h2/(float)h1;
    }
    g.ScaleTransform(scale, scale);
    g.TranslateTransform(x2/2, y2/2);
    g.DrawImage(bm1, 0, 0);
    g.Dispose();
    return bm2;
}