1. using System;
  2. using System.Collections;
  3. using System.Runtime.InteropServices;
  4. using System.Security.Cryptography;
  6. namespace Framework.Cryptography
  7. {
  8. public class SRP6
  9. {
  10. static HashAlgorithm hashAlgorithm = new SHA1Managed();
  11. IntPtr BNA, BNa, BNb, BNB, BNg, BNk, BNn, BNS, BNU, BNv, BNx;
  12. public byte[] A, K, M2, N, S, salt, U;
  13. public byte[] a = new byte[0x14];
  14. public byte[] b = new byte[0x14];
  15. public byte[] B = new byte[0x20];
  16. public byte[] g = new byte[] { 0x07 };
  17. public byte[] k = new byte[] { 0x03 };
  18. public string Username, Password;
  20. public SRP6()
  21. {
  22. N = new byte[] { 0x89, 0x4B, 0x64, 0x5E, 0x89, 0xE1, 0x53, 0x5B, 0xBD, 0xAD, 0x5B, 0x8B, 0x29, 0x06, 0x50, 0x53,
  23. 0x08, 0x01, 0xB1, 0x8E, 0xBF, 0xBF, 0x5E, 0x8F, 0xAB, 0x3C, 0x82, 0x87, 0x2A, 0x3E, 0x9B, 0xB7 };
  25. salt = new byte[] { 0xAD, 0xD0, 0x3A, 0x31, 0xD2, 0x71, 0x14, 0x46, 0x75, 0xF2, 0x70, 0x7E, 0x50, 0x26, 0xB6, 0xD2,
  26. 0xF1, 0x86, 0x59, 0x99, 0x76, 0x02, 0x50, 0xAA, 0xB9, 0x45, 0xE0, 0x9E, 0xDD, 0x2A, 0xA3, 0x45 };
  27. }
  29. [DllImport("libeay32.dll")]
  30. private static extern int BN_add(IntPtr r, IntPtr a, IntPtr b);
  31. [DllImport("libeay32.dll", EntryPoint = "BN_bin2bn")]
  32. private static extern IntPtr BN_Bin2BN(byte[] ByteArrayIn, int length, IntPtr to);
  33. [DllImport("libeay32.dll")]
  34. private static extern int BN_bn2bin(IntPtr a, byte[] to);
  35. [DllImport("libeay32.dll", EntryPoint = "BN_CTX_free")]
  36. private static extern int BN_ctx_free(IntPtr a);
  37. [DllImport("libeay32.dll", EntryPoint = "BN_CTX_new")]
  38. private static extern IntPtr BN_ctx_new();
  39. [DllImport("libeay32.dll")]
  40. private static extern int BN_div(IntPtr dv, IntPtr r, IntPtr a, IntPtr b, IntPtr ctx);
  41. [DllImport("libeay32.dll", EntryPoint = "BN_free")]
  42. private static extern void BN_Free(IntPtr r);
  43. [DllImport("libeay32.dll")]
  44. private static extern IntPtr BN_mod_exp(IntPtr res, IntPtr a, IntPtr p, IntPtr m, IntPtr ctx);
  45. [DllImport("libeay32.dll")]
  46. private static extern int BN_mul(IntPtr r, IntPtr a, IntPtr b, IntPtr ctx);
  47. [DllImport("libeay32.dll", EntryPoint = "BN_new")]
  48. private static extern IntPtr BN_New();
  50. public byte[] CalculateA()
  51. {
  52. RAND_bytes(this.a, 20);
  53. IntPtr res = BN_New();
  54. IntPtr r = BN_New();
  55. IntPtr ptr3 = BN_New();
  56. this.BNA = BN_New();
  57. IntPtr ctx = BN_ctx_new();
  58. Array.Reverse(this.a);
  59. this.BNa = BN_Bin2BN(this.a, this.a.Length, IntPtr.Zero);
  60. Array.Reverse(this.a);
  61. BN_mod_exp(res, this.BNg, this.BNa, this.BNn, ctx);
  62. BN_mul(r, this.BNk, this.BNv, ctx);
  63. BN_add(ptr3, res, r);
  64. BN_div(IntPtr.Zero, this.BNA, ptr3, this.BNn, ctx);
  65. BN_bn2bin(this.BNA, this.A);
  66. Array.Reverse(this.A);
  67. BN_ctx_free(ctx);
  68. BN_Free(ptr3);
  69. BN_Free(r);
  70. BN_Free(res);
  71. return A;
  72. }
  74. public void CalculateM()
  75. {
  76. this.CalculateU();
  77. this.CalculateS();
  78. this.CalculateK();
  79. }
  81. public void CalculateK()
  82. {
  83. ArrayList list = Split(this.S);
  84. list[0] = hashAlgorithm.ComputeHash((byte[])list[0]);
  85. list[1] = hashAlgorithm.ComputeHash((byte[])list[1]);
  86. this.K = Combine((byte[])list[0], (byte[])list[1]);
  87. }
  89. public void CalculateM2()
  90. {
  91. byte[] dst = new byte[this.S.Length + this.A.Length + this.B.Length + this.K.Length];
  92. Buffer.BlockCopy(this.S, 0, dst, 0, this.S.Length);
  93. Buffer.BlockCopy(this.A, 0, dst, this.S.Length, this.A.Length);
  94. Buffer.BlockCopy(this.B, 0, dst, this.S.Length + this.A.Length, this.B.Length);
  95. Buffer.BlockCopy(this.K, 0, dst, this.S.Length + this.A.Length + this.B.Length, this.K.Length);
  96. this.M2 = hashAlgorithm.ComputeHash(dst);
  97. }
  99. public void CalculateS()
  100. {
  101. IntPtr res = BN_New();
  102. IntPtr r = BN_New();
  103. this.BNS = BN_New();
  104. IntPtr ctx = BN_ctx_new();
  105. this.S = new byte[0x20];
  106. BN_mod_exp(res, this.BNv, this.BNU, this.BNn, ctx);
  107. BN_mul(r, this.BNA, res, ctx);
  108. BN_mod_exp(this.BNS, r, this.BNb, this.BNn, ctx);
  109. BN_bn2bin(this.BNS, this.S);
  110. Array.Reverse(this.S);
  111. BN_ctx_free(ctx);
  112. BN_Free(r);
  113. BN_Free(res);
  114. }
  116. public void CalculateU()
  117. {
  118. byte[] dst = new byte[this.A.Length + this.B.Length];
  119. Buffer.BlockCopy(this.A, 0, dst, 0, this.A.Length);
  120. Buffer.BlockCopy(this.B, 0, dst, a.Length, this.B.Length);
  121. this.U = hashAlgorithm.ComputeHash(dst);
  122. Array.Reverse(this.U);
  123. this.BNU = BN_Bin2BN(this.U, this.U.Length, IntPtr.Zero);
  124. Array.Reverse(this.U);
  125. Array.Reverse(this.A);
  126. this.BNA = BN_Bin2BN(this.A, this.A.Length, IntPtr.Zero);
  127. Array.Reverse(this.A);
  128. }
  130. public void CalculateV()
  131. {
  132. this.BNv = BN_New();
  133. IntPtr ctx = BN_ctx_new();
  134. BN_mod_exp(this.BNv, this.BNg, this.BNx, this.BNn, ctx);
  135. BN_ctx_free(ctx);
  136. }
  138. public void CalculateX(byte[] username, byte[] password)
  139. {
  140. byte[] src = username;
  141. byte[] buffer2 = password;
  142. byte[] dst = new byte[(src.Length + buffer2.Length) + 1];
  143. byte[] buffer5 = new byte[this.salt.Length + 20];
  144. Buffer.BlockCopy(src, 0, dst, 0, src.Length);
  145. dst[src.Length] = 0x3a;
  146. Buffer.BlockCopy(buffer2, 0, dst, src.Length + 1, buffer2.Length);
  147. Buffer.BlockCopy(hashAlgorithm.ComputeHash(dst, 0, dst.Length), 0, buffer5, this.salt.Length, 20);
  148. Buffer.BlockCopy(this.salt, 0, buffer5, 0, this.salt.Length);
  149. byte[] array = hashAlgorithm.ComputeHash(buffer5);
  150. Array.Reverse(array);
  151. this.BNx = BN_Bin2BN(array, array.Length, IntPtr.Zero);
  152. Array.Reverse(this.g);
  153. this.BNg = BN_Bin2BN(this.g, this.g.Length, IntPtr.Zero);
  154. Array.Reverse(this.g);
  155. Array.Reverse(this.k);
  156. this.BNk = BN_Bin2BN(this.k, this.k.Length, IntPtr.Zero);
  157. Array.Reverse(this.k);
  158. Array.Reverse(this.N);
  159. this.BNn = BN_Bin2BN(this.N, this.N.Length, IntPtr.Zero);
  160. Array.Reverse(this.N);
  161. this.CalculateV();
  162. }
  164. private static byte[] Combine(byte[] b1, byte[] b2)
  165. {
  166. if (b1.Length != b2.Length)
  167. {
  168. return null;
  169. }
  170. byte[] buffer = new byte[b1.Length + b2.Length];
  171. int index = 0;
  172. int num2 = 1;
  173. for (int i = 0; i < b1.Length; i++)
  174. {
  175. buffer[index] = b1[i];
  176. index++;
  177. index++;
  178. }
  179. for (int j = 0; j < b2.Length; j++)
  180. {
  181. buffer[num2] = b2[j];
  182. num2++;
  183. num2++;
  184. }
  185. return buffer;
  186. }
  188. ~SRP6()
  189. {
  190. BN_Free(this.BNA);
  191. BN_Free(this.BNb);
  192. BN_Free(this.BNB);
  193. BN_Free(this.BNg);
  194. BN_Free(this.BNk);
  195. BN_Free(this.BNn);
  196. BN_Free(this.BNS);
  197. BN_Free(this.BNU);
  198. BN_Free(this.BNv);
  199. BN_Free(this.BNx);
  200. }
  202. [DllImport("libeay32.dll")]
  203. public static extern int RAND_bytes(byte[] buf, int num);
  204. private static ArrayList Split(byte[] bo)
  205. {
  206. byte[] dst = new byte[bo.Length - 1];
  207. if (((bo.Length % 2) != 0) && (bo.Length > 2))
  208. {
  209. Buffer.BlockCopy(bo, 1, dst, 0, bo.Length);
  210. }
  211. byte[] buffer2 = new byte[bo.Length / 2];
  212. byte[] buffer3 = new byte[bo.Length / 2];
  213. int index = 0;
  214. int num2 = 1;
  215. for (int i = 0; i < buffer2.Length; i++)
  216. {
  217. buffer2[i] = bo[index];
  218. index++;
  219. index++;
  220. }
  221. for (int j = 0; j < buffer3.Length; j++)
  222. {
  223. buffer3[j] = bo[num2];
  224. num2++;
  225. num2++;
  226. }
  227. ArrayList list = new ArrayList();
  228. list.Add(buffer2);
  229. list.Add(buffer3);
  230. return list;
  231. }
  232. }
  233. }