crypto/web-wallet-sample
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add scrypt hash for wasm in web

Browse Source
This commit is contained in:
CounterFire2023 2023-09-14 13:14:02 +08:00
parent 9d3238db2e
commit 20ceec121d
7 changed files with 270 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
assets/scripts/libs/google.client.js
View File

@ -4,7 +4,7 @@ const CLIENT_ID = '53206975661-ih3r0ubph3rqejdq97b029difbrk2bqj.apps.googleuserc
// Authorization scopes required by the API; multiple scopes can be
// included, separated by spaces.
const SCOPES = 'https://www.googleapis.com/auth/drive.appdata';
const SCOPES = 'openid email profile https://www.googleapis.com/auth/drive.appdata';
export class GoogleClient {
async initGApi() {
@ -34,6 +34,7 @@ export class GoogleClient {
throw resp;
}
console.log('token: ', gapi.client.getToken());
this.access_token = gapi.client.getToken().access_token;
let result = {
data: gapi.client.getToken().access_token,
errcode: 0,

24
assets/scripts/libs/native_bridge.js
View File

@ -4,8 +4,7 @@ import init, {
sign,
sign_for_tran,
generate_sec_key,
wgenerate_client_key,
keccak256_hash,
generate_scrypt_hash,
} from '../../wasm/rustwallet.js';
import { GoogleClient } from './google.client.js';
// call native method
@ -72,27 +71,28 @@ window.jsb = {
// method that returns immediately
// id, openid, mast-key, salt, pass
prepareWallet: function (...args) {
let localSKey = wgenerate_client_key(args[4], args[1], args[3]);
let seed = keccak256_hash(args[0] + args[1] + args[3]);
let address = wget_address(seed, args[2], localSKey);
walletCache = [args[2], localSKey, seed];
let address = wget_address.apply(this, args);
walletCache = args;
return address;
},
walletSecKey: function (...args) {
let localSKey = wgenerate_client_key(args[4], args[1], args[3]);
let seed = keccak256_hash(args[0] + args[1] + args[3]);
let address = wget_address(seed, args[2], localSKey);
let key = generate_sec_key(seed, args[2], localSKey);
let address = wget_address.apply(this, args);
let key = generate_sec_key.apply(this, args);
return JSON.stringify({ address, key });
},
hashSvrPass: function (msg) {
return hash_pass_svr(msg);
},
walletSign: function (msg) {
return sign(walletCache[2], walletCache[0], walletCache[1], msg);
let args = [...walletCache, msg];
return sign.apply(this, args);
},
walletSignTran: function (msg) {
return sign_for_tran(walletCache[2], walletCache[0], walletCache[1], msg);
let args = [...walletCache, msg];
return sign_for_tran.apply(this, args);
},
jcCryptoScrypt: function (...args) {
return generate_scrypt_hash.apply(this, args);
},
// END:: only for web
// BEGIN:: native method

117
assets/wasm/rustwallet.d.ts vendored
View File

@ -1,70 +1,87 @@
/* tslint:disable */
/* eslint-disable */
/**
* @param {string} msg_key
* @param {string} master_key
* @param {string} second_key
* @returns {string}
*/
export function get_public_key(msg_key: string, master_key: string, second_key: string): string;
/**
* @param {string} msg_key
* @param {string} master_key
* @param {string} second_key
* @returns {string}
*/
export function generate_sec_key(msg_key: string, master_key: string, second_key: string): string;
/**
* @param {string} msg_key
* @param {string} master_key
* @param {string} second_key
* @param {string} msg
* @returns {string}
*/
export function sign(msg_key: string, master_key: string, second_key: string, msg: string): string;
/**
* @param {string} msg_key
* @param {string} master_key
* @param {string} second_key
* @param {string} msg
* @returns {string}
*/
export function sign_for_tran(msg_key: string, master_key: string, second_key: string, msg: string): string;
/**
* @param {string} password
* @param {string} id
* @param {string} openid
* @param {string} master_key
* @param {string} salt
* @param {string} pass
* @returns {string}
*/
export function wgenerate_client_key(password: string, openid: string, salt: string): string;
export function get_public_key(id: string, openid: string, master_key: string, salt: string, pass: string): string;
/**
* @param {string} id
* @param {string} openid
* @param {string} master_key
* @param {string} salt
* @param {string} pass
* @returns {string}
*/
export function generate_sec_key(id: string, openid: string, master_key: string, salt: string, pass: string): string;
/**
* @param {string} id
* @param {string} openid
* @param {string} master_key
* @param {string} salt
* @param {string} pass
* @param {string} msg
* @returns {string}
*/
export function sign(id: string, openid: string, master_key: string, salt: string, pass: string, msg: string): string;
/**
* @param {string} id
* @param {string} openid
* @param {string} master_key
* @param {string} salt
* @param {string} pass
* @param {string} msg
* @returns {string}
*/
export function sign_for_tran(id: string, openid: string, master_key: string, salt: string, pass: string, msg: string): string;
/**
* @param {string} content
* @returns {string}
*/
export function keccak256_hash(content: string): string;
/**
* @param {string} msg_key
* @param {string} master_key
* @param {string} second_key
* @param {string} pass
* @param {string} salt
* @param {number} n
* @param {number} r
* @param {number} p
* @param {number} size
* @returns {string}
*/
export function wget_address(msg_key: string, master_key: string, second_key: string): string;
export function generate_scrypt_hash(pass: string, salt: string, n: number, r: number, p: number, size: number): string;
/**
* @param {string} msg_key
* @param {string} id
* @param {string} openid
* @param {string} master_key
* @param {string} second_key
* @param {string} salt
* @param {string} pass
* @returns {string}
*/
export function wget_address(id: string, openid: string, master_key: string, salt: string, pass: string): string;
/**
* @param {string} id
* @param {string} openid
* @param {string} master_key
* @param {string} salt
* @param {string} pass
* @param {string} msg
* @returns {string}
*/
export function wencrypt(msg_key: string, master_key: string, second_key: string, msg: string): string;
export function wencrypt(id: string, openid: string, master_key: string, salt: string, pass: string, msg: string): string;
/**
* @param {string} msg_key
* @param {string} id
* @param {string} openid
* @param {string} master_key
* @param {string} second_key
* @param {string} salt
* @param {string} pass
* @param {string} msg
* @returns {string}
*/
export function wdecrypt(msg_key: string, master_key: string, second_key: string, msg: string): string;
export function wdecrypt(id: string, openid: string, master_key: string, salt: string, pass: string, msg: string): string;
/**
* @param {string} content
* @param {string} key
@ -126,15 +143,15 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
export interface InitOutput {
readonly memory: WebAssembly.Memory;
readonly get_public_key: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
readonly generate_sec_key: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
readonly sign: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
readonly sign_for_tran: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
readonly wgenerate_client_key: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
readonly get_public_key: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
readonly generate_sec_key: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
readonly sign: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => void;
readonly sign_for_tran: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => void;
readonly keccak256_hash: (a: number, b: number, c: number) => void;
readonly wget_address: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
readonly wencrypt: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
readonly wdecrypt: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
readonly generate_scrypt_hash: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
readonly wget_address: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
readonly wencrypt: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => void;
readonly wdecrypt: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => void;
readonly aes_encrypt: (a: number, b: number, c: number, d: number, e: number) => void;
readonly aes_decrypt: (a: number, b: number, c: number, d: number, e: number) => void;
readonly rencrypt: (a: number, b: number, c: number, d: number, e: number) => void;

317
assets/wasm/rustwallet.js
View File

@ -111,127 +111,126 @@ function getInt32Memory0() {
return cachedInt32Memory0;
}
/**
* @param {string} msg_key
* @param {string} master_key
* @param {string} second_key
* @returns {string}
*/
export function get_public_key(msg_key, master_key, second_key) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(msg_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
const ptr2 = passStringToWasm0(second_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len2 = WASM_VECTOR_LEN;
wasm.get_public_key(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
var r0 = getInt32Memory0()[retptr / 4 + 0];
var r1 = getInt32Memory0()[retptr / 4 + 1];
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(r0, r1);
}
}
/**
* @param {string} msg_key
* @param {string} master_key
* @param {string} second_key
* @returns {string}
*/
export function generate_sec_key(msg_key, master_key, second_key) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(msg_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
const ptr2 = passStringToWasm0(second_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len2 = WASM_VECTOR_LEN;
wasm.generate_sec_key(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
var r0 = getInt32Memory0()[retptr / 4 + 0];
var r1 = getInt32Memory0()[retptr / 4 + 1];
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(r0, r1);
}
}
/**
* @param {string} msg_key
* @param {string} master_key
* @param {string} second_key
* @param {string} msg
* @returns {string}
*/
export function sign(msg_key, master_key, second_key, msg) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(msg_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
const ptr2 = passStringToWasm0(second_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len2 = WASM_VECTOR_LEN;
const ptr3 = passStringToWasm0(msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len3 = WASM_VECTOR_LEN;
wasm.sign(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
var r0 = getInt32Memory0()[retptr / 4 + 0];
var r1 = getInt32Memory0()[retptr / 4 + 1];
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(r0, r1);
}
}
/**
* @param {string} msg_key
* @param {string} master_key
* @param {string} second_key
* @param {string} msg
* @returns {string}
*/
export function sign_for_tran(msg_key, master_key, second_key, msg) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(msg_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
const ptr2 = passStringToWasm0(second_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len2 = WASM_VECTOR_LEN;
const ptr3 = passStringToWasm0(msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len3 = WASM_VECTOR_LEN;
wasm.sign_for_tran(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
var r0 = getInt32Memory0()[retptr / 4 + 0];
var r1 = getInt32Memory0()[retptr / 4 + 1];
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(r0, r1);
}
}
/**
* @param {string} password
* @param {string} id
* @param {string} openid
* @param {string} master_key
* @param {string} salt
* @param {string} pass
* @returns {string}
*/
export function wgenerate_client_key(password, openid, salt) {
export function get_public_key(id, openid, master_key, salt, pass) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(openid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
const ptr2 = passStringToWasm0(salt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const ptr2 = passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len2 = WASM_VECTOR_LEN;
wasm.wgenerate_client_key(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
const ptr3 = passStringToWasm0(salt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len3 = WASM_VECTOR_LEN;
const ptr4 = passStringToWasm0(pass, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len4 = WASM_VECTOR_LEN;
wasm.get_public_key(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
var r0 = getInt32Memory0()[retptr / 4 + 0];
var r1 = getInt32Memory0()[retptr / 4 + 1];
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(r0, r1);
}
}
/**
* @param {string} id
* @param {string} openid
* @param {string} master_key
* @param {string} salt
* @param {string} pass
* @returns {string}
*/
export function generate_sec_key(id, openid, master_key, salt, pass) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(openid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
const ptr2 = passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len2 = WASM_VECTOR_LEN;
const ptr3 = passStringToWasm0(salt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len3 = WASM_VECTOR_LEN;
const ptr4 = passStringToWasm0(pass, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len4 = WASM_VECTOR_LEN;
wasm.generate_sec_key(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
var r0 = getInt32Memory0()[retptr / 4 + 0];
var r1 = getInt32Memory0()[retptr / 4 + 1];
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(r0, r1);
}
}
/**
* @param {string} id
* @param {string} openid
* @param {string} master_key
* @param {string} salt
* @param {string} pass
* @param {string} msg
* @returns {string}
*/
export function sign(id, openid, master_key, salt, pass, msg) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(openid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
const ptr2 = passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len2 = WASM_VECTOR_LEN;
const ptr3 = passStringToWasm0(salt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len3 = WASM_VECTOR_LEN;
const ptr4 = passStringToWasm0(pass, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len4 = WASM_VECTOR_LEN;
const ptr5 = passStringToWasm0(msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len5 = WASM_VECTOR_LEN;
wasm.sign(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
var r0 = getInt32Memory0()[retptr / 4 + 0];
var r1 = getInt32Memory0()[retptr / 4 + 1];
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(r0, r1);
}
}
/**
* @param {string} id
* @param {string} openid
* @param {string} master_key
* @param {string} salt
* @param {string} pass
* @param {string} msg
* @returns {string}
*/
export function sign_for_tran(id, openid, master_key, salt, pass, msg) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(openid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
const ptr2 = passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len2 = WASM_VECTOR_LEN;
const ptr3 = passStringToWasm0(salt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len3 = WASM_VECTOR_LEN;
const ptr4 = passStringToWasm0(pass, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len4 = WASM_VECTOR_LEN;
const ptr5 = passStringToWasm0(msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len5 = WASM_VECTOR_LEN;
wasm.sign_for_tran(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
var r0 = getInt32Memory0()[retptr / 4 + 0];
var r1 = getInt32Memory0()[retptr / 4 + 1];
return getStringFromWasm0(r0, r1);
@ -261,21 +260,22 @@ export function keccak256_hash(content) {
}
/**
* @param {string} msg_key
* @param {string} master_key
* @param {string} second_key
* @param {string} pass
* @param {string} salt
* @param {number} n
* @param {number} r
* @param {number} p
* @param {number} size
* @returns {string}
*/
export function wget_address(msg_key, master_key, second_key) {
export function generate_scrypt_hash(pass, salt, n, r, p, size) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(msg_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const ptr0 = passStringToWasm0(pass, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const ptr1 = passStringToWasm0(salt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
const ptr2 = passStringToWasm0(second_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len2 = WASM_VECTOR_LEN;
wasm.wget_address(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
wasm.generate_scrypt_hash(retptr, ptr0, len0, ptr1, len1, n, r, p, size);
var r0 = getInt32Memory0()[retptr / 4 + 0];
var r1 = getInt32Memory0()[retptr / 4 + 1];
return getStringFromWasm0(r0, r1);
@ -286,24 +286,27 @@ export function wget_address(msg_key, master_key, second_key) {
}
/**
* @param {string} msg_key
* @param {string} id
* @param {string} openid
* @param {string} master_key
* @param {string} second_key
* @param {string} msg
* @param {string} salt
* @param {string} pass
* @returns {string}
*/
export function wencrypt(msg_key, master_key, second_key, msg) {
export function wget_address(id, openid, master_key, salt, pass) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(msg_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const ptr1 = passStringToWasm0(openid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
const ptr2 = passStringToWasm0(second_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const ptr2 = passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len2 = WASM_VECTOR_LEN;
const ptr3 = passStringToWasm0(msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const ptr3 = passStringToWasm0(salt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len3 = WASM_VECTOR_LEN;
wasm.wencrypt(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
const ptr4 = passStringToWasm0(pass, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len4 = WASM_VECTOR_LEN;
wasm.wget_address(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
var r0 = getInt32Memory0()[retptr / 4 + 0];
var r1 = getInt32Memory0()[retptr / 4 + 1];
return getStringFromWasm0(r0, r1);
@ -314,24 +317,64 @@ export function wencrypt(msg_key, master_key, second_key, msg) {
}
/**
* @param {string} msg_key
* @param {string} id
* @param {string} openid
* @param {string} master_key
* @param {string} second_key
* @param {string} salt
* @param {string} pass
* @param {string} msg
* @returns {string}
*/
export function wdecrypt(msg_key, master_key, second_key, msg) {
export function wencrypt(id, openid, master_key, salt, pass, msg) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(msg_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const ptr1 = passStringToWasm0(openid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
const ptr2 = passStringToWasm0(second_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const ptr2 = passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len2 = WASM_VECTOR_LEN;
const ptr3 = passStringToWasm0(msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const ptr3 = passStringToWasm0(salt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len3 = WASM_VECTOR_LEN;
wasm.wdecrypt(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
const ptr4 = passStringToWasm0(pass, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len4 = WASM_VECTOR_LEN;
const ptr5 = passStringToWasm0(msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len5 = WASM_VECTOR_LEN;
wasm.wencrypt(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
var r0 = getInt32Memory0()[retptr / 4 + 0];
var r1 = getInt32Memory0()[retptr / 4 + 1];
return getStringFromWasm0(r0, r1);
} finally {
wasm.__wbindgen_add_to_stack_pointer(16);
wasm.__wbindgen_free(r0, r1);
}
}
/**
* @param {string} id
* @param {string} openid
* @param {string} master_key
* @param {string} salt
* @param {string} pass
* @param {string} msg
* @returns {string}
*/
export function wdecrypt(id, openid, master_key, salt, pass, msg) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
const ptr1 = passStringToWasm0(openid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len1 = WASM_VECTOR_LEN;
const ptr2 = passStringToWasm0(master_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len2 = WASM_VECTOR_LEN;
const ptr3 = passStringToWasm0(salt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len3 = WASM_VECTOR_LEN;
const ptr4 = passStringToWasm0(pass, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len4 = WASM_VECTOR_LEN;
const ptr5 = passStringToWasm0(msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len5 = WASM_VECTOR_LEN;
wasm.wdecrypt(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
var r0 = getInt32Memory0()[retptr / 4 + 0];
var r1 = getInt32Memory0()[retptr / 4 + 1];
return getStringFromWasm0(r0, r1);

BIN
assets/wasm/rustwallet_bg.wasm
View File

Binary file not shown.

16
assets/wasm/rustwallet_bg.wasm.d.ts vendored
View File

@ -1,15 +1,15 @@
/* tslint:disable */
/* eslint-disable */
export const memory: WebAssembly.Memory;
export function get_public_key(a: number, b: number, c: number, d: number, e: number, f: number, g: number): void;
export function generate_sec_key(a: number, b: number, c: number, d: number, e: number, f: number, g: number): void;
export function sign(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number): void;
export function sign_for_tran(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number): void;
export function wgenerate_client_key(a: number, b: number, c: number, d: number, e: number, f: number, g: number): void;
export function get_public_key(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number): void;
export function generate_sec_key(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number): void;
export function sign(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number): void;
export function sign_for_tran(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number): void;
export function keccak256_hash(a: number, b: number, c: number): void;
export function wget_address(a: number, b: number, c: number, d: number, e: number, f: number, g: number): void;
export function wencrypt(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number): void;
export function wdecrypt(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number): void;
export function generate_scrypt_hash(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number): void;
export function wget_address(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number): void;
export function wencrypt(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number): void;
export function wdecrypt(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number): void;
export function aes_encrypt(a: number, b: number, c: number, d: number, e: number): void;
export function aes_decrypt(a: number, b: number, c: number, d: number, e: number): void;
export function rencrypt(a: number, b: number, c: number, d: number, e: number): void;

2
index.html
View File

@ -78,7 +78,7 @@
var loaded = 0;
var loadNext = function () {
return new Promise((resolve, reject) => {
list[loaded][0] = list[loaded][0] + (list[loaded][0].indexOf("?") == -1 ? "?" : "&") + "t=" + Date.now();
// list[loaded][0] = list[loaded][0] + (list[loaded][0].indexOf("?") == -1 ? "?" : "&") + "t=" + Date.now();
loadSingleScript(list[loaded]).then(() => {
loaded++;
if (loaded >= list.length) {