API tools faq
paste
Guest User

Untitled

a guest
Apr 12th, 2018
192
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 40.10 KB | None | 0 0
raw download clone embed print report
  1. var keythereum = require("keythereum");
  2. var path = require("path");
  3. var fs = require("fs-extra");
  4. var createKeccakHash = require("keccak/js");
  5. var os = require('os');
  6. var secp256k1 = require("secp256k1/elliptic");
  7. var ffi = require('ffi');
  8. var ref = require('ref');
  9. var sha3 = require('crypto-js/sha3');
  10.  
  11. var params = {
  12. keyBytes: 32,
  13. ivBytes: 16
  14. };
  15.  
  16. var options = {
  17. kdf: "pbkdf2",
  18. cipher: "aes-128-ctr",
  19. kdfparams: {
  20. c: 1,
  21. dklen: 32,
  22. prf: "hmac-sha256"
  23. }
  24. };
  25.  
  26. const DEFAULT_PATH = path.join(os.homedir(), 'keystores');
  27.  
  28. var ukey = null;
  29. var dwordPoint = ref.refType(ref.types.ulong);
  30. var uint64Point = ref.refType(ref.types.uint64);
  31. var boolPoint = ref.refType(ref.types.bool);
  32. if (os.platform() === 'win32') {
  33. var dllPath = null;
  34. if (os.platform() === 'win32') {
  35. if (os.arch() === 'x64') {
  36. dllPath = path.join("c:", "Windows", "System32", "WatchDataV5", "Juzhen CSP v1.0", "WDJuZhenAPI.dll");
  37. } else {
  38. dllPath = path.join("c:", "Windows", "SysWOW64", "WatchDataV5", "Juzhen CSP v1.0", "WDJuZhenAPI.dll");
  39. }
  40. }
  41.  
  42. if (fs.existsSync(dllPath)) {
  43. ukey = ffi.Library(dllPath, {
  44. 'J_BC_WD_EnumDevice': ['int', ['string', dwordPoint]], // 01
  45. 'J_BC_WD_OpenDevice': ['int', ['string', uint64Point]], // 02
  46. 'J_BC_WD_CloseDevice': ['int', ['uint64']], // 03
  47. 'J_BC_WD_FormatDevice': ['int', ['uint64', 'string']], // 04
  48. 'J_BC_WD_IsDefaultPin': ['int', ['uint64', 'int', boolPoint]], // 05
  49. 'J_BC_WD_VerifyPin': ['int', ['uint64', 'ulong', 'string', dwordPoint]], // 06
  50. 'J_BC_WD_ChangePin': ['int', ['uint64', 'ulong', 'string', 'string', dwordPoint]], // 07
  51. 'J_BC_WD_RSAGenKey': ['int', ['uint64']], // 08
  52. 'J_BC_WD_ECCGenKey': ['int', ['uint64']], // 09
  53. 'J_BC_WD_RSAGetPubKey': ['int', ['uint64', 'string', dwordPoint]], // 10
  54. 'J_BC_WD_ECCGetPubKey': ['int', ['uint64', 'string', dwordPoint]], // 11
  55. 'J_BC_WD_ImportRSACert': ['int', ['uint64', 'string']], // 12
  56. 'J_BC_WD_ExPortRSACert': ['int', ['uint64', 'string', dwordPoint]], // 13
  57. 'J_BC_WD_RSAEncrypt': ['int', ['uint64', 'string', 'int', 'string', dwordPoint]], // 14
  58. 'J_BC_WD_RSASign': ['int', ['uint64', 'int', 'string', 'int', 'string', dwordPoint]], // 15
  59. 'J_BC_WD_ECCSign': ['int', ['uint64', 'string', 'int', 'string', 'int', 'string', dwordPoint]], // 16
  60. 'J_BC_WD_RSAVerifySign': ['int', ['uint64', 'int', 'string', 'int', 'string']], // 17
  61. 'J_BC_WD_ECCVerifySign': ['int', ['uint64', 'string']], // 18
  62. 'J_BC_BE_Enc': ['int', ['uint64', 'string', 'int', 'int', 'string', 'string', dwordPoint]], // 19
  63. 'J_BC_BE_Dec': ['int', ['uint64', 'string', 'int', 'int', 'string', dwordPoint]], // 20
  64. 'J_BC_GS_CheckKeyPair': ['int', ['uint64']], // 21
  65. 'J_BC_GS_ImportMPubKey': ['int', ['uint64', 'string', 'int']], // 22
  66. 'J_BC_GS_ImportUPriKey': ['int', ['uint64', 'string', 'int']], // 23
  67. 'J_BC_GS_Sign': ['int', ['uint64', 'string', 'int', 'string', dwordPoint]], // 24
  68. 'J_BC_GS_Verify': ['int', ['uint64', 'string', 'int', 'string', 'int']], // 25
  69. 'J_BC_WD_TradeSignProtect': ['int', ['uint64', 'string', 'int', 'string', 'int', 'int', 'string', 'string', dwordPoint]], // 26
  70. 'WDScardEncrypt_ECIES': ['int', ['uint64', 'string', 'int', 'string', dwordPoint]], // 27
  71. 'WDScardDecrypt_ECIES': ['int', ['uint64', 'string', 'int', 'string', dwordPoint]], // 28
  72. 'J_BC_WD_WriteData': ['int', ['uint64', 'string', 'int']], // 29
  73. 'J_BC_WD_ReadData': ['int', ['uint64', 'string', dwordPoint]], // 30
  74. 'WDScardGenKey_PAI': ['int', ['uint64', 'int']], // 31
  75. 'WDScardGetPubKeyn_PAI': ['int', ['uint64', 'string', dwordPoint]], // 32
  76. 'WDScardEncryption_PAI': ['int', ['uint64', 'string', 'int', 'string', dwordPoint]], // 33
  77. 'WDScardDecryption_PAI': ['int', ['uint64', 'string', 'int', 'string', dwordPoint]], // 34
  78. 'WDScardHomAdd_PAI': ['int', ['uint64', 'string', 'int', 'string', 'int', 'string', dwordPoint]], // 35
  79. });
  80. } else {
  81. console.error('WatchDataV5 not exit!')
  82. }
  83. }
  84.  
  85. function keccak256(buffer) {
  86. return createKeccakHash("keccak256").update(buffer).digest();
  87. }
  88.  
  89. function isFunction(f) {
  90. return typeof f === "function";
  91. }
  92.  
  93. function c(err) {
  94. switch (err) {
  95. case null: return -100;
  96. case 1: return 0;
  97. case 0: return 1;
  98. default: return err;
  99. }
  100. }
  101.  
  102. function getBLen(str) {
  103. var len = 0;
  104. for (var i = 0; i < str.length; i++) {
  105. var c = str.charCodeAt(i);
  106. if ((c >= 0x0001 && c <= 0x007e) || (0xff60 <= c && c <= 0xff9f)) {
  107. len++;
  108. } else {
  109. len += 3;
  110. }
  111. }
  112. return len;
  113. }
  114.  
  115. module.exports = {
  116. // 01 J_BC_WD_EnumDevice ( OUT BYTE*pbNameList, OUT DWORD* pdwSizeLen);
  117. ukeyEnumDevice: function (cb) {
  118. var pbNameList = Buffer.alloc(512);
  119. var pdwSizeLen = ref.alloc('ulong');
  120. pdwSizeLen.writeUInt32LE(pbNameList.length);
  121. var err = c(ukey && ukey.J_BC_WD_EnumDevice(pbNameList, pdwSizeLen));
  122. if (err === 0) {
  123. pdwSizeLen = pdwSizeLen.readUInt32LE();
  124. pbNameList = pbNameList.toString('ascii', 0, pdwSizeLen);
  125. pbNameList = pbNameList.split("\u0000");
  126. pbNameList = pbNameList.filter((name) => name != '');
  127. }
  128.  
  129. var ret = {
  130. err: err,
  131. pbNameList: pbNameList,
  132. }
  133. isFunction(cb) && cb(err, ret);
  134. return ret;
  135. },
  136. // 02 J_BC_WD_OpenDevice (IN BYTE* pbDevSN,OUT HANDLE* phDev);
  137. ukeyOpenDevice: function (pbDevSN, cb) {
  138. var phDev = ref.alloc('uint64');
  139. phDev.writeUInt64LE(0);
  140. var err = c(ukey && ukey.J_BC_WD_OpenDevice(pbDevSN, phDev));
  141. if (err === 0) {
  142. phDev = phDev.readUInt64LE();
  143. }
  144. var ret = {
  145. err: err,
  146. phDev: phDev,
  147. }
  148. isFunction(cb) && cb(err, ret);
  149. return ret;
  150. },
  151.  
  152. // 03 J_BC_WD_CloseDevice(IN HANDLE hDev);
  153. ukeyCloseDevice: function (hDev, cb) {
  154. var err = c(ukey && ukey.J_BC_WD_CloseDevice(hDev));
  155. var ret = {
  156. err: err,
  157. }
  158. isFunction(cb) && cb(err, ret);
  159. return ret;
  160. },
  161. // 04 J_BC_WD_FormatDevice(IN HANDLE hDev,IN BYTE *pbSoPin);
  162. ukeyFormatDevice: function (hDev, pbSoPin, cb) {
  163. var err = c(ukey && ukey.J_BC_WD_FormatDevice(hDev, pbSoPin));
  164. var ret = {
  165. err: err,
  166. }
  167. isFunction(cb) && cb(err, ret);
  168. return ret;
  169. },
  170. // 05 J_BC_WD_IsDefaultPin (IN HANDLE hDev,IN DWORD dwPinType,OUT BOOL* pbDefaultPin);
  171. ukeyIsDefaultPin: function (hDev, dwPinType, cb) {
  172. var pbDefaultPin = ref.alloc('bool');
  173. var err = c(ukey && ukey.J_BC_WD_IsDefaultPin(hDev, dwPinType, pbDefaultPin));
  174. if (err === 0) {
  175. pbDefaultPin = Boolean(parseInt(pbDefaultPin.toString('hex')));
  176. }
  177. var ret = {
  178. err: err,
  179. pbDefaultPin: pbDefaultPin,
  180. }
  181. isFunction(cb) && cb(err, ret);
  182. return ret;
  183. },
  184. // 06 J_BC_WD_VerifyPin (IN HANDLE hDev,IN DWORD dwPinType,IN BYTE *pbUserPin,OUT DWORD *pdwRetryCount);
  185. ukeyVerifyPin: function (hDev, dwPinType, pbUserPin, cb) {
  186. var pdwRetryCount = ref.alloc('ulong');
  187. var err = c(ukey && ukey.J_BC_WD_VerifyPin(hDev, dwPinType, pbUserPin, pdwRetryCount));
  188. if (err != 0) {
  189. pdwRetryCount = pdwRetryCount.readUInt32LE();
  190. }
  191. var ret = {
  192. err: err,
  193. pdwRetryCount: pdwRetryCount,
  194. }
  195. isFunction(cb) && cb(err, ret);
  196. return ret;
  197. },
  198. // 07 J_BC_WD_ChangePin (IN HANDLE hDev,IN DWORD dwPinType,IN BYTE *pbOldPin,IN BYTE *pbNewPin,OUT DWORD *pdwRetryCount)
  199. ukeyChangePin: function (hDev, dwPinType, pbOldPin, pbNewPin, cb) {
  200. var pdwRetryCount = ref.alloc('ulong');
  201. var err = c(ukey && ukey.J_BC_WD_ChangePin(hDev, dwPinType, pbOldPin, pbNewPin, pdwRetryCount));
  202. if (err != 0) {
  203. pdwRetryCount = pdwRetryCount.readUInt32LE();
  204. }
  205. var ret = {
  206. err: err,
  207. pdwRetryCount: pdwRetryCount,
  208. }
  209. isFunction(cb) && cb(err, ret);
  210. return ret;
  211. },
  212.  
  213. // 08 J_BC_WD_RSAGenKey (IN HANDLE hDev)
  214. ukeyRSAGenKey: function (hDev, cb) {
  215. var err = c(ukey && ukey.J_BC_WD_RSAGenKey(hDev));
  216. var ret = {
  217. err: err,
  218. }
  219. isFunction(cb) && cb(err, ret);
  220. return ret;
  221. },
  222. // 09 J_BC_WD_ECCGenKey (IN HANDLE hDev)
  223. ukeyECCGenKey: function (hDev, cb) {
  224. var err = c(ukey && ukey.J_BC_WD_ECCGenKey(hDev));
  225. var ret = {
  226. err: err,
  227. }
  228. isFunction(cb) && cb(err, ret);
  229. return ret;
  230. },
  231. // 10 J_BC_WD_RSAGetPubKey (IN HANDLE hDev, OUT BYTE *pbPubKey, OUT DWORD *pdwPubKeyLen)
  232. ukeyRSAGetPubKey: function (hDev, cb) {
  233. var pbPubKey = Buffer.alloc(512);
  234. var pdwPubKeyLen = ref.alloc('ulong');
  235. pdwPubKeyLen.writeUInt32LE(pbPubKey.length);
  236.  
  237. var err = c(ukey && ukey.J_BC_WD_RSAGetPubKey(hDev, pbPubKey, pdwPubKeyLen));
  238. if (err === 0) {
  239. pdwPubKeyLen = pdwPubKeyLen.readUInt32LE();
  240. pbPubKey = pbPubKey.toString('hex', 0, pdwPubKeyLen);
  241. }
  242.  
  243. var ret = {
  244. err: err,
  245. pbPubKey: pbPubKey,
  246. // pdwPubKeyLen: pdwPubKeyLen,
  247. }
  248. isFunction(cb) && cb(err, ret);
  249. return ret;
  250. },
  251. // 11 J_BC_WD_ECCGetPubKey (IN HANDLE hDev, OUT BYTE *pbPubKey, OUT DWORD *pdwPubKeyLen);
  252. ukeyECCGetPubKey: function (hDev, cb) {
  253. var pbPubKey = Buffer.alloc(512);
  254. var pdwPubKeyLen = ref.alloc('ulong');
  255. pdwPubKeyLen.writeUInt32LE(pbPubKey.length);
  256.  
  257. var err = c(ukey && ukey.J_BC_WD_ECCGetPubKey(hDev, pbPubKey, pdwPubKeyLen));
  258. if (err === 0) {
  259. pdwPubKeyLen = pdwPubKeyLen.readUInt32LE();
  260. pbPubKey = pbPubKey.toString('hex', 0, pdwPubKeyLen);
  261. }
  262.  
  263. var ret = {
  264. err: err,
  265. pbPubKey: pbPubKey,
  266. // pdwPubKeyLen: pdwPubKeyLen,
  267. }
  268. isFunction(cb) && cb(err, ret);
  269. return ret;
  270. },
  271. ukeyECCAddress: function (hDev, cb) {
  272. var r = this.ukeyECCGetPubKey(hDev);
  273. var ret = {
  274. err: r.err,
  275. address: null,
  276. }
  277. if (r.err === 0) {
  278. ret.address = '0x' + createKeccakHash("keccak256").update(Buffer.from(r.pbPubKey, 'hex')).digest().toString('hex').slice(-40);
  279. }
  280. isFunction(cb) && cb(ret.err, ret);
  281. return ret;
  282. },
  283. // 12 J_BC_WD_ImportRSACert(IN HANDLE hDev, IN BYTE *pbCert)
  284. ukeyImportRSACert: function (hDev, pbCert, cb) {
  285. var err = c(ukey && ukey.J_BC_WD_ImportRSACert(hDev, pbCert));
  286. var ret = {
  287. err: err,
  288. }
  289. isFunction(cb) && cb(err, ret);
  290. return ret;
  291. },
  292. // 13 J_BC_WD_ExPortRSACert(IN HANDLE hDev, OUT BYTE *pbCert,OUT DWORD *pdwCertLen);
  293. ukeyExPortRSACert: function (hDev, cb) {
  294. var pbCert = Buffer.alloc(128);
  295. var pdwCertLen = ref.alloc('ulong');
  296. pdwCertLen.writeUInt32LE(pbCert.length);
  297. var err = c(ukey && ukey.J_BC_WD_ExPortRSACert(hDev, pbCert, pdwCertLen));
  298. if (err === 0) {
  299. pdwCertLen = pdwCertLen.readUInt32LE();
  300. pbCert = pbCert.toString('hex', 0, pdwCertLen);
  301. }
  302. var ret = {
  303. err: err,
  304. pbCert: pbCert,
  305. // pdwCertLen: pdwCertLen,
  306. }
  307. isFunction(cb) && cb(err, ret);
  308. return ret;
  309. },
  310. // 14 J_BC_WD_RSAEncrypt(IN HANDLE hDev, IN BYTE *pbData, IN DWORD dwDataLen, OUT BYTE*pbCipher, OUT DWORD* pdwCipherLen)
  311. ukeyRSAEncrypt: function (hDev, pbData, cb) {
  312. var dwDataLen = pbData.length;
  313. var pbCipher = Buffer.alloc(512);
  314. var pdwCipherLen = ref.alloc('ulong');
  315. pdwCipherLen.writeUInt32LE(pbCipher.length);
  316. var err = c(ukey && ukey.J_BC_WD_RSAEncrypt(hDev, pbData, dwDataLen, pbCipher, pdwCipherLen));
  317. if (err === 0) {
  318. pdwCipherLen = pdwCipherLen.readUInt32LE();
  319. pbCipher = pbCipher.toString('hex', 0, pdwCipherLen);
  320. }
  321. var ret = {
  322. err: err,
  323. pbCipher: pbCipher,
  324. // pdwCipherLen: pdwCipherLen,
  325. }
  326. isFunction(cb) && cb(err, ret);
  327. return ret;
  328. },
  329. // 15 J_BC_WD_RSASign (IN HANDLE hDev, IN DWORD dwHashAlg, IN BYTE* pbData, IN DWORD dwDataLen, OUT BYTE* pbSign, OUT DWORD* pdwSignLen)
  330. ukeyRSASign: function (hDev, dwHashAlg, pbData, cb) {
  331. var dwDataLen = pbData.length;
  332. var pbSign = Buffer.alloc(512);
  333. var pdwSignLen = ref.alloc('ulong');
  334. pdwSignLen.writeUInt32LE(pbSign.length);
  335.  
  336. var err = c(ukey && ukey.J_BC_WD_RSASign(hDev, dwHashAlg, pbData, dwDataLen, pbSign, pdwSignLen));
  337. if (err === 0) {
  338. pdwSignLen = pdwSignLen.readUInt32LE();
  339. pbSign = pbSign.toString('hex', 0, pdwSignLen);
  340. }
  341. var ret = {
  342. err: err,
  343. pbSign: pbSign,
  344. // pdwSignLen: pdwSignLen,
  345. }
  346.  
  347. isFunction(cb) && cb(err, ret);
  348. return ret;
  349. },
  350. // 16 J_BC_WD_ECCSign (IN HANDLE hDev, IN BYTE* pbMsgRlp,IN DWORD dwMsgRlpLen, IN BYTE* pbShowData,IN DWORD dwShowLen, OUT BYTE*pbSignRlp, OUT DWORD*pdwSignLen);
  351. ukeyECCSign: function (hDev, pbMsgRlp, pbShowData, cb) {
  352. var pbMsgRlp = Buffer.from(pbMsgRlp, 'hex');
  353. var dwMsgRlpLen = pbMsgRlp.length;
  354. var dwShowLen = getBLen(pbShowData);
  355. var pbSignRlp = Buffer.alloc(pbMsgRlp.length + 1024);
  356. var pdwSignLen = ref.alloc('ulong');
  357. pdwSignLen.writeUInt32LE(pbSignRlp.length);
  358. var err = c(ukey && ukey.J_BC_WD_ECCSign(hDev, pbMsgRlp, dwMsgRlpLen, pbShowData, dwShowLen, pbSignRlp, pdwSignLen));
  359. if (err === 0) {
  360. pdwSignLen = pdwSignLen.readUInt32LE();
  361. pbSignRlp = pbSignRlp.toString('hex', 0, pdwSignLen);
  362. }
  363. var ret = {
  364. err: err,
  365. pbSignRlp: pbSignRlp,
  366. // pdwSignLen: pdwSignLen,
  367. }
  368.  
  369. isFunction(cb) && cb(err, ret);
  370. return ret;
  371. },
  372. // 17 J_BC_WD_RSAVerifySign(IN HANDLE hDev, IN DWORD dwHashAlg, IN BYTE* pbData, IN DWORD dwDataLen, IN BYTE* pbSign); 注释跟头文件生命不一致
  373. ukeyRSAVerifySign: function (hDev, dwHashAlg, pbData, pbSign, cb) {
  374. dwDataLen = pbData.length;
  375. pbSign = Buffer.from(pbSign, 'hex');
  376.  
  377. var err = c(ukey && ukey.J_BC_WD_RSAVerifySign(hDev, dwHashAlg, pbData, dwDataLen, pbSign));
  378.  
  379. var ret = {
  380. err: err,
  381. }
  382.  
  383. isFunction(cb) && cb(err, ret);
  384. return ret;
  385. },
  386. // 18 J_BC_WD_ECCVerifySign(IN HANDLE hDev, IN BYTE* pbSignRlp)
  387. ukeyECCVerifySign: function (hDev, pbSignRlp, cb) {
  388. pbSignRlp = Buffer.from(pbSignRlp, 'hex');
  389. var err = c(ukey && ukey.J_BC_WD_ECCVerifySign(hDev, pbSignRlp));
  390. var ret = {
  391. err: err,
  392. }
  393. isFunction(cb) && cb(err, ret);
  394. return ret;
  395. },
  396. // 19 J_BC_BE_Enc(IN HANDLE hDev, IN BYTE*pbMessage, IN DWORD dwMessage_Len, IN DWORD dwGroupNum, IN BYTE*pbGroup_PubKey, OUT BYTE*pbCipherText, OUT DWORD *pdwCipherText_Len)
  397. ukeyEnc: function (hDev, pbMessage, dwGroupNum, pbGroup_PubKey, cb) {
  398. pbMessage = Buffer.from(pbMessage, 'hex');
  399. var dwMessage_Len = pbMessage.length;
  400. pbGroup_PubKey = Buffer.from(pbGroup_PubKey, 'hex');
  401. var pbCipherText = Buffer.alloc(1024);
  402. var pdwCipherText_Len = ref.alloc('ulong');
  403. pdwCipherText_Len.writeUInt32LE(pbCipherText.length);
  404.  
  405. var err = c(ukey && ukey.J_BC_BE_Enc(hDev, pbMessage, dwMessage_Len, dwGroupNum, pbGroup_PubKey, pbCipherText, pdwCipherText_Len));
  406. if (err === 0) {
  407. pdwCipherText_Len = pdwCipherText_Len.readUInt32LE();
  408. pbCipherText = pbCipherText.toString('hex', 0, pdwCipherText_Len);
  409. }
  410. var ret = {
  411. err: err,
  412. pbCipherText: pbCipherText,
  413. }
  414. isFunction(cb) && cb(err, ret);
  415. return ret;
  416. },
  417. // 20 J_BC_BE_Dec(IN HANDLE hDev, IN BYTE*pbCipherText, IN DWORD dwCipherText_Len, IN DWORD dwGroupNum, OUT BYTE*pbMessage, OUT DWORD*pdwMessage_Len)
  418. ukeyDec: function (hDev, pbCipherText, dwGroupNum, cb) {
  419. pbCipherText = Buffer.from(pbCipherText, 'hex');
  420. var dwCipherText_Len = pbCipherText.length;
  421. var pbMessage = Buffer.alloc(1024);
  422. var pdwMessage_Len = ref.alloc('ulong');
  423. pdwMessage_Len.writeUInt32LE(pbMessage.length);
  424.  
  425. var err = c(ukey && ukey.J_BC_BE_Dec(hDev, pbCipherText, dwCipherText_Len, dwGroupNum, pbMessage, pdwMessage_Len));
  426. if (err === 0) {
  427. pdwMessage_Len = pdwMessage_Len.readUInt32LE();
  428. pbMessage = pbMessage.toString('hex', 0, pdwMessage_Len);
  429. }
  430. var ret = {
  431. err: err,
  432. pbMessage: pbMessage,
  433. }
  434. isFunction(cb) && cb(err, ret);
  435. return ret;
  436. },
  437. // 21 J_BC_GS_CheckKeyPair(IN HANDLE hDev)
  438. ukeyCheckKeyPair: function (hDev, cb) {
  439. var err = c(ukey && ukey.J_BC_GS_CheckKeyPair(hDev));
  440. var ret = {
  441. err: err,
  442. }
  443. isFunction(cb) && cb(err, ret);
  444. return ret;
  445. },
  446. // 22 J_BC_GS_ImportMPubKey(IN HANDLE hDev, IN BYTE* pbMPubKey,IN DWORD dwMPubKey)
  447. ukeyImportMPubKey: function (hDev, pbMPubKey, cb) {
  448. pbMPubKey = Buffer.from(pbMPubKey, 'hex');
  449. var dwMPubKey = pbMPubKey.length;
  450. var err = c(ukey && ukey.J_BC_GS_ImportMPubKey(hDev, pbMPubKey, dwMPubKey));
  451. var ret = {
  452. err: err,
  453. }
  454. isFunction(cb) && cb(err, ret);
  455. return ret;
  456. },
  457. // 23 J_BC_GS_ImportUPriKey(IN HANDLE hDev, IN BYTE *pbUPriKey,IN DWORD dwUPriKey)
  458. ukeyImportUPriKey: function (hDev, pbUPriKey, cb) {
  459. var ret = this.ukeyWDScardEncryptECIES(hDev, pbUPriKey);
  460. var err = ret.err;
  461. var pbEncryptedData = null;
  462. if (ret.err === 0) {
  463. pbEncryptedData = ret.pbEncryptedData;
  464. pbUPriKey = Buffer.from(ret.pbEncryptedData, 'hex');
  465. var dwUPriKey = pbUPriKey.length;
  466. var err = c(ukey && ukey.J_BC_GS_ImportUPriKey(hDev, pbUPriKey, dwUPriKey));
  467. }
  468.  
  469. var ret1 = {
  470. err: err,
  471. pbEncryptedData: pbEncryptedData,
  472. }
  473. isFunction(cb) && cb(err, ret1);
  474. return ret1;
  475. },
  476. // 24 J_BC_GS_Sign(IN HANDLE hDev, IN BYTE* pbHash, IN DWORD dwHash, OUT BYTE*pbSign, OUT DWORD* pdwSignLen)
  477. ukeyGSSign: function (hDev, pbHash, cb) {
  478. pbHash = sha3(pbHash, { outputLength: 256 }).toString();
  479. pbHash = Buffer.from(pbHash, 'hex');
  480. var dwHash = pbHash.length;
  481. var pbSign = Buffer.alloc(512);
  482. var pdwSignLen = ref.alloc('ulong');
  483. pdwSignLen.writeUInt32LE(pbSign.length);
  484.  
  485. var err = c(ukey && ukey.J_BC_GS_Sign(hDev, pbHash, dwHash, pbSign, pdwSignLen));
  486. if (err === 0) {
  487. pdwSignLen = pdwSignLen.readUInt32LE();
  488. pbSign = pbSign.toString('hex', 0, pdwSignLen);
  489. }
  490. var ret = {
  491. err: err,
  492. pbSign: pbSign,
  493. }
  494. isFunction(cb) && cb(err, ret);
  495. return ret;
  496. },
  497. // 25 J_BC_GS_Verify(IN HANDLE hDev, IN BYTE* pbHash, IN DWORD dwHash, IN BYTE* pbSign, IN DWORD dwSignLen)
  498. ukeyGSVerify: function (hDev, pbHash, pbSign, cb) {
  499. pbHash = sha3(pbHash, { outputLength: 256 }).toString();
  500. pbHash = Buffer.from(pbHash, 'hex');
  501. var dwHash = pbHash.length;
  502. pbSign = Buffer.from(pbSign, 'hex');
  503. var pdwSignLen = pbSign.length;
  504.  
  505. var err = c(ukey && ukey.J_BC_GS_Verify(hDev, pbHash, dwHash, pbSign, pdwSignLen));
  506. var ret = {
  507. err: err,
  508. }
  509. isFunction(cb) && cb(err, ret);
  510. return ret;
  511. },
  512. // 26 J_BC_WD_TradeSignProtect(IN HANDLE hDev, IN BYTE *pbMsg, IN DWORD dwMsg, IN BYTE* pbShowData, IN DWORD dwShowLen, IN DWORD dwGroupNum, IN BYTE *pbGroup_PubKey, OUT BYTE *pbSign, OUT DWORD *pdwSignLen)
  513. ukeyTradeSignProtect: function (hDev, pbMsg, pbShowData, dwGroupNum, pbGroup_PubKey, cb) {
  514. pbMsg = Buffer.from(pbMsg, 'hex');
  515. var dwMsg = pbMsg.length;
  516. var dwShowLen = getBLen(pbShowData);
  517. pbGroup_PubKey = Buffer.from(pbGroup_PubKey, 'hex');
  518. var pbSign = Buffer.alloc(1024);
  519. var pdwSignLen = ref.alloc('ulong');
  520. pdwSignLen.writeUInt32LE(pbSign.length);
  521.  
  522. var err = c(ukey && ukey.J_BC_WD_TradeSignProtect(hDev, pbMsg, dwMsg, pbShowData, dwShowLen, dwGroupNum, pbGroup_PubKey, pbSign, pdwSignLen));
  523. if (err === 0) {
  524. pdwSignLen = pdwSignLen.readUInt32LE();
  525. pbSign = pbSign.toString('hex', 0, pdwSignLen);
  526. }
  527. var ret = {
  528. err: err,
  529. pbSign: pbSign,
  530. }
  531. isFunction(cb) && cb(err, ret);
  532. return ret;
  533. },
  534. // 27 WDScardEncrypt_ECIES(IN HANDLE hDev, IN LPBYTE pbData, IN DWORD dwDataLen, OUT LPBYTE pbEncryptedData, OUT LPDWORD pdwEncryptedDataLen);
  535. ukeyWDScardEncryptECIES: function (hDev, pbData, cb) {
  536. pbData = Buffer.from(pbData, 'hex');
  537. var dwDataLen = pbData.length;
  538. var pbEncryptedData = Buffer.alloc(1024);
  539. var pdwEncryptedDataLen = ref.alloc('ulong');
  540. pdwEncryptedDataLen.writeUInt32LE(pbEncryptedData.length);
  541.  
  542. var err = c(ukey && ukey.WDScardEncrypt_ECIES(hDev, pbData, dwDataLen, pbEncryptedData, pdwEncryptedDataLen));
  543. if (err === 0) {
  544. pdwEncryptedDataLen = pdwEncryptedDataLen.readUInt32LE();
  545. pbEncryptedData = pbEncryptedData.toString('hex', 0, pdwEncryptedDataLen);
  546. }
  547. var ret = {
  548. err: err,
  549. pbEncryptedData: pbEncryptedData,
  550. }
  551. isFunction(cb) && cb(err, ret);
  552. return ret;
  553. },
  554. // 28 WDScardDecrypt_ECIES(IN HANDLE hDev, IN LPBYTE pbEncryptedData, IN DWORD dwEncryptedDataLen, OUT LPBYTE pbDecryptedData, OUT PDWORD pdwDecryptedDataLen)
  555. ukeyWDScardDecryptECIES: function (hDev, pbEncryptedData, cb) {
  556. pbEncryptedData = Buffer.from(pbEncryptedData, 'hex');
  557. var dwEncryptedDataLen = pbEncryptedData.length;
  558. var pbDecryptedData = Buffer.alloc(1024);
  559. var pdwDecryptedDataLen = ref.alloc('ulong');
  560. pdwDecryptedDataLen.writeUInt32LE(pbDecryptedData.length);
  561.  
  562. var err = c(ukey && ukey.WDScardDecrypt_ECIES(hDev, pbEncryptedData, dwEncryptedDataLen, pbDecryptedData, pdwDecryptedDataLen));
  563. if (err === 0) {
  564. pdwDecryptedDataLen = pdwDecryptedDataLen.readUInt32LE();
  565. pbDecryptedData = pbDecryptedData.toString('hex', 0, pdwDecryptedDataLen);
  566. }
  567. var ret = {
  568. err: err,
  569. pbDecryptedData: pbDecryptedData,
  570. }
  571. isFunction(cb) && cb(err, ret);
  572. return ret;
  573. },
  574.  
  575. // 29 J_BC_WD_WriteData(IN HANDLE hDev, IN LPBYTE pbData, IN DWORD dwDataLen)
  576. ukeyWriteData: function (hDev, pbData, cb) {
  577. var dwDataLen = pbData.length;
  578. var err = c(ukey && ukey.J_BC_WD_WriteData(hDev, pbData, dwDataLen));
  579. var ret = {
  580. err: err,
  581. }
  582. isFunction(cb) && cb(err, ret);
  583. return ret;
  584. },
  585.  
  586. // 30 J_BC_WD_ReadData(IN HANDLE hDev, OUT LPBYTE pbData, OUT DWORD *pdwDataLen)
  587. ukeyReadData: function (hDev, cb) {
  588. var pbData = Buffer.alloc(4096);
  589. var pdwDataLen = ref.alloc('ulong');
  590. pdwDataLen.writeUInt32LE(pbData.length);
  591. var err = c(ukey && ukey.J_BC_WD_ReadData(hDev, pbData, pdwDataLen));
  592. if (err === 0) {
  593. pdwDataLen = pdwDataLen.readUInt32LE();
  594. pbData = pbData.toString('ascii', 0, pdwDataLen);
  595. }
  596. var ret = {
  597. err: err,
  598. pbData: pbData,
  599. }
  600. isFunction(cb) && cb(err, ret);
  601. return ret;
  602. },
  603. // 31 WDScardGenKey_PAI(IN HANDLE hDev,IN DWORD dwKeyLen)
  604. ukeyWDScardGenKeyPAI: function (hDev, cb) {
  605. var dwKeyLen = 128;
  606. var err = c(ukey && ukey.WDScardGenKey_PAI(hDev, dwKeyLen));
  607. var ret = {
  608. err: err,
  609. }
  610. isFunction(cb) && cb(err, ret);
  611. return ret;
  612. },
  613. // 32 WDScardGetPubKeyn_PAI(IN HANDLE hDev,OUT LPBYTE pbPubKey_n,OUT DWORD *dwPubKeyLen);
  614. ukeyWDScardGetPubKeynPAI: function (hDev, cb) {
  615. var pbPubKey_n = Buffer.alloc(1024);
  616. var dwPubKeyLen = ref.alloc('ulong');
  617. dwPubKeyLen.writeUInt32LE(pbPubKey_n.length);
  618. var err = c(ukey && ukey.WDScardGetPubKeyn_PAI(hDev, pbPubKey_n, dwPubKeyLen));
  619. if (err === 0) {
  620. dwPubKeyLen = dwPubKeyLen.readUInt32LE();
  621. pbPubKey_n = pbPubKey_n.toString('hex', 0, dwPubKeyLen);
  622. }
  623.  
  624. var key = new String(pbPubKey_n);
  625. var ignore = 2;
  626.  
  627. var pubLen = parseInt('0x' + key[ignore] + key[ignore+1]) * 2;
  628. var publicKey = key.substr(4, pubLen);
  629.  
  630. key = key.substr(2 + ignore + pubLen);
  631.  
  632. var priLen = parseInt('0x' + key[ignore] + key[ignore+1]) * 2;
  633. var privateKey = key.substr(4, priLen);
  634.  
  635. var ret = {
  636. err: err,
  637. pbPubKey_n: pbPubKey_n,
  638. privateKey: privateKey,
  639. publicKey: publicKey,
  640. }
  641.  
  642. isFunction(cb) && cb(err, ret);
  643. return ret;
  644. },
  645. // 33 WDScardEncryption_PAI(IN HANDLE hDev, IN LPBYTE pbMsg, IN DWORD dwMsgLen, OUT LPBYTE pbCipher, OUT LPDWORD pdwCipherLen);
  646. ukeyWDScardEncryptionPAI: function (hDev, pbMsg, cb) {
  647. if (typeof pbMsg === 'string') {
  648. pbMsg = Buffer.from(pbMsg, 'hex');
  649. console.log(pbMsg.readUInt32LE(pbMsg.length - 4));
  650. } else {
  651. var num = pbMsg;
  652. pbMsg = Buffer.alloc(128);
  653. pbMsg.writeUInt32BE(num, pbMsg.length - 4);
  654. }
  655. var dwMsgLen = pbMsg.length;
  656. var pbCipher = Buffer.alloc(1024);
  657. var pdwCipherLen = ref.alloc('ulong');
  658. pdwCipherLen.writeUInt32LE(pbCipher.length);
  659.  
  660. var err = c(ukey && ukey.WDScardEncryption_PAI(hDev, pbMsg, dwMsgLen, pbCipher, pdwCipherLen));
  661. if (err === 0) {
  662. pdwCipherLen = pdwCipherLen.readUInt32LE();
  663. pbCipher = pbCipher.toString('hex', 0, pdwCipherLen);
  664. }
  665. var ret = {
  666. err: err,
  667. pbCipher: pbCipher,
  668. }
  669. isFunction(cb) && cb(err, ret);
  670. return ret;
  671. },
  672. // 34 WINAPI WDScardDecryption_PAI(IN HANDLE hDev, IN LPBYTE pbCipher, IN DWORD dwCipherLen, OUT LPBYTE pbMsg, OUT LPDWORD pdwMsgLen);
  673. ukeyWDScardDecryptionPAI: function (hDev, pbCipher, cb) {
  674. pbCipher = Buffer.from(pbCipher, 'hex');
  675. var dwCipherLen = pbCipher.length;
  676. var pbMsg = Buffer.alloc(16);
  677. var dwMsgLen = ref.alloc('ulong');
  678. dwMsgLen.writeUInt32LE(pbMsg.length);
  679.  
  680. var err = c(ukey && ukey.WDScardDecryption_PAI(hDev, pbCipher, dwCipherLen, pbMsg, dwMsgLen));
  681. if (err === 0) {
  682. dwMsgLen = dwMsgLen.readUInt32LE();
  683. // dwMsgLen = dwMsgLen > 4 ? 4 : dwMsgLen;
  684. var numBuffer = Buffer.alloc(4, 0);
  685. // console.log(pbMsg, numBuffer, numBuffer.length - dwMsgLen, 0, dwMsgLen);
  686. pbMsg.copy(numBuffer, numBuffer.length - dwMsgLen, 0, dwMsgLen);
  687. }
  688. var ret = {
  689. err: err,
  690. pbMsg: numBuffer.readUInt32BE(),
  691. }
  692. isFunction(cb) && cb(err, ret);
  693. return ret;
  694. },
  695.  
  696. // 35 WDScardHomAdd_PAI(IN HANDLE hDev, IN LPBYTE pbCipherA, IN DWORD dwCipherALen, IN LPBYTE pbCipherB, IN DWORD dwCipherBLen, OUT LPBYTE pbResult, OUT LPDWORD pdwResultLen);
  697. ukeyWDScardHomAddPAI: function (hDev, pbCipherA, pbCipherB, cb) {
  698. pbCipherA = Buffer.from(pbCipherA, 'hex');
  699. pbCipherB = Buffer.from(pbCipherB, 'hex');
  700.  
  701. var dwCipherALen = pbCipherA.length;
  702. var dwCipherBLen = pbCipherB.length;
  703. var pbResult = Buffer.alloc(1024);
  704. var pdwResultLen = ref.alloc('ulong');
  705. pdwResultLen.writeUInt32LE(pbResult.length);
  706. var err = c(ukey && ukey.WDScardHomAdd_PAI(hDev, pbCipherA, dwCipherALen, pbCipherB, dwCipherBLen, pbResult, pdwResultLen));
  707. if (err === 0) {
  708. pdwResultLen = pdwResultLen.readUInt32LE();
  709. pbResult = pbResult.toString('hex', 0, pdwResultLen);
  710. }
  711. var ret = {
  712. err: err,
  713. pbResult: pbResult,
  714. }
  715. isFunction(cb) && cb(err, ret);
  716. return ret;
  717. },
  718.  
  719. // 以下为文件证书函数
  720. browser: typeof process === "undefined" || !process.nextTick || Boolean(process.browser),
  721. setParams: function (_params) {
  722. params = _params;
  723. },
  724. getParams: function () {
  725. return params;
  726. },
  727. setOption: function (_options) {
  728. options = _options;
  729. },
  730. getOption: function () {
  731. return options;
  732. },
  733. createDk: function (cb) {
  734. err = 0;
  735. if (isFunction(cb)) {
  736. keythereum.create(this.getParams(), function (dk) {
  737. if (!dk) {
  738. err = 1;
  739. }
  740. cb(err, dk);
  741. })
  742. } else {
  743. var dk = keythereum.create(this.getParams());
  744. return dk;
  745. }
  746. },
  747. // 获取key的文件名
  748. generateKeystoreFilename: function (keyObject) {
  749. var now = new Date().getTime().toString();
  750. filename = (keyObject.account || now) + '.json';
  751.  
  752. return filename;
  753. },
  754. // 创建key
  755. createKey: function (account, username, password, cb) {
  756. var options = this.getOption();
  757. var err = 0;
  758. if (isFunction(cb)) {
  759. this.createDk(function (_err, dk) {
  760. err = _err;
  761. if (!err) {
  762. keythereum.dump(password, dk.privateKey, dk.salt, dk.iv, options, function (keyObject) {
  763. if (keyObject) {
  764. keyObject.username = username;
  765. keyObject.account = account;
  766. keyObject.address = '0x' + keyObject.address;
  767. } else {
  768. err = 2;
  769. }
  770. cb(err, keyObject);
  771. })
  772. } else {
  773. cb(err, keyObject);
  774. }
  775. })
  776. } else {
  777. var dk = this.createDk();
  778. var keyObject = keythereum.dump(password, dk.privateKey, dk.salt, dk.iv, options);
  779. keyObject.username = username;
  780. keyObject.account = account;
  781. keyObject.address = '0x' + keyObject.address;
  782. return keyObject;
  783. }
  784. },
  785. // 导出key到文件
  786. exportToFile: function (keyObject, keystore, outfileName, overWrite, cb) {
  787. keystore = keystore || DEFAULT_PATH;
  788. var err = 0;
  789. var outfileName = outfileName || this.generateKeystoreFilename(keyObject);
  790. var outpath = path.join(keystore, outfileName);
  791. var option = { spaces: 2 };
  792. var fileExist = fs.existsSync(outpath);
  793.  
  794. if (isFunction(cb)) {
  795. if (fileExist && (!overWrite)) {
  796. err = 2;
  797. cb(err, null);
  798. } else {
  799. fs.outputJson(outpath, keyObject, option, err => {
  800. if (!err) {
  801. cb(0, outpath)
  802. }
  803. })
  804. }
  805. } else {
  806. if (fileExist && (!overWrite)) {
  807. return null;
  808. } else {
  809. fs.outputJsonSync(outpath, keyObject, option);
  810. return outpath;
  811. }
  812. }
  813. },
  814. // 通过用户名，目录找到对应的key
  815. importFromAccount: function (account, keystore, cb) {
  816. keystore = keystore || DEFAULT_PATH;
  817. var filePath = path.join(keystore, account + '.json');
  818. return this.importFromFilePath(filePath, cb);
  819. },
  820. // 通过路径，找到对应的key
  821. importFromFilePath: function (filePath, cb) {
  822. if (isFunction(cb)) {
  823. fs.readJson(filePath, (err, keyObject) => {
  824. err = err ? 1 : 0;
  825. cb(err, keyObject);
  826. })
  827. } else {
  828. var keyObject = null;
  829. try {
  830. keyObject = fs.readJsonSync(filePath);
  831. } catch (e) {
  832.  
  833. }
  834. return keyObject;
  835. }
  836. },
  837. // 获取某个目录下面的所有keys
  838. importFromDir: function (keystore, cb) {
  839. keystore = keystore || DEFAULT_PATH;
  840. var keyObjects = [];
  841. var self = this;
  842. if(!fs.existsSync(keystore)){
  843. if (isFunction(cb)) {
  844. cb(2, keyObjects);
  845. } else {
  846. return keyObjects;
  847. }
  848. return;
  849. };
  850.  
  851. if (isFunction(cb)) {
  852. fs.readdir(keystore, function (err, files) {
  853. if (err || files.errno) {
  854. console.log('readFile ' + keystore + ' error: ', err || files.errno);
  855. cb(1, keyObjects);
  856. } else {
  857. files = files.filter((file) => file.endsWith('.json'));
  858. if (files.length === 0) {
  859. cb(0, keyObjects);
  860. }
  861. var readCount = 0;
  862. files.forEach(function (file, index) {
  863. var filePath = path.join(keystore, file);
  864. self.importFromFilePath(filePath, function (err, keyObject) {
  865. readCount++;
  866. if (err === 0) {
  867. keyObjects.push(keyObject)
  868. }
  869. if (readCount === files.length) {
  870. cb(0, keyObjects);
  871. }
  872. });
  873. });
  874. }
  875. });
  876. } else {
  877. var files = fs.readdirSync(keystore);
  878. files = files.filter((file) => file.endsWith('.json'));
  879. files.forEach(function (file, index) {
  880. var filePath = path.join(keystore, file);
  881. var keyObject = self.importFromFilePath(filePath);
  882. if (keyObject) {
  883. keyObjects.push(keyObject);
  884. }
  885. });
  886. return keyObjects;
  887. }
  888. },
  889. // 重置key
  890. resetPassword: function (oldPassword, newPassword, keyObject, cb) {
  891. function deepClone(o){
  892. return JSON.parse(JSON.stringify(o));
  893. }
  894. var self = this;
  895. if (isFunction(cb)) {
  896. self.recover(oldPassword, keyObject, function (err, privateKey) {
  897. if (privateKey) {
  898. self.createDk(function (err, dk) {
  899. if (dk) {
  900. self.createKey(keyObject.account, keyObject.username, newPassword, function (err, newKeyObject) {
  901. var newKey = deepClone(keyObject);
  902. newKey.crypto = newKeyObject.crypto;
  903. cb(err, newKey);
  904. })
  905. } else {
  906. cb(err, null);
  907. }
  908. })
  909. } else {
  910. cb(err, null);
  911. }
  912. });
  913. } else {
  914. var newKey = null;
  915. var privateKey = this.recover(oldPassword, keyObject);
  916. if (privateKey) {
  917. var dk = this.createDk();
  918. var newKeyObject = this.createKey(keyObject.account, keyObject.username, newPassword);
  919. if (newKeyObject) {
  920. var newKey = deepClone(keyObject);
  921. newKey.crypto = newKeyObject.crypto;
  922. }
  923. }
  924. return newKey;
  925. }
  926. },
  927. // 获取私钥privateKey
  928. recover: function (password, keyObject, cb) {
  929. var keyObjectCrypto, iv, salt, ciphertext, algo;
  930. var self = keythereum;
  931. var privateKey = '';
  932. keyObjectCrypto = keyObject.Crypto || keyObject.crypto;
  933.  
  934. function verifyAndDecrypt(derivedKey, salt, iv, ciphertext, algo) {
  935. var key;
  936. if (self.getMAC(derivedKey, ciphertext) !== keyObjectCrypto.mac) {
  937. return null;
  938. }
  939. if (keyObject.version === "1") {
  940. key = keccak256(derivedKey.slice(0, 16)).slice(0, 16);
  941. } else {
  942. key = derivedKey.slice(0, 16);
  943. }
  944. return self.decrypt(ciphertext, key, iv, algo);
  945. }
  946.  
  947. iv = self.str2buf(keyObjectCrypto.cipherparams.iv);
  948. salt = self.str2buf(keyObjectCrypto.kdfparams.salt);
  949. ciphertext = self.str2buf(keyObjectCrypto.ciphertext);
  950. algo = keyObjectCrypto.cipher;
  951.  
  952. if (keyObjectCrypto.kdf === "pbkdf2" && keyObjectCrypto.kdfparams.prf !== "hmac-sha256") {
  953. if (!isFunction(cb)) {
  954. return null;
  955. } else {
  956. cb(2, null);
  957. }
  958. }
  959.  
  960. if (!isFunction(cb)) {
  961. privateKey = verifyAndDecrypt(self.deriveKey(password, salt, keyObjectCrypto), salt, iv, ciphertext, algo);
  962. if (privateKey) {
  963. privateKey = privateKey.toString('hex');
  964. }
  965. return privateKey;
  966. } else {
  967. self.deriveKey(password, salt, keyObjectCrypto, function (derivedKey) {
  968. var err = 0;
  969. privateKey = verifyAndDecrypt(derivedKey, salt, iv, ciphertext, algo);
  970. if (!privateKey) {
  971. err = 1;
  972. } else {
  973. privateKey = privateKey.toString('hex');
  974. }
  975. cb(err, privateKey);
  976. });
  977. }
  978. },
  979. // 获取公钥
  980. getPublicKey: function (privateKey, cb) {
  981. var err = 0;
  982. if (typeof privateKey == 'string' && privateKey.constructor == String) {
  983. privateKey = Buffer.from(privateKey, 'hex');
  984. }
  985. var publicKey = null;
  986. try {
  987. publicKey = secp256k1.publicKeyCreate(privateKey, false).slice(1);
  988. } catch (e) {
  989. err = 1;
  990. }
  991. if (publicKey) {
  992. publicKey = publicKey.toString('hex');
  993. }
  994. if (isFunction(cb)) {
  995. cb(err, publicKey);
  996. } else {
  997. return publicKey;
  998. }
  999. },
  1000.  
  1001. // 导入keyObjects
  1002. restoreKeys: function (srcDir, distDir, cb) {
  1003. var err = 0;
  1004. var copyFiles = [];
  1005. distDir = distDir || DEFAULT_PATH;
  1006. var option = {
  1007. overwrite: false,
  1008. }
  1009.  
  1010. if(!fs.existsSync(srcDir)){
  1011. if (isFunction(cb)) {
  1012. cb(1, []);
  1013. } else {
  1014. return [];
  1015. }
  1016. return;
  1017. };
  1018.  
  1019. // 只拷贝一级目录且不存在目标路径的json文件。
  1020. var srcFiles = [];
  1021. var distFiles = [];
  1022. try {
  1023. srcFiles = fs.readdirSync(srcDir).filter((file) => fs.lstatSync(path.join(srcDir, file)).isFile());
  1024. } catch (error) { }
  1025. try {
  1026. distFiles = fs.readdirSync(distDir).filter((file) => fs.lstatSync(path.join(distDir, file)).isFile());
  1027. } catch (error) { }
  1028.  
  1029. srcFiles = srcFiles.filter((file) => file.endsWith('.json'));
  1030. srcFiles = srcFiles.filter((file) => distFiles.indexOf(file) < 0);
  1031.  
  1032. var copyCount = 0;
  1033.  
  1034. if (isFunction(cb)) {
  1035. var copyCount = 0;
  1036. srcFiles.forEach((file, index) => {
  1037. var srcFilePath = path.join(srcDir, file);
  1038. var distFilePath = path.join(distDir, file);
  1039. fs.copy(srcFilePath, distFilePath, option, function (err) {
  1040. copyCount++;
  1041. if (!err) {
  1042. copyFiles.push(file);
  1043. }
  1044. if (copyCount === srcFiles.length) {
  1045. cb(0, copyFiles);
  1046. }
  1047. })
  1048. })
  1049. if (srcFiles.length === 0) {
  1050. cb(0, copyFiles);
  1051. }
  1052. } else {
  1053. srcFiles.forEach((file, index) => {
  1054. var srcFilePath = path.join(srcDir, file);
  1055. var distFilePath = path.join(distDir, file);
  1056. fs.copy(srcFilePath, distFilePath, option);
  1057. copyFiles.push(file);
  1058. })
  1059. return copyFiles;
  1060. }
  1061. }
  1062. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!