@tapni/auth 1.0.5 → 1.0.6-4.dev

package/src/services/UserService.js

@@ -1,49 +1,52 @@
 import api from './Api.js';
 
 export default {
-  getMe() {
-    return api().get(`/users/me`);
-  },
-  getByUsername(data) {
-    let referrer = document.referrer || "";
-    let params = data.utmParams || {};
-    if (data.dontTap) params.dontTap = true;
-    return api().get(`/users/${data.username}`, {
-      params,
-      headers: { "X-Referer": referrer },
-    });
-  },
-  getByNumber(data) {
-    let referrer = document.referrer || "";
-    let params = data.utmParams || {};
-    if (data.dontTap) params.dontTap = true;
-    return api().get(`/users/tag/${data.serial}`, {
-      params,
-      headers: { "X-Referer": referrer },
-    });
-  },
-  save(data) {
-    return api().put(`/users`, data);
-  },
-  newPassword(data) {
-    return api().put(`/users/new-password`, data);
-  },
-  connect(data) {
-    return api().post(`/users/connect`, data);
-  },
-  eventLog(data) {
-    return api().post(`/users/log`, data);
-  },
-  deleteAccount(data) {
-    return api().post(`/users/profile/delete`, data);
-  },
-  registerDevice(data) {
-    return api().post(`/users/device/register`, data);
-  },
-  addFcmToken(data) {
-    return api().post(`/users/device/fcm`, data);
-  },
-  loginUsingQR(data) {
-    return api().post("/users/qr/login", data);
-  }
+	getMe() {
+		return api().get(`/users/me`);
+	},
+	getByUsername(data) {
+		let referrer = document.referrer || '';
+		let params = data.utmParams || {};
+		if (data.dontTap) params.dontTap = true;
+		return api().get(`/users/${data.username}`, {
+			params,
+			headers: { 'X-Referer': referrer }
+		});
+	},
+	getByNumber(data) {
+		let referrer = document.referrer || '';
+		let params = data.utmParams || {};
+		if (data.dontTap) params.dontTap = true;
+		return api().get(`/users/tag/${data.serial}`, {
+			params,
+			headers: { 'X-Referer': referrer }
+		});
+	},
+	save(data) {
+		return api().put(`/users`, data);
+	},
+	newPassword(data) {
+		return api().put(`/users/new-password`, data);
+	},
+	connect(data) {
+		return api().post(`/users/connect`, data);
+	},
+	eventLog(data) {
+		return api().post(`/users/log`, data);
+	},
+	deleteAccount(data) {
+		return api().post(`/users/profile/delete`, data);
+	},
+	registerDevice(data) {
+		return api().post(`/users/device/register`, data);
+	},
+	addFcmToken(data) {
+		return api().post(`/users/device/fcm`, data);
+	},
+	loginUsingQR(data) {
+		return api().post('/users/qr/login', data);
+	},
+	updateAccount(data) {
+		return api().put('/accounts/me', data);
+	}
 };

package/src/services/UtilService.js

@@ -1,228 +1,320 @@
-import enLocale from '../store/locales/en';
-import deLocale from '../store/locales/de';
-import esLocale from '../store/locales/es';
-import krLocale from '../store/locales/kr';
-import itLocale from '../store/locales/it';
-import frLocale from '../store/locales/fr';
-import srLocale from '../store/locales/sr';
+import enLocale from '../store/locales/en.js';
+import deLocale from '../store/locales/de.js';
+import esLocale from '../store/locales/es.js';
+import krLocale from '../store/locales/kr.js';
+import itLocale from '../store/locales/it.js';
+import frLocale from '../store/locales/fr.js';
+import srLocale from '../store/locales/sr.js';
 import trLocale from '../store/locales/tr';
+import { sha256 } from 'js-sha256';
+
+// Helper function to safely get random values
+const getRandomValues = (array) => {
+	try {
+		return window.crypto.getRandomValues(array);
+	} catch (e) {
+		for (let i = 0; i < array.length; i++) {
+			array[i] = Math.floor(Math.random() * 256);
+		}
+		return array;
+	}
+};
+
+// Helper function to safely perform crypto digest
+const performDigest = async (data) => {
+	try {
+		return await window.crypto.subtle.digest('SHA-256', data);
+	} catch (e) {
+		const hash = sha256(data);
+		return new Uint8Array(hash.match(/.{1,2}/g).map(byte => parseInt(byte, 16))).buffer;
+	}
+};
+
+// Helper function to safely perform crypto encrypt
+const performEncrypt = async (algorithm, key, data) => {
+	try {
+		return await window.crypto.subtle.encrypt(algorithm, key, data);
+	} catch (e) {
+		throw new Error('Encryption not supported in this environment');
+	}
+};
+
+// Helper function to safely perform crypto decrypt
+const performDecrypt = async (algorithm, key, data) => {
+	try {
+		return await window.crypto.subtle.decrypt(algorithm, key, data);
+	} catch (e) {
+		throw new Error('Decryption not supported in this environment');
+	}
+};
 
 export default {
-    getFirstBrowserLanguage() {
-        let nav = window.navigator
-        let browserLanguagePropertyKeys = ['language', 'browserLanguage', 'systemLanguage', 'userLanguage']
-        let i
-        let language
-
-        // support for HTML 5.1 "navigator.languages"
-        if (Array.isArray(nav.languages)) {
-            for (i = 0; i < nav.languages.length; i++) {
-                language = nav.languages[i]
-                if (language && language.length) {
-                    return language.slice(0, 2)
-                }
-            }
-        }
-
-        // support for other well known properties in browsers
-        for (i = 0; i < browserLanguagePropertyKeys.length; i++) {
-            language = nav[browserLanguagePropertyKeys[i]]
-            if (language && language.length) {
-                return language.slice(0, 2)
-            }
-        }
-
-        return null
-    },
-    compareLangKeys() {
-        const en = Object.keys(enLocale.default.state);
-        const de = Object.keys(deLocale.default.state);
-        const es = Object.keys(esLocale.default.state);
-        const kr = Object.keys(krLocale.default.state);
-        const it = Object.keys(itLocale.default.state);
-        const fr = Object.keys(frLocale.default.state);
-        const sr = Object.keys(srLocale.default.state);
-        const tr = Object.keys(trLocale.default.state);
-
-
-        // Compare en and de
-        console.log('In en but not in de', en.filter(x => !de.includes(x)));
-        console.log('In de but not in en', de.filter(x => !en.includes(x)));
-        console.log();
-
-        // Compare en and es
-        console.log('In en but not in es', en.filter(x => !es.includes(x)));
-        console.log('In es but not in en', es.filter(x => !en.includes(x)));
-        console.log();
-
-        // Compare en and kr
-        console.log('In en but not in kr', en.filter(x => !kr.includes(x)));
-        console.log('In kr but not in en', kr.filter(x => !en.includes(x)));
-        console.log();
-
-        // Compare en and it
-        console.log('In en but not in it', en.filter(x => !it.includes(x)));
-        console.log('In it but not in en', it.filter(x => !en.includes(x)));
-        console.log();
-
-        // Compare en and fr
-        console.log('In en but not in fr', en.filter(x => !fr.includes(x)));
-        console.log('In fr but not in en', fr.filter(x => !en.includes(x)));
-        console.log();
-
-        // Compare en and sr
-        console.log('In en but not in sr', en.filter(x => !sr.includes(x)));
-        console.log('In sr but not in en', sr.filter(x => !en.includes(x)));
-        console.log();
-
-        // Compare en and tr
-        console.log('In en but not in tr', en.filter(x => !tr.includes(x)));
-        console.log('In tr but not in en', tr.filter(x => !en.includes(x)));
-        console.log();
-    },
-    base64ImageToBlob(base64Image) {
-        // Split into two parts
-        const parts = base64Image.split(';base64,');
-
-        // Hold the content type
-        const imageType = parts[0].split(':')[1];
-
-        // Decode Base64 string
-        const decodedData = window.atob(parts[1]);
-
-        // Create UNIT8ARRAY of size same as row data length
-        const uInt8Array = new Uint8Array(decodedData.length);
-
-        // Insert all character code into uInt8Array
-        for (let i = 0; i < decodedData.length; ++i) {
-            uInt8Array[i] = decodedData.charCodeAt(i);
-        }
-
-        // Return BLOB image after conversion
-        return new Blob([uInt8Array], {type: imageType});
-    },
-    blobToBase64(blob) {
-        const reader = new FileReader();
-        reader.readAsDataURL(blob);
-        return new Promise(resolve => {
-            reader.onloadend = () => {
-                resolve(reader.result);
-            };
-        });
-    },
-    base64toFile(base64, filename) {
-
-        var arr = base64.split(','),
-          mime = arr[0].match(/:(.*?);/)[1],
-          bstr = atob(arr[1]),
-          n = bstr.length,
-          u8arr = new Uint8Array(n);
-
-        while (n--) {
-            u8arr[n] = bstr.charCodeAt(n);
-        }
-
-        return new File([u8arr], filename, {type: mime});
-    },
-    fileToBase64(file) {
-        new Promise((resolve, reject) => {
-            const reader = new FileReader();
-            reader.readAsDataURL(file);
-            reader.onload = () => resolve(reader.result);
-            reader.onerror = error => reject(error);
-        });
-    },
-    getUTMParams(data) {
-        let utm = {}
-        if (data.utm_source) utm.utm_source = data.utm_source;
-        if (data.utm_medium) utm.utm_medium = data.utm_medium;
-        if (data.utm_campaign) utm.utm_campaign = data.utm_campaign;
-        if (data.utm_term) utm.utm_term = data.utm_term;
-        if (data.utm_content) utm.utm_content = data.utm_content;
-        return utm;
-    },
-
-    cropCardScan(base64PictureData, callback) {
-
-        // image will contain ORIGINAL image
-        const image = new window.Image();
-
-        // image will contain CROPPED image
-        const canvas = document.createElement('canvas');
-        const ctx = canvas.getContext('2d');
-
-        // Load original image into image element
-        image.src = 'data:image/jpeg;base64,' + base64PictureData;
-        image.onload = () => {
-            const sw = image.width;
-            const sh = image.width / 1.65;
-            const sx = 0;
-            const sy = (image.height / 2) - (sh / 2)
-            const dw = sw;
-            const dh = sh;
-            canvas.width = dw;
-            canvas.height = dh
-            // https://i.stack.imgur.com/USDAX.png
-            ctx.drawImage(image, sx, sy, sw, sh, 0, 0, dw, dh); // Crop interpolated rectangle
-            const croppedBase64Image = canvas.toDataURL();
-
-            callback(croppedBase64Image);
-
-            return croppedBase64Image;
-        };
-    },
-    generateRandomString(length) {
-        let array = new Uint32Array(length);
-        window.crypto.getRandomValues(array);
-        return Array.from(array, dec => ('0' + dec.toString(16)).substr(-2)).join('');
-    },
-    async pkceChallengeFromVerifier(v) {
-        const encoder = new TextEncoder();
-        const data = encoder.encode(v);
-        const hashed =  await window.crypto.subtle.digest('SHA-256', data);
-        // base64 url encode
-        return btoa(String.fromCharCode.apply(null, new Uint8Array(hashed))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-    },
-    encryptAES(key, iv, data) {
-        let encoder = new TextEncoder();
-        let encoded = encoder.encode(data, storage);
-        return window.crypto.subtle.encrypt(
-          {
-              name: "AES-CBC",
-              iv: iv,
-          },
-          key,
-          encoded,
-        );
-    },
-    async decryptAES(key, iv, data) {
-        try {
-            const fromBase64 = base64String => Uint8Array.from(atob(base64String), c => c.charCodeAt(0));
-
-            data = data.replace(/ /g, '+');
-
-            const encoder = new TextEncoder();
-            const decoder = new TextDecoder();
-
-            key = encoder.encode(key);
-            iv = encoder.encode(iv);
-            data = fromBase64(data, storage);
-
-
-            const secretKey = await window.crypto.subtle.importKey('raw', key, 'AES-CBC', true, ['encrypt', 'decrypt']);
-
-
-            let decoded = await window.crypto.subtle.decrypt({name: "AES-CBC", iv}, secretKey, data);
-
-            decoded = decoder.decode(decoded);
-            decoded = decoded.replace(/ /g, '+');
-            decoded = atob(decoded);
-
-            return decoded;
-
-
-        } catch (err) {
-            console.log(err)
-        }
-    }
-}
+	getFirstBrowserLanguage() {
+		let nav = window.navigator;
+		let browserLanguagePropertyKeys = ['language', 'browserLanguage', 'systemLanguage', 'userLanguage'];
+		let i;
+		let language;
+
+		// support for HTML 5.1 "navigator.languages"
+		if (Array.isArray(nav.languages)) {
+			for (i = 0; i < nav.languages.length; i++) {
+				language = nav.languages[i];
+				if (language && language.length) {
+					return language.slice(0, 2);
+				}
+			}
+		}
+
+		// support for other well known properties in browsers
+		for (i = 0; i < browserLanguagePropertyKeys.length; i++) {
+			language = nav[browserLanguagePropertyKeys[i]];
+			if (language && language.length) {
+				return language.slice(0, 2);
+			}
+		}
+
+		return null;
+	},
+	compareLangKeys() {
+		const en = Object.keys(enLocale.state);
+		const de = Object.keys(deLocale.state);
+		const es = Object.keys(esLocale.state);
+		const kr = Object.keys(krLocale.state);
+		const it = Object.keys(itLocale.state);
+		const fr = Object.keys(frLocale.state);
+		const sr = Object.keys(srLocale.state);
+		const tr = Object.keys(trLocale.state);
+
+		// Compare en and de
+		console.log(
+			'In en but not in de',
+			en.filter((x) => !de.includes(x))
+		);
+		console.log(
+			'In de but not in en',
+			de.filter((x) => !en.includes(x))
+		);
+		console.log();
+
+		// Compare en and es
+		console.log(
+			'In en but not in es',
+			en.filter((x) => !es.includes(x))
+		);
+		console.log(
+			'In es but not in en',
+			es.filter((x) => !en.includes(x))
+		);
+		console.log();
+
+		// Compare en and kr
+		console.log(
+			'In en but not in kr',
+			en.filter((x) => !kr.includes(x))
+		);
+		console.log(
+			'In kr but not in en',
+			kr.filter((x) => !en.includes(x))
+		);
+		console.log();
+
+		// Compare en and it
+		console.log(
+			'In en but not in it',
+			en.filter((x) => !it.includes(x))
+		);
+		console.log(
+			'In it but not in en',
+			it.filter((x) => !en.includes(x))
+		);
+		console.log();
+
+		// Compare en and fr
+		console.log(
+			'In en but not in fr',
+			en.filter((x) => !fr.includes(x))
+		);
+		console.log(
+			'In fr but not in en',
+			fr.filter((x) => !en.includes(x))
+		);
+		console.log();
+
+		// Compare en and sr
+		console.log(
+			'In en but not in sr',
+			en.filter((x) => !sr.includes(x))
+		);
+		console.log(
+			'In sr but not in en',
+			sr.filter((x) => !en.includes(x))
+		);
+		console.log();
+
+		// Compare en and tr
+		console.log(
+			'In en but not in tr',
+			en.filter((x) => !tr.includes(x))
+		);
+		console.log(
+			'In tr but not in en',
+			tr.filter((x) => !en.includes(x))
+		);
+		console.log();
+	},
+	base64ImageToBlob(base64Image) {
+		// Split into two parts
+		const parts = base64Image.split(';base64,');
+
+		// Hold the content type
+		const imageType = parts[0].split(':')[1];
+
+		// Decode Base64 string
+		const decodedData = window.atob(parts[1]);
+
+		// Create UNIT8ARRAY of size same as row data length
+		const uInt8Array = new Uint8Array(decodedData.length);
+
+		// Insert all character code into uInt8Array
+		for (let i = 0; i < decodedData.length; ++i) {
+			uInt8Array[i] = decodedData.charCodeAt(i);
+		}
+
+		// Return BLOB image after conversion
+		return new Blob([uInt8Array], { type: imageType });
+	},
+	blobToBase64(blob) {
+		const reader = new FileReader();
+		reader.readAsDataURL(blob);
+		return new Promise((resolve) => {
+			reader.onloadend = () => {
+				resolve(reader.result);
+			};
+		});
+	},
+	base64toFile(base64, filename) {
+		var arr = base64.split(','),
+			mime = arr[0].match(/:(.*?);/)[1],
+			bstr = atob(arr[1]),
+			n = bstr.length,
+			u8arr = new Uint8Array(n);
+
+		while (n--) {
+			u8arr[n] = bstr.charCodeAt(n);
+		}
+
+		return new File([u8arr], filename, { type: mime });
+	},
+	fileToBase64(file) {
+		new Promise((resolve, reject) => {
+			const reader = new FileReader();
+			reader.readAsDataURL(file);
+			reader.onload = () => resolve(reader.result);
+			reader.onerror = (error) => reject(error);
+		});
+	},
+	getUTMParams(data) {
+		let utm = {};
+		if (data.utm_source) utm.utm_source = data.utm_source;
+		if (data.utm_medium) utm.utm_medium = data.utm_medium;
+		if (data.utm_campaign) utm.utm_campaign = data.utm_campaign;
+		if (data.utm_term) utm.utm_term = data.utm_term;
+		if (data.utm_content) utm.utm_content = data.utm_content;
+		return utm;
+	},
+
+	cropCardScan(base64PictureData, callback) {
+		// image will contain ORIGINAL image
+		const image = new window.Image();
+
+		// image will contain CROPPED image
+		const canvas = document.createElement('canvas');
+		const ctx = canvas.getContext('2d');
+
+		// Load original image into image element
+		image.src = 'data:image/jpeg;base64,' + base64PictureData;
+		image.onload = () => {
+			const sw = image.width;
+			const sh = image.width / 1.65;
+			const sx = 0;
+			const sy = image.height / 2 - sh / 2;
+			const dw = sw;
+			const dh = sh;
+			canvas.width = dw;
+			canvas.height = dh;
+			// https://i.stack.imgur.com/USDAX.png
+			ctx.drawImage(image, sx, sy, sw, sh, 0, 0, dw, dh); // Crop interpolated rectangle
+			const croppedBase64Image = canvas.toDataURL();
+
+			callback(croppedBase64Image);
+
+			return croppedBase64Image;
+		};
+	},
+	generateRandomString(length) {
+		let array = new Uint32Array(length);
+		getRandomValues(array);
+		return Array.from(array, (dec) => ('0' + dec.toString(16)).substr(-2)).join('');
+	},
+	async pkceChallengeFromVerifier(v) {
+		try {
+			const encoder = new TextEncoder();
+			const data = encoder.encode(v);
+			const hashed = await performDigest(data);
+			const base64 = btoa(String.fromCharCode.apply(null, new Uint8Array(hashed)))
+				.replace(/\+/g, '-')
+				.replace(/\//g, '_')
+				.replace(/=+$/, '');
+			return base64;
+		} catch (error) {
+			const hash = sha256(v);
+			const base64 = btoa(String.fromCharCode.apply(null, new Uint8Array(hash.match(/.{1,2}/g).map(byte => parseInt(byte, 16)))))
+				.replace(/\+/g, '-')
+				.replace(/\//g, '_')
+				.replace(/=+$/, '');
+			return base64;
+		}
+	},
+	async encryptAES(key, iv, data) {
+		try {
+			let encoder = new TextEncoder();
+			let encoded = encoder.encode(data);
+			return await performEncrypt(
+				{
+					name: 'AES-CBC',
+					iv: iv
+				},
+				key,
+				encoded
+			);
+		} catch (error) {
+			throw error;
+		}
+	},
+	async decryptAES(key, iv, data) {
+		try {
+			const fromBase64 = (base64String) => Uint8Array.from(atob(base64String), (c) => c.charCodeAt(0));
+
+			data = data.replace(/ /g, '+');
+
+			const encoder = new TextEncoder();
+			const decoder = new TextDecoder();
+
+			key = encoder.encode(key);
+			iv = encoder.encode(iv);
+			data = fromBase64(data);
+
+			const secretKey = await window.crypto.subtle.importKey('raw', key, 'AES-CBC', true, ['encrypt', 'decrypt']);
+
+			let decoded = await performDecrypt({ name: 'AES-CBC', iv }, secretKey, data);
+
+			decoded = decoder.decode(decoded);
+			decoded = decoded.replace(/ /g, '+');
+			decoded = atob(decoded);
+
+			return decoded;
+		} catch (err) {
+			throw err;
+		}
+	}
+};