Qortal/Qortal-Hub
1
0
Fork 0
mirror of https://github.com/Qortal/Qortal-Hub.git synced 2025-06-12 11:11:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Format code

Browse Source
This commit is contained in:
Nicola Benaglia 2025-04-20 13:49:23 +02:00
parent de9285a280
commit e1bb064d1a
1 changed files with 326 additions and 285 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

611
src/backgroundFunctions/encryption.ts
View File

@ -1,327 +1,368 @@
import { getBaseApi } from "../background"; import { getBaseApi } from '../background';
import { createSymmetricKeyAndNonce, decryptGroupData, encryptDataGroup, objectToBase64 } from "../qdn/encryption/group-encryption"; import {
import { publishData } from "../qdn/publish/pubish"; createSymmetricKeyAndNonce,
import { getData } from "../utils/chromeStorage"; decryptGroupData,
import { RequestQueueWithPromise } from "../utils/queue/queue"; encryptDataGroup,
objectToBase64,
} from '../qdn/encryption/group-encryption';
import { publishData } from '../qdn/publish/pubish';
import { getData } from '../utils/chromeStorage';
import { RequestQueueWithPromise } from '../utils/queue/queue';
export const requestQueueGetPublicKeys = new RequestQueueWithPromise(10); export const requestQueueGetPublicKeys = new RequestQueueWithPromise(10);
const apiEndpoints = [ const apiEndpoints = [
"https://api.qortal.org", 'https://api.qortal.org',
"https://api2.qortal.org", 'https://api2.qortal.org',
"https://appnode.qortal.org", 'https://appnode.qortal.org',
"https://apinode.qortalnodes.live", 'https://apinode.qortalnodes.live',
"https://apinode1.qortalnodes.live", 'https://apinode1.qortalnodes.live',
"https://apinode2.qortalnodes.live", 'https://apinode2.qortalnodes.live',
"https://apinode3.qortalnodes.live", 'https://apinode3.qortalnodes.live',
"https://apinode4.qortalnodes.live", 'https://apinode4.qortalnodes.live',
]; ];
async function findUsableApi() { async function findUsableApi() {
for (const endpoint of apiEndpoints) { for (const endpoint of apiEndpoints) {
try { try {
const response = await fetch(`${endpoint}/admin/status`); const response = await fetch(`${endpoint}/admin/status`);
if (!response.ok) throw new Error("Failed to fetch"); if (!response.ok) throw new Error('Failed to fetch');
const data = await response.json(); const data = await response.json();
if (data.isSynchronizing === false && data.syncPercent === 100) { if (data.isSynchronizing === false && data.syncPercent === 100) {
console.log(`Usable API found: ${endpoint}`); console.log(`Usable API found: ${endpoint}`);
return endpoint; return endpoint;
} else { } else {
console.log(`API not ready: ${endpoint}`); console.log(`API not ready: ${endpoint}`);
}
} catch (error) {
console.error(`Error checking API ${endpoint}:`, error);
} }
} catch (error) {
console.error(`Error checking API ${endpoint}:`, error);
} }
throw new Error("No usable API found");
} }
throw new Error('No usable API found');
}
async function getSaveWallet() { async function getSaveWallet() {
const res = await getData<any>("walletInfo").catch(() => null); const res = await getData<any>('walletInfo').catch(() => null);
if (res) {
return res
} else {
throw new Error("No wallet saved");
}
}
export async function getNameInfo() {
const wallet = await getSaveWallet();
const address = wallet.address0;
const validApi = await getBaseApi()
const response = await fetch(validApi + "/names/address/" + address);
const nameData = await response.json();
if (nameData?.length > 0) {
return nameData[0].name;
} else {
return "";
}
}
async function getKeyPair() {
const res = await getData<any>("keyPair").catch(() => null);
if (res) { if (res) {
return res return res;
} else { } else {
throw new Error("Wallet not authenticated"); throw new Error('No wallet saved');
}
} }
const getPublicKeys = async (groupNumber: number) => { }
const validApi = await getBaseApi();
const response = await fetch(`${validApi}/groups/members/${groupNumber}?limit=0`);
const groupData = await response.json();
if (groupData && Array.isArray(groupData.members)) {
// Use the request queue for fetching public keys
const memberPromises = groupData.members
.filter((member) => member.member)
.map((member) =>
requestQueueGetPublicKeys.enqueue(async () => {
const resAddress = await fetch(`${validApi}/addresses/${member.member}`);
const resData = await resAddress.json();
return resData.publicKey;
})
);
const members = await Promise.all(memberPromises);
return members;
}
return [];
};
export const getPublicKeysByAddress = async (admins: string[]) => { export async function getNameInfo() {
const validApi = await getBaseApi(); const wallet = await getSaveWallet();
const address = wallet.address0;
if (Array.isArray(admins)) { const validApi = await getBaseApi();
// Use the request queue to limit concurrent fetches const response = await fetch(validApi + '/names/address/' + address);
const memberPromises = admins const nameData = await response.json();
.filter((address) => address) // Ensure the address is valid if (nameData?.length > 0) {
.map((address) => return nameData[0].name;
requestQueueGetPublicKeys.enqueue(async () => { } else {
const resAddress = await fetch(`${validApi}/addresses/${address}`); return '';
const resData = await resAddress.json(); }
return resData.publicKey; }
})
);
const members = await Promise.all(memberPromises);
return members;
}
return []; // Return empty array if admins is not an array
};
async function getKeyPair() {
const res = await getData<any>('keyPair').catch(() => null);
if (res) {
return res;
} else {
throw new Error('Wallet not authenticated');
}
}
const getPublicKeys = async (groupNumber: number) => {
const validApi = await getBaseApi();
const response = await fetch(
`${validApi}/groups/members/${groupNumber}?limit=0`
);
const groupData = await response.json();
if (groupData && Array.isArray(groupData.members)) {
export const encryptAndPublishSymmetricKeyGroupChat = async ({groupId, previousData}: { // Use the request queue for fetching public keys
groupId: number, const memberPromises = groupData.members
previousData: Object, .filter((member) => member.member)
}) => { .map((member) =>
try { requestQueueGetPublicKeys.enqueue(async () => {
const resAddress = await fetch(
let highestKey = 0 `${validApi}/addresses/${member.member}`
if(previousData){ );
highestKey = Math.max(...Object.keys((previousData || {})).filter(item=> !isNaN(+item)).map(Number)); const resData = await resAddress.json();
return resData.publicKey;
}
const resKeyPair = await getKeyPair()
const parsedData = resKeyPair
const privateKey = parsedData.privateKey
const userPublicKey = parsedData.publicKey
const groupmemberPublicKeys = await getPublicKeys(groupId)
const symmetricKey = createSymmetricKeyAndNonce()
const nextNumber = highestKey + 1
const objectToSave = {
...previousData,
[nextNumber]: symmetricKey
}
const symmetricKeyAndNonceBase64 = await objectToBase64(objectToSave)
const encryptedData = encryptDataGroup({
data64: symmetricKeyAndNonceBase64,
publicKeys: groupmemberPublicKeys,
privateKey,
userPublicKey
}) })
if(encryptedData){ );
const registeredName = await getNameInfo()
const data = await publishData({ const members = await Promise.all(memberPromises);
registeredName, file: encryptedData, service: 'DOCUMENT_PRIVATE', identifier: `symmetric-qchat-group-${groupId}`, uploadType: 'file', isBase64: true, withFee: true return members;
}) }
return {
data, return [];
numberOfMembers: groupmemberPublicKeys.length };
}
export const getPublicKeysByAddress = async (admins: string[]) => {
} else { const validApi = await getBaseApi();
throw new Error('Cannot encrypt content')
} if (Array.isArray(admins)) {
} catch (error: any) { // Use the request queue to limit concurrent fetches
throw new Error(error.message); const memberPromises = admins
.filter((address) => address) // Ensure the address is valid
.map((address) =>
requestQueueGetPublicKeys.enqueue(async () => {
const resAddress = await fetch(`${validApi}/addresses/${address}`);
const resData = await resAddress.json();
return resData.publicKey;
})
);
const members = await Promise.all(memberPromises);
return members;
}
return []; // Return empty array if admins is not an array
};
export const encryptAndPublishSymmetricKeyGroupChat = async ({
groupId,
previousData,
}: {
groupId: number;
previousData: Object;
}) => {
try {
let highestKey = 0;
if (previousData) {
highestKey = Math.max(
...Object.keys(previousData || {})
.filter((item) => !isNaN(+item))
.map(Number)
);
} }
}
export const encryptAndPublishSymmetricKeyGroupChatForAdmins = async ({groupId, previousData, admins}: { const resKeyPair = await getKeyPair();
groupId: number, const parsedData = resKeyPair;
previousData: Object, const privateKey = parsedData.privateKey;
const userPublicKey = parsedData.publicKey;
const groupmemberPublicKeys = await getPublicKeys(groupId);
const symmetricKey = createSymmetricKeyAndNonce();
const nextNumber = highestKey + 1;
const objectToSave = {
...previousData,
[nextNumber]: symmetricKey,
};
const symmetricKeyAndNonceBase64 = await objectToBase64(objectToSave);
const encryptedData = encryptDataGroup({
data64: symmetricKeyAndNonceBase64,
publicKeys: groupmemberPublicKeys,
privateKey,
userPublicKey,
});
if (encryptedData) {
const registeredName = await getNameInfo();
const data = await publishData({
registeredName,
file: encryptedData,
service: 'DOCUMENT_PRIVATE',
identifier: `symmetric-qchat-group-${groupId}`,
uploadType: 'file',
isBase64: true,
withFee: true,
});
return {
data,
numberOfMembers: groupmemberPublicKeys.length,
};
} else {
throw new Error('Cannot encrypt content');
}
} catch (error: any) {
throw new Error(error.message);
}
};
export const encryptAndPublishSymmetricKeyGroupChatForAdmins = async ({
groupId,
previousData,
admins,
}: {
groupId: number;
previousData: Object;
}) => { }) => {
try { try {
let highestKey = 0;
let highestKey = 0 if (previousData) {
if(previousData){ highestKey = Math.max(
highestKey = Math.max(...Object.keys((previousData || {})).filter(item=> !isNaN(+item)).map(Number)); ...Object.keys(previousData || {})
.filter((item) => !isNaN(+item))
} .map(Number)
);
const resKeyPair = await getKeyPair() }
const parsedData = resKeyPair
const privateKey = parsedData.privateKey
const userPublicKey = parsedData.publicKey
const groupmemberPublicKeys = await getPublicKeysByAddress(admins.map((admin)=> admin.address))
const resKeyPair = await getKeyPair();
const symmetricKey = createSymmetricKeyAndNonce() const parsedData = resKeyPair;
const nextNumber = highestKey + 1 const privateKey = parsedData.privateKey;
const objectToSave = { const userPublicKey = parsedData.publicKey;
...previousData, const groupmemberPublicKeys = await getPublicKeysByAddress(
[nextNumber]: symmetricKey admins.map((admin) => admin.address)
} );
const symmetricKeyAndNonceBase64 = await objectToBase64(objectToSave) const symmetricKey = createSymmetricKeyAndNonce();
const nextNumber = highestKey + 1;
const encryptedData = encryptDataGroup({ const objectToSave = {
data64: symmetricKeyAndNonceBase64, ...previousData,
publicKeys: groupmemberPublicKeys, [nextNumber]: symmetricKey,
privateKey, };
userPublicKey
}) const symmetricKeyAndNonceBase64 = await objectToBase64(objectToSave);
if(encryptedData){
const registeredName = await getNameInfo() const encryptedData = encryptDataGroup({
const data = await publishData({ data64: symmetricKeyAndNonceBase64,
registeredName, file: encryptedData, service: 'DOCUMENT_PRIVATE', identifier: `admins-symmetric-qchat-group-${groupId}`, uploadType: 'file', isBase64: true, withFee: true publicKeys: groupmemberPublicKeys,
}) privateKey,
return { userPublicKey,
data, });
numberOfMembers: groupmemberPublicKeys.length if (encryptedData) {
} const registeredName = await getNameInfo();
const data = await publishData({
} else { registeredName,
throw new Error('Cannot encrypt content') file: encryptedData,
} service: 'DOCUMENT_PRIVATE',
identifier: `admins-symmetric-qchat-group-${groupId}`,
uploadType: 'file',
isBase64: true,
withFee: true,
});
return {
data,
numberOfMembers: groupmemberPublicKeys.length,
};
} else {
throw new Error('Cannot encrypt content');
}
} catch (error: any) { } catch (error: any) {
throw new Error(error.message); throw new Error(error.message);
} }
} };
export const publishGroupEncryptedResource = async ({encryptedData, identifier}) => {
try { export const publishGroupEncryptedResource = async ({
encryptedData,
if(encryptedData && identifier){ identifier,
const registeredName = await getNameInfo()
if(!registeredName) throw new Error('You need a name to publish')
const data = await publishData({
registeredName, file: encryptedData, service: 'DOCUMENT', identifier, uploadType: 'file', isBase64: true, withFee: true
})
return data
} else {
throw new Error('Cannot encrypt content')
}
} catch (error: any) {
throw new Error(error.message);
}
}
export const publishOnQDN = async ({data, identifier, service, title,
description,
category,
tag1,
tag2,
tag3,
tag4,
tag5,
uploadType = 'file'
}) => { }) => {
try {
if (encryptedData && identifier) {
const registeredName = await getNameInfo();
if (!registeredName) throw new Error('You need a name to publish');
const data = await publishData({
registeredName,
file: encryptedData,
service: 'DOCUMENT',
identifier,
uploadType: 'file',
isBase64: true,
withFee: true,
});
return data;
} else {
throw new Error('Cannot encrypt content');
}
} catch (error: any) {
throw new Error(error.message);
}
};
if(data && service){ export const publishOnQDN = async ({
const registeredName = await getNameInfo() data,
if(!registeredName) throw new Error('You need a name to publish') identifier,
service,
const res = await publishData({ title,
registeredName, file: data, service, identifier, uploadType, isBase64: true, withFee: true, title, description,
description, category,
category, tag1,
tag1, tag2,
tag2, tag3,
tag3, tag4,
tag4, tag5,
tag5 uploadType = 'file',
}) => {
}) if (data && service) {
return res const registeredName = await getNameInfo();
if (!registeredName) throw new Error('You need a name to publish');
const res = await publishData({
registeredName,
} else { file: data,
throw new Error('Cannot publish content') service,
} identifier,
uploadType,
} isBase64: true,
withFee: true,
title,
description,
category,
tag1,
tag2,
tag3,
tag4,
tag5,
});
return res;
} else {
throw new Error('Cannot publish content');
}
};
export function uint8ArrayToBase64(uint8Array: any) { export function uint8ArrayToBase64(uint8Array: any) {
const length = uint8Array.length const length = uint8Array.length;
let binaryString = '' let binaryString = '';
const chunkSize = 1024 * 1024; // Process 1MB at a time const chunkSize = 1024 * 1024; // Process 1MB at a time
for (let i = 0; i < length; i += chunkSize) { for (let i = 0; i < length; i += chunkSize) {
const chunkEnd = Math.min(i + chunkSize, length) const chunkEnd = Math.min(i + chunkSize, length);
const chunk = uint8Array.subarray(i, chunkEnd) const chunk = uint8Array.subarray(i, chunkEnd);
// @ts-ignore // @ts-ignore
binaryString += Array.from(chunk, byte => String.fromCharCode(byte)).join('') binaryString += Array.from(chunk, (byte) => String.fromCharCode(byte)).join(
} ''
return btoa(binaryString) );
}
return btoa(binaryString);
} }
export function base64ToUint8Array(base64: string) { export function base64ToUint8Array(base64: string) {
const binaryString = atob(base64) const binaryString = atob(base64);
const len = binaryString.length const len = binaryString.length;
const bytes = new Uint8Array(len) const bytes = new Uint8Array(len);
for (let i = 0; i < len; i++) { for (let i = 0; i < len; i++) {
bytes[i] = binaryString.charCodeAt(i) bytes[i] = binaryString.charCodeAt(i);
}
return bytes
} }
export const decryptGroupEncryption = async ({data}: { return bytes;
data: string
}) => {
try {
const resKeyPair = await getKeyPair()
const parsedData = resKeyPair
const privateKey = parsedData.privateKey
const encryptedData = decryptGroupData(
data,
privateKey,
)
return {
data: uint8ArrayToBase64(encryptedData.decryptedData),
count: encryptedData.count
}
} catch (error: any) {
throw new Error(error.message);
}
} }
export const decryptGroupEncryption = async ({ data }: { data: string }) => {
try {
const resKeyPair = await getKeyPair();
const parsedData = resKeyPair;
const privateKey = parsedData.privateKey;
const encryptedData = decryptGroupData(data, privateKey);
return {
data: uint8ArrayToBase64(encryptedData.decryptedData),
count: encryptedData.count,
};
} catch (error: any) {
throw new Error(error.message);
}
};
export function uint8ArrayToObject(uint8Array: any) { export function uint8ArrayToObject(uint8Array: any) {
// Decode the byte array using TextDecoder // Decode the byte array using TextDecoder
const decoder = new TextDecoder() const decoder = new TextDecoder();
const jsonString = decoder.decode(uint8Array) const jsonString = decoder.decode(uint8Array);
// Convert the JSON string back into an object // Convert the JSON string back into an object
return JSON.parse(jsonString) return JSON.parse(jsonString);
} }