One of the things I appreciate the most in OOP is the concept of classes. I have found that the use of classes allows for code to be easily maintained and reused. I look at classes as neat little packaged objects that can be ‘moved around’ and ‘worked with’ as their own. Another big benefit of classes is the concept of inheritance and polymorphism. In three previous posts (1, 2, 3) I discussed using the System.Security.Cryptography Namespace to calculate the hash values of text (strings) and files. I actually did create a class (that I actively use) from that sample.

1using System;
2using System.Text;
3using System.Security.Cryptography;
4using System.IO;
5
6 public class CryptoHash
7 ...{
8 /**//// <summary>
9 /// public enum hashtypes { MD5, SHA1, SHA256, SHA384, SHA512 };
10 /// </summary>
11 public enum hashtypes ...{ MD5, SHA1, SHA256, SHA384, SHA512 };
12
13 Properties#region Properties
14
15 private Int64 _bytesread;
16 /**//// <summary>
17 /// Int64 Bytesread returns the number of bytes read when calculating the hash
18 /// value.
19 /// </summary>
20 public Int64 Bytesread
21 ...{
22 get
23 ...{
24 return _bytesread;
25 }
26 }
27
28 private hashtypes _hashtype;
29 /**//// <summary>
30 /// hashtypes Hashtype specifies the type of hash to calculate.
31 /// </summary>
32 public hashtypes Hashtype
33 ...{
34 get
35 ...{
36 return _hashtype;
37 }
38 set
39 ...{
40 _hashtype = value;
41 }
42 }
43 #endregion
44
45 Constructors#region Constructors
46 public CryptoHash()
47 ...{
48 }
49
50 public CryptoHash(hashtypes inhashtype)
51 ...{
52 _hashtype = inhashtype;
53 }
54 #endregion
55
56 Methods#region Methods
57
58 private string GetByteString(byte[] data)
59 ...{
60 StringBuilder sb = new StringBuilder();
61 for (int i = 0; i < data.Length; i++)
62 ...{
63 sb.Append(data[i].ToString("x2"));
64 }
65 string bytestring = sb.ToString();
66 return bytestring.ToUpper();
67 }
68
69 private string GetHash(byte[] data)
70 ...{
71 HashAlgorithm ha;
72 switch (_hashtype)
73 ...{
74 case hashtypes.MD5:
75 ha = MD5CryptoServiceProvider.Create();
76 break;
77 case hashtypes.SHA1:
78 ha = SHA1Managed.Create();
79 break;
80 case hashtypes.SHA256:
81 ha = SHA256Managed.Create();
82 break;
83 case hashtypes.SHA384:
84 ha = SHA384Managed.Create();
85 break;
86 case hashtypes.SHA512:
87 ha = SHA512Managed.Create();
88 break;
89 default:
90 ha = MD5CryptoServiceProvider.Create();
91 break;
92 }
93 _bytesread = data.Length;
94 byte[] res = ha.ComputeHash(data);
95 return GetByteString(res);
96 }
97
98 /**//// <summary>
99 /// GetStringHash calculates the hash value for a string.
100 /// </summary>
101 /// <param name="inputtext">String value.</param>
102 /// <returns>Returns the hash value of a file.</returns>
103 public string GetStringHash(string inputtext)
104 ...{
105 return GetHash(Encoding.Default.GetBytes(inputtext));
106
107 }
108
109 /**//// <summary>
110 /// GetFileHash calculates the hash value for a file.
111 /// </summary>
112 /// <param name="filename">Full file path for the file.</param>
113 /// <returns>Returns the hash value of a file.</returns>
114 public string GetFileHash(string filename)
115 ...{
116 _bytesread = 0;
117 byte[] filecontents;
118
119 FileInfo instance = new FileInfo(filename);
120 if (!instance.Exists)
121 ...{
122 throw new FileNotFoundException();
123 }
124 else
125 ...{
126 try
127 ...{
128 FileStream ofs = instance.OpenRead();
129 filecontents = new byte[ofs.Length];
130 int offset = 0;
131 int count = filecontents.Length;
132 while (count > 0)
133 ...{
134 int bytesread = ofs.Read(filecontents, offset, count);
135 count -= bytesread;
136 offset += bytesread;
137 }
138 // ofs.Read(filecontents, 0, filecontents.Length);
139 ofs.Close();
140 }
141 catch (Exception e)
142 ...{
143 throw e;
144 }
145 }
146 return GetHash(filecontents);
147 }
148
149 /**//// <summary>
150 /// CompareStrings compares the hash value of two strings to determine
151 /// if they are the same.
152 /// </summary>
153 /// <param name="string1">The first string to compare.</param>
154 /// <param name="string2">The second string to compare.</param>
155 /// <returns>Returns True if the strings are identical (same hash value).</returns>
156 public bool CompareStrings(string string1, string string2)
157 ...{
158 string1 = GetStringHash(string1);
159 string2 = GetStringHash(string2);
160 return ((string1.CompareTo(string2) == 0));
161 }
162
163 /**//// <summary>
164 /// CompareFiles compares the hash value of the contents of two files to determine
165 /// if they are the same.
166 /// </summary>
167 /// <param name="filename1">Full file path for the first file to compare.</param>
168 /// <param name="filename2">Full file path for the second file to compare.</param>
169 /// <returns>Returns True if the files are identical (same hash value).</returns>
170 public bool CompareFiles(string filename1, string filename2)
171 ...{
172 filename1 = GetFileHash(filename1);
173 filename2 = GetFileHash(filename2);
174 return ((filename1.CompareTo(filename2) == 0));
175 }
176
177 /**//// <summary>
178 /// CompareStringToHash compares a string's hash with a hash to determine if the hash values are the same.
179 /// </summary>
180 /// <param name="string1">The string to compare.</param>
181 /// <param name="hash">The hash to compare to.</param>
182 /// <returns>Returns True if the string1 hash and hash match.</returns>
183 public bool CompareStringtoHash(string string1, string hash)
184 ...{
185 return(hash.CompareTo(GetStringHash(string1)) == 0);
186 }
187
188 /**//// <summary>
189 /// CompareFileToHash compares a file's hash with a hash to determine if the hash values are the same.
190 /// </summary>
191 /// <param name="filename1">Full file path for the file to compare.</param>
192 /// <param name="hash">The hash to compare to.</param>
193 /// <returns>Returns True if the filename1 hash and hash match.</returns>
194 public bool CompareFiletoHash(string filename1, string hash)
195 ...{
196 return (hash.CompareTo(GetFileHash(filename1)) == 0);
197 }
198 #endregion
199 }
200
201

Labels: .NET, C#, Code