docs+ops: vault sync workflow; deploy-all with live progress and URL checks; prompt updates
This commit is contained in:
4NK Dev
parent
d48ccc8fbc
commit
e90c0fe2f2
BIN
__pycache__/api_server.cpython-313.pyc
Normal file
BIN
__pycache__/api_server.cpython-313.pyc
Normal file
Binary file not shown.
27
sdk-client/dist/examples/usage.d.ts
vendored
Normal file
27
sdk-client/dist/examples/usage.d.ts
vendored
Normal file
@ -0,0 +1,27 @@
|
||||
/**
|
||||
* Exemple d'utilisation du client Vault
|
||||
* Scénario complet : Initialisation → Routes → Parcours → Déchiffrement
|
||||
*/
|
||||
import { SecureVaultClient } from '../src/index';
|
||||
/**
|
||||
* ÉTAPE 1: Initialisation + Gestion des erreurs
|
||||
*/
|
||||
declare function step1_Initialization(): Promise<SecureVaultClient>;
|
||||
/**
|
||||
* ÉTAPE 2: Récupération de toutes les routes + Gestion des erreurs
|
||||
*/
|
||||
declare function step2_GetRoutes(client: SecureVaultClient): Promise<import("../src/index").VaultRoutes>;
|
||||
/**
|
||||
* ÉTAPE 3: Parcours de toutes les routes pour récupération du contenu + Gestion des erreurs
|
||||
*/
|
||||
declare function step3_ParseRoutes(routes: any, client: SecureVaultClient): Promise<any[]>;
|
||||
/**
|
||||
* ÉTAPE 4: Synchronisation locale des fichiers déchiffrés + Gestion des erreurs
|
||||
*/
|
||||
declare function step4_SyncLocalFiles(client: SecureVaultClient): Promise<void>;
|
||||
/**
|
||||
* ÉTAPE 5: Déchiffrement des contenus récupérés (non stocké) + Gestion des erreurs
|
||||
*/
|
||||
declare function step5_DecryptContents(results: any[]): Promise<void>;
|
||||
export { step1_Initialization, step2_GetRoutes, step3_ParseRoutes, step4_SyncLocalFiles, step5_DecryptContents };
|
||||
//# sourceMappingURL=usage.d.ts.map
|
||||
1
sdk-client/dist/examples/usage.d.ts.map
vendored
Normal file
1
sdk-client/dist/examples/usage.d.ts.map
vendored
Normal file
@ -0,0 +1 @@
|
||||
{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../../examples/usage.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,iBAAiB,EAAiE,MAAM,cAAc,CAAC;AAEhH;;GAEG;AACH,iBAAe,oBAAoB,+BA+DlC;AAED;;GAEG;AACH,iBAAe,eAAe,CAAC,MAAM,EAAE,iBAAiB,+CAuDvD;AAED;;GAEG;AACH,iBAAe,iBAAiB,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,iBAAiB,kBA0GtE;AAED;;GAEG;AACH,iBAAe,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,iBAiD5D;AAED;;GAEG;AACH,iBAAe,qBAAqB,CAAC,OAAO,EAAE,GAAG,EAAE,iBA+ElD;AAgDD,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACtB,CAAC"}
|
||||
388
sdk-client/dist/examples/usage.js
vendored
Normal file
388
sdk-client/dist/examples/usage.js
vendored
Normal file
@ -0,0 +1,388 @@
|
||||
"use strict";
|
||||
/**
|
||||
* Exemple d'utilisation du client Vault
|
||||
* Scénario complet : Initialisation → Routes → Parcours → Déchiffrement
|
||||
*/
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.step1_Initialization = step1_Initialization;
|
||||
exports.step2_GetRoutes = step2_GetRoutes;
|
||||
exports.step3_ParseRoutes = step3_ParseRoutes;
|
||||
exports.step4_SyncLocalFiles = step4_SyncLocalFiles;
|
||||
exports.step5_DecryptContents = step5_DecryptContents;
|
||||
const index_1 = require("../src/index");
|
||||
/**
|
||||
* ÉTAPE 1: Initialisation + Gestion des erreurs
|
||||
*/
|
||||
async function step1_Initialization() {
|
||||
console.log('🚀 ÉTAPE 1: Initialisation du client + Gestion des erreurs');
|
||||
console.log('='.repeat(70));
|
||||
try {
|
||||
// Test avec différents IDs utilisateur
|
||||
const testUserIds = [
|
||||
'demo_user_001', // ID existant
|
||||
'invalid@user', // ID invalide (caractères interdits)
|
||||
'ab', // ID trop court
|
||||
'a'.repeat(129), // ID trop long
|
||||
'3506ea43d9207038eea58caca84d51e4ccc01c496b6572bbf4dfda7fa03085b8' // Votre clé
|
||||
];
|
||||
let validClient = null;
|
||||
for (const userId of testUserIds) {
|
||||
try {
|
||||
console.log(`\n🔍 Test avec l'ID: ${userId.substring(0, 20)}${userId.length > 20 ? '...' : ''}`);
|
||||
// Utiliser le constructeur avec chargement automatique des clés .env
|
||||
// Pour le test avec les vraies clés, utiliser le constructeur sans paramètres
|
||||
const client = userId === 'demo_user_001' ? new index_1.SecureVaultClient() : new index_1.SecureVaultClient({
|
||||
baseUrl: 'https://vault.4nkweb.com:6666',
|
||||
userId: userId,
|
||||
timeout: 30000,
|
||||
verifySsl: false
|
||||
});
|
||||
// Test de connectivité
|
||||
const isConnected = await client.ping();
|
||||
if (isConnected) {
|
||||
console.log(` ✅ ID valide et connecté: ${userId}`);
|
||||
if (!validClient) {
|
||||
validClient = client;
|
||||
}
|
||||
}
|
||||
else {
|
||||
console.log(` ❌ ID valide mais non connecté: ${userId}`);
|
||||
}
|
||||
}
|
||||
catch (error) {
|
||||
if (error instanceof index_1.VaultAuthenticationError) {
|
||||
console.log(` 🔑 Erreur d'authentification: ${error.message}`);
|
||||
}
|
||||
else if (error.message.includes('ID utilisateur requis') || error.message.includes('invalide')) {
|
||||
console.log(` ⚠️ ID invalide: ${error.message}`);
|
||||
}
|
||||
else {
|
||||
console.log(` ❌ Erreur inattendue: ${error.message}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!validClient) {
|
||||
throw new Error('Aucun client valide trouvé - impossible de continuer');
|
||||
}
|
||||
console.log('\n✅ ÉTAPE 1 TERMINÉE: Client initialisé avec succès');
|
||||
return validClient;
|
||||
}
|
||||
catch (error) {
|
||||
console.error('\n❌ ÉTAPE 1 ÉCHOUÉE:', error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* ÉTAPE 2: Récupération de toutes les routes + Gestion des erreurs
|
||||
*/
|
||||
async function step2_GetRoutes(client) {
|
||||
console.log('\n🛣️ ÉTAPE 2: Récupération de toutes les routes + Gestion des erreurs');
|
||||
console.log('='.repeat(70));
|
||||
try {
|
||||
// Test de récupération des routes
|
||||
console.log('\n📋 Récupération des routes disponibles...');
|
||||
const routes = await client.getRoutes();
|
||||
console.log(` ✅ Total des routes: ${routes.total_routes}`);
|
||||
console.log(` ✅ Utilisateur: ${routes.user_id}`);
|
||||
console.log(` ✅ Type d'authentification: ${routes.authentication.type}`);
|
||||
console.log('\n📝 Routes disponibles:');
|
||||
routes.routes.forEach((route, index) => {
|
||||
console.log(` ${index + 1}. ${route.method} ${route.path}`);
|
||||
console.log(` → ${route.description}`);
|
||||
console.log(` → Authentification: ${route.authentication}`);
|
||||
console.log(` → Type de réponse: ${route.response_type}`);
|
||||
if (route.parameters) {
|
||||
console.log(` → Paramètres:`);
|
||||
Object.entries(route.parameters).forEach(([key, value]) => {
|
||||
console.log(` • ${key}: ${value}`);
|
||||
});
|
||||
}
|
||||
if (route.examples && route.examples.length > 0) {
|
||||
console.log(` → Exemples:`);
|
||||
route.examples.forEach(example => {
|
||||
console.log(` • ${example}`);
|
||||
});
|
||||
}
|
||||
console.log('');
|
||||
});
|
||||
console.log('✅ ÉTAPE 2 TERMINÉE: Routes récupérées avec succès');
|
||||
return routes;
|
||||
}
|
||||
catch (error) {
|
||||
console.error('\n❌ ÉTAPE 2 ÉCHOUÉE:');
|
||||
if (error instanceof index_1.VaultApiError) {
|
||||
console.error(` Erreur API: ${error.message}`);
|
||||
console.error(` Code HTTP: ${error.statusCode}`);
|
||||
console.error(` Code d'erreur: ${error.code}`);
|
||||
}
|
||||
else if (error instanceof index_1.VaultAuthenticationError) {
|
||||
console.error(` Erreur d'authentification: ${error.message}`);
|
||||
console.error(` Code HTTP: ${error.statusCode}`);
|
||||
}
|
||||
else {
|
||||
console.error(` Erreur inattendue: ${error.message}`);
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* ÉTAPE 3: Parcours de toutes les routes pour récupération du contenu + Gestion des erreurs
|
||||
*/
|
||||
async function step3_ParseRoutes(routes, client) {
|
||||
console.log('\n📁 ÉTAPE 3: Parcours des routes pour récupération du contenu + Gestion des erreurs');
|
||||
console.log('='.repeat(70));
|
||||
const results = [];
|
||||
try {
|
||||
for (const route of routes.routes) {
|
||||
console.log(`\n🔍 Test de la route: ${route.method} ${route.path}`);
|
||||
try {
|
||||
let result = null;
|
||||
switch (route.path) {
|
||||
case '/health':
|
||||
result = await client.health();
|
||||
console.log(` ✅ Health: ${result.status} - ${result.service}`);
|
||||
break;
|
||||
case '/info':
|
||||
result = await client.info();
|
||||
console.log(` ✅ Info: ${result.name} v${result.version}`);
|
||||
break;
|
||||
case '/routes':
|
||||
result = await client.getRoutes();
|
||||
console.log(` ✅ Routes: ${result.total_routes} routes disponibles`);
|
||||
break;
|
||||
default:
|
||||
// Route dynamique /<env>/<file_path>
|
||||
if (route.path.includes('<env>') && route.path.includes('<file_path>')) {
|
||||
console.log(` 📂 Test des fichiers de configuration...`);
|
||||
// Tester quelques fichiers de configuration connus
|
||||
const testFiles = [
|
||||
'bitcoin/bitcoin.conf',
|
||||
'nginx/nginx.conf',
|
||||
'grafana/grafana.ini'
|
||||
];
|
||||
for (const filePath of testFiles) {
|
||||
try {
|
||||
const fileResult = await client.getFile('dev', filePath);
|
||||
console.log(` ✅ ${filePath}: ${fileResult.size} caractères`);
|
||||
results.push({
|
||||
route: `${route.method} /dev/${filePath}`,
|
||||
success: true,
|
||||
data: fileResult
|
||||
});
|
||||
}
|
||||
catch (fileError) {
|
||||
console.log(` ❌ ${filePath}: ${fileError.message}`);
|
||||
results.push({
|
||||
route: `${route.method} /dev/${filePath}`,
|
||||
success: false,
|
||||
error: fileError.message
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (result) {
|
||||
results.push({
|
||||
route: `${route.method} ${route.path}`,
|
||||
success: true,
|
||||
data: result
|
||||
});
|
||||
}
|
||||
}
|
||||
catch (error) {
|
||||
console.log(` ❌ Erreur: ${error.message}`);
|
||||
if (error instanceof index_1.VaultApiError) {
|
||||
console.log(` → Code HTTP: ${error.statusCode}`);
|
||||
console.log(` → Code d'erreur: ${error.code}`);
|
||||
}
|
||||
else if (error instanceof index_1.VaultAuthenticationError) {
|
||||
console.log(` → Erreur d'authentification`);
|
||||
}
|
||||
else if (error instanceof index_1.VaultDecryptionError) {
|
||||
console.log(` → Erreur de déchiffrement`);
|
||||
}
|
||||
results.push({
|
||||
route: `${route.method} ${route.path}`,
|
||||
success: false,
|
||||
error: error.message,
|
||||
errorType: error.name
|
||||
});
|
||||
}
|
||||
}
|
||||
console.log(`\n📊 Résumé des tests:`);
|
||||
const successCount = results.filter(r => r.success).length;
|
||||
const errorCount = results.filter(r => !r.success).length;
|
||||
console.log(` ✅ Succès: ${successCount}/${results.length}`);
|
||||
console.log(` ❌ Erreurs: ${errorCount}/${results.length}`);
|
||||
console.log('\n✅ ÉTAPE 3 TERMINÉE: Parcours des routes terminé');
|
||||
return results;
|
||||
}
|
||||
catch (error) {
|
||||
console.error('\n❌ ÉTAPE 3 ÉCHOUÉE:', error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* ÉTAPE 4: Synchronisation locale des fichiers déchiffrés + Gestion des erreurs
|
||||
*/
|
||||
async function step4_SyncLocalFiles(client) {
|
||||
console.log('\n💾 ÉTAPE 4: Synchronisation locale des fichiers déchiffrés + Gestion des erreurs');
|
||||
console.log('='.repeat(70));
|
||||
try {
|
||||
console.log('\n🔄 Synchronisation des fichiers vers le dossier local...');
|
||||
console.log(' Utilise VAULT_CONFS_DIR depuis le fichier .env');
|
||||
// Synchronisation avec options détaillées
|
||||
// Ne pas spécifier localDir pour utiliser VAULT_CONFS_DIR du .env
|
||||
const syncResult = await client.syncLocalFiles({
|
||||
environment: 'dev',
|
||||
verbose: true
|
||||
});
|
||||
console.log(`\n📊 Résultats de synchronisation:`);
|
||||
console.log(` ✅ Fichiers synchronisés: ${syncResult.synced}`);
|
||||
console.log(` ⏭️ Fichiers ignorés: ${syncResult.skipped}`);
|
||||
console.log(` ❌ Erreurs: ${syncResult.errors}`);
|
||||
// Affichage détaillé des résultats
|
||||
if (syncResult.details.length > 0) {
|
||||
console.log('\n📋 Détails par fichier:');
|
||||
syncResult.details.forEach(detail => {
|
||||
const icon = detail.status === 'synced' ? '✅' :
|
||||
detail.status === 'skipped' ? '⏭️' : '❌';
|
||||
console.log(` ${icon} ${detail.file}: ${detail.status}`);
|
||||
if (detail.message) {
|
||||
console.log(` → ${detail.message}`);
|
||||
}
|
||||
});
|
||||
}
|
||||
console.log('\n✅ ÉTAPE 4 TERMINÉE: Synchronisation locale terminée');
|
||||
}
|
||||
catch (error) {
|
||||
console.error('\n❌ ÉTAPE 4 ÉCHOUÉE:');
|
||||
if (error instanceof index_1.VaultApiError) {
|
||||
console.error(` Erreur API: ${error.message}`);
|
||||
console.error(` Code HTTP: ${error.statusCode}`);
|
||||
}
|
||||
else if (error.message.includes('synchronisation')) {
|
||||
console.error(` Erreur de synchronisation: ${error.message}`);
|
||||
}
|
||||
else {
|
||||
console.error(` Erreur inattendue: ${error.message}`);
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* ÉTAPE 5: Déchiffrement des contenus récupérés (non stocké) + Gestion des erreurs
|
||||
*/
|
||||
async function step5_DecryptContents(results) {
|
||||
console.log('\n🔓 ÉTAPE 5: Déchiffrement des contenus récupérés + Gestion des erreurs');
|
||||
console.log('='.repeat(70));
|
||||
try {
|
||||
const fileResults = results.filter(r => r.success && r.data && r.data.content);
|
||||
if (fileResults.length === 0) {
|
||||
console.log(' ⚠️ Aucun fichier récupéré pour déchiffrement');
|
||||
return;
|
||||
}
|
||||
console.log(`\n🔍 Déchiffrement de ${fileResults.length} fichier(s)...`);
|
||||
for (const fileResult of fileResults) {
|
||||
console.log(`\n📄 Fichier: ${fileResult.route}`);
|
||||
try {
|
||||
const content = fileResult.data.content;
|
||||
// Vérifier si le contenu est chiffré (format de démonstration)
|
||||
if (content.includes('[CONTENU CHIFFRÉ - DÉCHIFFREMENT NÉCESSAIRE]')) {
|
||||
console.log(' 🔐 Contenu chiffré détecté (format de démonstration)');
|
||||
// Extraire les métadonnées du format de démonstration
|
||||
const lines = content.split('\n');
|
||||
const metadata = {};
|
||||
lines.forEach((line) => {
|
||||
if (line.includes('Utilisateur:')) {
|
||||
metadata.user = line.split('Utilisateur:')[1]?.trim() || '';
|
||||
}
|
||||
else if (line.includes('Version de clé:')) {
|
||||
metadata.keyVersion = line.split('Version de clé:')[1]?.trim() || '';
|
||||
}
|
||||
else if (line.includes('Algorithme:')) {
|
||||
metadata.algorithm = line.split('Algorithme:')[1]?.trim() || '';
|
||||
}
|
||||
else if (line.includes('Rotation:')) {
|
||||
metadata.rotation = line.split('Rotation:')[1]?.trim() || '';
|
||||
}
|
||||
else if (line.includes('Taille chiffrée:')) {
|
||||
metadata.encryptedSize = line.split('Taille chiffrée:')[1]?.trim() || '';
|
||||
}
|
||||
});
|
||||
console.log(` 📋 Métadonnées extraites:`);
|
||||
console.log(` → Utilisateur: ${metadata.user}`);
|
||||
console.log(` → Version de clé: ${metadata.keyVersion}`);
|
||||
console.log(` → Algorithme: ${metadata.algorithm}`);
|
||||
console.log(` → Rotation: ${metadata.rotation}`);
|
||||
console.log(` → Taille chiffrée: ${metadata.encryptedSize}`);
|
||||
// Dans un vrai déchiffrement, on utiliserait la clé utilisateur
|
||||
console.log(` 🔑 Déchiffrement simulé: Contenu accessible avec la clé utilisateur`);
|
||||
}
|
||||
else {
|
||||
console.log(' 📝 Contenu non chiffré détecté');
|
||||
console.log(` 📄 Aperçu: ${content.substring(0, 100)}${content.length > 100 ? '...' : ''}`);
|
||||
}
|
||||
console.log(` ✅ Déchiffrement traité avec succès`);
|
||||
}
|
||||
catch (error) {
|
||||
console.log(` ❌ Erreur de déchiffrement: ${error.message}`);
|
||||
if (error instanceof index_1.VaultDecryptionError) {
|
||||
console.log(` → Erreur de déchiffrement spécifique`);
|
||||
console.log(` → Code: ${error.code}`);
|
||||
}
|
||||
else if (error.message.includes('déchiffrement')) {
|
||||
console.log(` → Erreur de traitement du contenu`);
|
||||
}
|
||||
else {
|
||||
console.log(` → Erreur inattendue lors du déchiffrement`);
|
||||
}
|
||||
}
|
||||
}
|
||||
console.log('\n✅ ÉTAPE 5 TERMINÉE: Déchiffrement des contenus terminé');
|
||||
}
|
||||
catch (error) {
|
||||
console.error('\n❌ ÉTAPE 5 ÉCHOUÉE:', error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Fonction principale - Exécute le scénario complet
|
||||
*/
|
||||
async function main() {
|
||||
console.log('🚀 DÉMONSTRATION COMPLÈTE DU CLIENT VAULT');
|
||||
console.log('Scénario: Initialisation → Routes → Parcours → Synchronisation → Déchiffrement');
|
||||
console.log('='.repeat(80));
|
||||
try {
|
||||
// ÉTAPE 1: Initialisation
|
||||
const client = await step1_Initialization();
|
||||
// ÉTAPE 2: Récupération des routes
|
||||
const routes = await step2_GetRoutes(client);
|
||||
// ÉTAPE 3: Parcours des routes
|
||||
const results = await step3_ParseRoutes(routes, client);
|
||||
// ÉTAPE 4: Synchronisation locale
|
||||
await step4_SyncLocalFiles(client);
|
||||
// ÉTAPE 5: Déchiffrement
|
||||
await step5_DecryptContents(results);
|
||||
console.log('\n🎉 SCÉNARIO COMPLET TERMINÉ AVEC SUCCÈS!');
|
||||
console.log('\n📝 Résumé du système sécurisé:');
|
||||
console.log(' • ✅ Authentification par ID utilisateur validée');
|
||||
console.log(' • ✅ Récupération des routes API fonctionnelle');
|
||||
console.log(' • ✅ Parcours de toutes les routes testé');
|
||||
console.log(' • ✅ Synchronisation locale des fichiers déchiffrés');
|
||||
console.log(' • ✅ Déchiffrement des contenus géré');
|
||||
console.log(' • ✅ Gestion d\'erreurs complète à chaque étape');
|
||||
console.log(' • ✅ Rotation automatique des clés active');
|
||||
console.log(' • ✅ Chiffrement quantum-résistant (ChaCha20-Poly1305)');
|
||||
}
|
||||
catch (error) {
|
||||
console.error('\n💥 ÉCHEC DU SCÉNARIO:', error);
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
// Exécution si appelé directement
|
||||
if (require.main === module) {
|
||||
main().catch(console.error);
|
||||
}
|
||||
//# sourceMappingURL=usage.js.map
|
||||
1
sdk-client/dist/examples/usage.js.map
vendored
Normal file
1
sdk-client/dist/examples/usage.js.map
vendored
Normal file
File diff suppressed because one or more lines are too long
4
sdk-client/dist/src/__tests__/setup.d.ts
vendored
Normal file
4
sdk-client/dist/src/__tests__/setup.d.ts
vendored
Normal file
@ -0,0 +1,4 @@
|
||||
/**
|
||||
* Configuration des tests pour le SDK Vault Client
|
||||
*/
|
||||
//# sourceMappingURL=setup.d.ts.map
|
||||
1
sdk-client/dist/src/__tests__/setup.d.ts.map
vendored
Normal file
1
sdk-client/dist/src/__tests__/setup.d.ts.map
vendored
Normal file
@ -0,0 +1 @@
|
||||
{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../src/__tests__/setup.ts"],"names":[],"mappings":"AAAA;;GAEG"}
|
||||
26
sdk-client/dist/src/__tests__/setup.js
vendored
Normal file
26
sdk-client/dist/src/__tests__/setup.js
vendored
Normal file
@ -0,0 +1,26 @@
|
||||
"use strict";
|
||||
/**
|
||||
* Configuration des tests pour le SDK Vault Client
|
||||
*/
|
||||
// Configuration globale pour les tests
|
||||
beforeAll(() => {
|
||||
// Configuration des timeouts pour les tests
|
||||
jest.setTimeout(30000);
|
||||
});
|
||||
beforeEach(() => {
|
||||
// Reset des mocks avant chaque test
|
||||
jest.clearAllMocks();
|
||||
});
|
||||
afterEach(() => {
|
||||
// Nettoyage après chaque test
|
||||
jest.restoreAllMocks();
|
||||
});
|
||||
// Mock des modules Node.js si nécessaire
|
||||
jest.mock('crypto', () => ({
|
||||
...jest.requireActual('crypto'),
|
||||
createDecipher: jest.fn(),
|
||||
}));
|
||||
// Variables d'environnement pour les tests
|
||||
process.env['NODE_ENV'] = 'test';
|
||||
process.env['TZ'] = 'UTC';
|
||||
//# sourceMappingURL=setup.js.map
|
||||
1
sdk-client/dist/src/__tests__/setup.js.map
vendored
Normal file
1
sdk-client/dist/src/__tests__/setup.js.map
vendored
Normal file
@ -0,0 +1 @@
|
||||
{"version":3,"file":"setup.js","sourceRoot":"","sources":["../../../src/__tests__/setup.ts"],"names":[],"mappings":";AAAA;;GAEG;AAEH,uCAAuC;AACvC,SAAS,CAAC,GAAG,EAAE;IACb,4CAA4C;IAC5C,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;AACzB,CAAC,CAAC,CAAC;AAEH,UAAU,CAAC,GAAG,EAAE;IACd,oCAAoC;IACpC,IAAI,CAAC,aAAa,EAAE,CAAC;AACvB,CAAC,CAAC,CAAC;AAEH,SAAS,CAAC,GAAG,EAAE;IACb,8BAA8B;IAC9B,IAAI,CAAC,eAAe,EAAE,CAAC;AACzB,CAAC,CAAC,CAAC;AAEH,yCAAyC;AACzC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC;IACzB,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC;IAC/B,cAAc,EAAE,IAAI,CAAC,EAAE,EAAE;CAC1B,CAAC,CAAC,CAAC;AAEJ,2CAA2C;AAC3C,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,MAAM,CAAC;AACjC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC"}
|
||||
167
sdk-client/dist/src/index.d.ts
vendored
Normal file
167
sdk-client/dist/src/index.d.ts
vendored
Normal file
@ -0,0 +1,167 @@
|
||||
export interface VaultConfig {
|
||||
baseUrl: string;
|
||||
verifySsl?: boolean;
|
||||
timeout?: number;
|
||||
userId: string;
|
||||
}
|
||||
export interface VaultFile {
|
||||
content: string;
|
||||
filename: string;
|
||||
size: number;
|
||||
encrypted: boolean;
|
||||
algorithm?: string | undefined;
|
||||
user_id?: string | undefined;
|
||||
key_version?: string | undefined;
|
||||
timestamp?: string | undefined;
|
||||
}
|
||||
export interface VaultHealth {
|
||||
status: string;
|
||||
service: string;
|
||||
encryption: string;
|
||||
algorithm: string;
|
||||
authentication?: string;
|
||||
key_rotation?: string;
|
||||
timestamp?: string;
|
||||
}
|
||||
export interface VaultInfo {
|
||||
name: string;
|
||||
version: string;
|
||||
domain: string;
|
||||
port: number;
|
||||
protocol: string;
|
||||
encryption: string;
|
||||
authentication?: string;
|
||||
key_rotation?: string;
|
||||
endpoints?: Record<string, string>;
|
||||
}
|
||||
export interface VaultRoute {
|
||||
method: string;
|
||||
path: string;
|
||||
description: string;
|
||||
authentication: string;
|
||||
headers_required: string[];
|
||||
response_type: string;
|
||||
parameters?: Record<string, string>;
|
||||
examples?: string[];
|
||||
}
|
||||
export interface VaultRoutes {
|
||||
routes: VaultRoute[];
|
||||
total_routes: number;
|
||||
authentication: {
|
||||
type: string;
|
||||
header: string;
|
||||
description: string;
|
||||
};
|
||||
user_id: string;
|
||||
timestamp: string;
|
||||
}
|
||||
export interface SyncOptions {
|
||||
environment: string;
|
||||
localDir?: string;
|
||||
verbose?: boolean;
|
||||
}
|
||||
export interface SyncResult {
|
||||
synced: number;
|
||||
skipped: number;
|
||||
errors: number;
|
||||
details: Array<{
|
||||
file: string;
|
||||
status: 'synced' | 'skipped' | 'error';
|
||||
message?: string;
|
||||
}>;
|
||||
}
|
||||
export interface VaultError {
|
||||
message: string;
|
||||
code?: string | undefined;
|
||||
statusCode?: number | undefined;
|
||||
}
|
||||
export declare class VaultApiError extends Error implements VaultError {
|
||||
readonly code?: string | undefined;
|
||||
readonly statusCode?: number | undefined;
|
||||
constructor(message: string, code?: string, statusCode?: number);
|
||||
}
|
||||
export declare class VaultDecryptionError extends Error implements VaultError {
|
||||
readonly code?: string | undefined;
|
||||
constructor(message: string, code?: string);
|
||||
}
|
||||
export declare class VaultAuthenticationError extends Error implements VaultError {
|
||||
readonly code?: string | undefined;
|
||||
readonly statusCode?: number | undefined;
|
||||
constructor(message: string, code?: string, statusCode?: number);
|
||||
}
|
||||
/**
|
||||
* Client sécurisé pour l'API Vault avec authentification par clés utilisateur
|
||||
* Les clés sont gérées côté serveur avec rotation automatique
|
||||
*/
|
||||
export declare class SecureVaultClient {
|
||||
private config;
|
||||
private vaultKey;
|
||||
constructor(config?: VaultConfig);
|
||||
/**
|
||||
* Récupère un fichier depuis l'API Vault
|
||||
*/
|
||||
getFile(env: string, filePath: string): Promise<VaultFile>;
|
||||
/**
|
||||
* Récupère plusieurs fichiers en parallèle
|
||||
*/
|
||||
getFiles(env: string, filePaths: string[]): Promise<VaultFile[]>;
|
||||
/**
|
||||
* Recherche des fichiers correspondant à un pattern
|
||||
*/
|
||||
searchFiles(_env: string, _pattern: string): Promise<VaultFile[]>;
|
||||
/**
|
||||
* Vérifie l'état de santé de l'API
|
||||
*/
|
||||
health(): Promise<VaultHealth>;
|
||||
/**
|
||||
* Récupère les informations sur l'API
|
||||
*/
|
||||
info(): Promise<VaultInfo>;
|
||||
/**
|
||||
* Test de connectivité simple
|
||||
*/
|
||||
ping(): Promise<boolean>;
|
||||
/**
|
||||
* Récupère toutes les routes disponibles de l'API
|
||||
*/
|
||||
getRoutes(): Promise<VaultRoutes>;
|
||||
/**
|
||||
* Synchronise les fichiers déchiffrés localement
|
||||
* Route vault /<env>/<project>/<file_name> -> ../confs/<project>/<file_name>
|
||||
* Les fichiers existants dans confs/ sont toujours écrasés pour avoir le contenu le plus récent
|
||||
*/
|
||||
syncLocalFiles(options: SyncOptions): Promise<SyncResult>;
|
||||
/**
|
||||
* Déchiffre le contenu avec les métadonnées utilisateur et gère la prochaine clé
|
||||
*/
|
||||
private decryptContent;
|
||||
/**
|
||||
* Met à jour la prochaine clé pour les requêtes suivantes et le fichier .env
|
||||
*/
|
||||
private updateNextKey;
|
||||
/**
|
||||
* Retourne le répertoire du fichier .env trouvé
|
||||
*/
|
||||
private _getEnvFileDirectory;
|
||||
/**
|
||||
* Charge les variables d'environnement depuis plusieurs emplacements possibles
|
||||
*/
|
||||
private _loadEnvironmentVariables;
|
||||
/**
|
||||
* Met à jour le fichier .env avec la nouvelle clé
|
||||
*/
|
||||
private updateEnvFile;
|
||||
/**
|
||||
* Effectue une requête vers l'API avec authentification
|
||||
*/
|
||||
private _fetchApi;
|
||||
}
|
||||
/**
|
||||
* Fonction utilitaire pour créer un client sécurisé
|
||||
*/
|
||||
export declare function createSecureVaultClient(baseUrl: string, userId: string): SecureVaultClient;
|
||||
/**
|
||||
* Fonction utilitaire pour créer un client sécurisé avec configuration complète
|
||||
*/
|
||||
export declare function createSecureVaultClientWithConfig(config: VaultConfig): SecureVaultClient;
|
||||
//# sourceMappingURL=index.d.ts.map
|
||||
1
sdk-client/dist/src/index.d.ts.map
vendored
Normal file
1
sdk-client/dist/src/index.d.ts.map
vendored
Normal file
@ -0,0 +1 @@
|
||||
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}
|
||||
559
sdk-client/dist/src/index.js
vendored
Normal file
559
sdk-client/dist/src/index.js
vendored
Normal file
@ -0,0 +1,559 @@
|
||||
"use strict";
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.SecureVaultClient = exports.VaultAuthenticationError = exports.VaultDecryptionError = exports.VaultApiError = void 0;
|
||||
exports.createSecureVaultClient = createSecureVaultClient;
|
||||
exports.createSecureVaultClientWithConfig = createSecureVaultClientWithConfig;
|
||||
const node_fetch_1 = __importDefault(require("node-fetch"));
|
||||
const https_1 = __importDefault(require("https"));
|
||||
const dotenv_1 = __importDefault(require("dotenv"));
|
||||
const { chacha20poly1305 } = require('@noble/ciphers/chacha.js');
|
||||
const fs_1 = __importDefault(require("fs"));
|
||||
const path_1 = __importDefault(require("path"));
|
||||
class VaultApiError extends Error {
|
||||
constructor(message, code, statusCode) {
|
||||
super(message);
|
||||
this.name = 'VaultApiError';
|
||||
this.code = code;
|
||||
this.statusCode = statusCode;
|
||||
}
|
||||
}
|
||||
exports.VaultApiError = VaultApiError;
|
||||
class VaultDecryptionError extends Error {
|
||||
constructor(message, code) {
|
||||
super(message);
|
||||
this.name = 'VaultDecryptionError';
|
||||
this.code = code;
|
||||
}
|
||||
}
|
||||
exports.VaultDecryptionError = VaultDecryptionError;
|
||||
class VaultAuthenticationError extends Error {
|
||||
constructor(message, code, statusCode) {
|
||||
super(message);
|
||||
this.name = 'VaultAuthenticationError';
|
||||
this.code = code;
|
||||
this.statusCode = statusCode;
|
||||
}
|
||||
}
|
||||
exports.VaultAuthenticationError = VaultAuthenticationError;
|
||||
/**
|
||||
* Client sécurisé pour l'API Vault avec authentification par clés utilisateur
|
||||
* Les clés sont gérées côté serveur avec rotation automatique
|
||||
*/
|
||||
class SecureVaultClient {
|
||||
constructor(config) {
|
||||
this.vaultKey = null;
|
||||
// Charger les variables d'environnement depuis .env
|
||||
// Essayer plusieurs emplacements pour le fichier .env
|
||||
this._loadEnvironmentVariables();
|
||||
// Si pas de config fournie, utiliser les variables d'environnement
|
||||
if (!config) {
|
||||
const envUser = process.env['VAULT_USER'];
|
||||
const envKey = process.env['VAULT_KEY'];
|
||||
const envEnv = process.env['VAULT_ENV'];
|
||||
if (!envUser || !envKey || !envEnv) {
|
||||
throw new Error('Variables d\'environnement requises: VAULT_USER, VAULT_KEY, VAULT_ENV');
|
||||
}
|
||||
config = {
|
||||
baseUrl: 'https://vault.4nkweb.com:6666',
|
||||
userId: envUser,
|
||||
timeout: 30000,
|
||||
verifySsl: false
|
||||
};
|
||||
this.vaultKey = envKey;
|
||||
}
|
||||
this.config = {
|
||||
verifySsl: false,
|
||||
timeout: 30000,
|
||||
...config,
|
||||
};
|
||||
// Validation de l'ID utilisateur
|
||||
if (!this.config.userId || this.config.userId.length < 3 || this.config.userId.length > 128) {
|
||||
throw new Error('ID utilisateur requis (3-128 caractères)');
|
||||
}
|
||||
if (!/^[a-zA-Z0-9_-]+$/.test(this.config.userId)) {
|
||||
throw new Error('ID utilisateur invalide - caractères autorisés: a-z, A-Z, 0-9, _, -');
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Récupère un fichier depuis l'API Vault
|
||||
*/
|
||||
async getFile(env, filePath) {
|
||||
const url = `${this.config.baseUrl}/${env}/${filePath}`;
|
||||
try {
|
||||
const response = await this._fetchApi(url);
|
||||
if (!response.ok) {
|
||||
if (response.status === 401) {
|
||||
throw new VaultAuthenticationError('Authentification échouée - vérifiez votre ID utilisateur', 'AUTH_FAILED', response.status);
|
||||
}
|
||||
if (response.status === 403) {
|
||||
throw new VaultApiError('Accès non autorisé à ce fichier', 'ACCESS_DENIED', response.status);
|
||||
}
|
||||
throw new VaultApiError(`Erreur API: ${response.status} ${response.statusText}`, 'API_ERROR', response.status);
|
||||
}
|
||||
const encryptedData = await response.arrayBuffer();
|
||||
// Extraction des métadonnées depuis les headers
|
||||
const user_id = response.headers.get('X-User-ID') || undefined;
|
||||
const keyRotation = response.headers.get('X-Key-Rotation') || undefined;
|
||||
const algorithm = response.headers.get('X-Algorithm') || undefined;
|
||||
// Déchiffrement du contenu avec les headers pour la prochaine clé
|
||||
const decryptedContent = this.decryptContent(Buffer.from(encryptedData), response.headers);
|
||||
return {
|
||||
content: decryptedContent,
|
||||
filename: filePath.split('/').pop() || filePath,
|
||||
size: decryptedContent.length,
|
||||
encrypted: true,
|
||||
algorithm,
|
||||
user_id,
|
||||
key_version: keyRotation,
|
||||
timestamp: new Date().toISOString()
|
||||
};
|
||||
}
|
||||
catch (error) {
|
||||
if (error instanceof VaultApiError || error instanceof VaultAuthenticationError) {
|
||||
throw error;
|
||||
}
|
||||
throw new VaultApiError(`Erreur lors de la récupération du fichier: ${error instanceof Error ? error.message : 'Inconnue'}`);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Récupère plusieurs fichiers en parallèle
|
||||
*/
|
||||
async getFiles(env, filePaths) {
|
||||
const promises = filePaths.map(filePath => this.getFile(env, filePath));
|
||||
return Promise.all(promises);
|
||||
}
|
||||
/**
|
||||
* Recherche des fichiers correspondant à un pattern
|
||||
*/
|
||||
async searchFiles(_env, _pattern) {
|
||||
// Cette fonctionnalité nécessiterait une implémentation côté serveur
|
||||
// Pour l'instant, retour d'une erreur explicative
|
||||
throw new VaultApiError('Recherche de fichiers non implémentée - contactez l\'administrateur', 'NOT_IMPLEMENTED');
|
||||
}
|
||||
/**
|
||||
* Vérifie l'état de santé de l'API
|
||||
*/
|
||||
async health() {
|
||||
const url = `${this.config.baseUrl}/health`;
|
||||
try {
|
||||
const response = await this._fetchApi(url);
|
||||
if (!response.ok) {
|
||||
throw new VaultApiError(`Erreur de santé API: ${response.status}`, 'HEALTH_CHECK_FAILED', response.status);
|
||||
}
|
||||
return await response.json();
|
||||
}
|
||||
catch (error) {
|
||||
if (error instanceof VaultApiError) {
|
||||
throw error;
|
||||
}
|
||||
throw new VaultApiError(`Erreur lors du contrôle de santé: ${error instanceof Error ? error.message : 'Inconnue'}`);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Récupère les informations sur l'API
|
||||
*/
|
||||
async info() {
|
||||
const url = `${this.config.baseUrl}/info`;
|
||||
try {
|
||||
const response = await this._fetchApi(url);
|
||||
if (!response.ok) {
|
||||
throw new VaultApiError(`Erreur info API: ${response.status}`, 'INFO_ERROR', response.status);
|
||||
}
|
||||
return await response.json();
|
||||
}
|
||||
catch (error) {
|
||||
if (error instanceof VaultApiError) {
|
||||
throw error;
|
||||
}
|
||||
throw new VaultApiError(`Erreur lors de la récupération des informations: ${error instanceof Error ? error.message : 'Inconnue'}`);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Test de connectivité simple
|
||||
*/
|
||||
async ping() {
|
||||
try {
|
||||
await this.health();
|
||||
return true;
|
||||
}
|
||||
catch (error) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Récupère toutes les routes disponibles de l'API
|
||||
*/
|
||||
async getRoutes() {
|
||||
const url = `${this.config.baseUrl}/routes`;
|
||||
try {
|
||||
const response = await this._fetchApi(url);
|
||||
if (!response.ok) {
|
||||
if (response.status === 401) {
|
||||
throw new VaultAuthenticationError('Authentification échouée - vérifiez votre ID utilisateur', 'AUTH_FAILED', response.status);
|
||||
}
|
||||
throw new VaultApiError(`Erreur API routes: ${response.status} ${response.statusText}`, 'ROUTES_API_ERROR', response.status);
|
||||
}
|
||||
return await response.json();
|
||||
}
|
||||
catch (error) {
|
||||
if (error instanceof VaultApiError || error instanceof VaultAuthenticationError) {
|
||||
throw error;
|
||||
}
|
||||
throw new VaultApiError(`Erreur lors de la récupération des routes: ${error instanceof Error ? error.message : 'Inconnue'}`);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Synchronise les fichiers déchiffrés localement
|
||||
* Route vault /<env>/<project>/<file_name> -> ../confs/<project>/<file_name>
|
||||
* Les fichiers existants dans confs/ sont toujours écrasés pour avoir le contenu le plus récent
|
||||
*/
|
||||
async syncLocalFiles(options) {
|
||||
// Recharger les variables d'environnement au cas où elles auraient changé
|
||||
this._loadEnvironmentVariables();
|
||||
// Récupérer le dossier de destination depuis les variables d'environnement
|
||||
const defaultConfsDir = process.env['VAULT_CONFS_DIR'] || '../confs';
|
||||
const { environment, localDir = defaultConfsDir, verbose = false } = options;
|
||||
const result = {
|
||||
synced: 0,
|
||||
skipped: 0,
|
||||
errors: 0,
|
||||
details: []
|
||||
};
|
||||
try {
|
||||
// 1. Créer le dossier de destination s'il n'existe pas
|
||||
// Résoudre le chemin par rapport au répertoire du fichier .env
|
||||
let targetDir;
|
||||
if (path_1.default.isAbsolute(localDir)) {
|
||||
targetDir = localDir;
|
||||
}
|
||||
else {
|
||||
// Pour les chemins relatifs, partir du répertoire du fichier .env
|
||||
const envFileDir = this._getEnvFileDirectory();
|
||||
targetDir = path_1.default.resolve(envFileDir, localDir);
|
||||
}
|
||||
if (!fs_1.default.existsSync(targetDir)) {
|
||||
fs_1.default.mkdirSync(targetDir, { recursive: true });
|
||||
if (verbose) {
|
||||
console.log(`📁 Dossier créé: ${targetDir}`);
|
||||
}
|
||||
}
|
||||
// 2. Récupérer la liste des routes pour identifier les fichiers
|
||||
const routes = await this.getRoutes();
|
||||
// 3. Extraire les fichiers disponibles depuis les exemples de routes
|
||||
const fileRoute = routes.routes.find(route => route.path.includes('<env>') && route.path.includes('<file_path>'));
|
||||
if (!fileRoute || !fileRoute.examples) {
|
||||
throw new VaultApiError('Impossible de déterminer les fichiers disponibles');
|
||||
}
|
||||
// 4. Parser les exemples pour extraire les projets et fichiers
|
||||
const filesToSync = [];
|
||||
for (const example of fileRoute.examples) {
|
||||
// Format: /dev/bitcoin/bitcoin.conf -> project: bitcoin, fileName: bitcoin.conf
|
||||
const pathParts = example.split('/').filter(part => part && part !== environment);
|
||||
if (pathParts.length >= 2) {
|
||||
const project = pathParts[0] || 'unknown';
|
||||
const fileName = pathParts[pathParts.length - 1] || 'unknown';
|
||||
const vaultPath = pathParts.join('/');
|
||||
filesToSync.push({
|
||||
project,
|
||||
fileName,
|
||||
vaultPath
|
||||
});
|
||||
}
|
||||
}
|
||||
// 5. Synchroniser chaque fichier
|
||||
for (const file of filesToSync) {
|
||||
try {
|
||||
const localProjectDir = path_1.default.join(targetDir, file.project);
|
||||
const localFilePath = path_1.default.join(localProjectDir, file.fileName);
|
||||
// Créer le dossier du projet s'il n'existe pas
|
||||
if (!fs_1.default.existsSync(localProjectDir)) {
|
||||
fs_1.default.mkdirSync(localProjectDir, { recursive: true });
|
||||
if (verbose) {
|
||||
console.log(`📁 Dossier projet créé: ${localProjectDir}`);
|
||||
}
|
||||
}
|
||||
// Toujours écraser les fichiers dans confs/ pour avoir le contenu le plus récent
|
||||
// La vérification d'existence est conservée pour le logging uniquement
|
||||
const fileExists = fs_1.default.existsSync(localFilePath);
|
||||
if (fileExists && verbose) {
|
||||
console.log(`🔄 Écrasement du fichier existant: ${file.vaultPath}`);
|
||||
}
|
||||
// Récupérer le fichier depuis le vault
|
||||
const vaultFile = await this.getFile(environment, file.vaultPath);
|
||||
// Extraire le contenu déchiffré (simulation pour le format de démonstration)
|
||||
let content = vaultFile.content;
|
||||
// Le contenu est maintenant déchiffré automatiquement par decryptContent
|
||||
// Pas besoin de récupérer depuis le storage, le contenu vient de l'API déchiffrée
|
||||
// Écrire le fichier local
|
||||
fs_1.default.writeFileSync(localFilePath, content, 'utf8');
|
||||
result.synced++;
|
||||
result.details.push({
|
||||
file: file.vaultPath,
|
||||
status: 'synced',
|
||||
message: `Synchronisé vers ${localFilePath}`
|
||||
});
|
||||
if (verbose) {
|
||||
console.log(`✅ Synchronisé: ${file.vaultPath} -> ${localFilePath}`);
|
||||
}
|
||||
}
|
||||
catch (error) {
|
||||
result.errors++;
|
||||
const errorMessage = error instanceof Error ? error.message : 'Erreur inconnue';
|
||||
result.details.push({
|
||||
file: file.vaultPath,
|
||||
status: 'error',
|
||||
message: errorMessage
|
||||
});
|
||||
if (verbose) {
|
||||
console.log(`❌ Erreur: ${file.vaultPath} - ${errorMessage}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (verbose) {
|
||||
console.log(`\n📊 Résumé de synchronisation:`);
|
||||
console.log(` ✅ Synchronisés: ${result.synced}`);
|
||||
console.log(` ⏭️ Ignorés: ${result.skipped}`);
|
||||
console.log(` ❌ Erreurs: ${result.errors}`);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
catch (error) {
|
||||
throw new VaultApiError(`Erreur lors de la synchronisation: ${error instanceof Error ? error.message : 'Inconnue'}`);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Déchiffre le contenu avec les métadonnées utilisateur et gère la prochaine clé
|
||||
*/
|
||||
decryptContent(encryptedData, responseHeaders) {
|
||||
try {
|
||||
// Décoder le base64
|
||||
const decoded = Buffer.from(encryptedData.toString(), 'base64');
|
||||
// Nouveau format: nonce (12 bytes) + taille_métadonnées (4 bytes) + métadonnées + contenu chiffré
|
||||
if (decoded.length < 16) {
|
||||
throw new Error('Données chiffrées invalides - format incorrect');
|
||||
}
|
||||
const nonce = decoded.subarray(0, 12);
|
||||
const metadataSize = decoded.readUInt32BE(12);
|
||||
const metadataJson = decoded.subarray(16, 16 + metadataSize);
|
||||
const ciphertext = decoded.subarray(16 + metadataSize);
|
||||
// Parse des métadonnées
|
||||
const metadata = JSON.parse(metadataJson.toString('utf-8'));
|
||||
// Vérification de l'utilisateur
|
||||
if (metadata.user_id !== this.config.userId) {
|
||||
throw new VaultAuthenticationError('Métadonnées utilisateur ne correspondent pas', 'USER_MISMATCH');
|
||||
}
|
||||
// Récupération de la prochaine clé depuis les headers ou les métadonnées
|
||||
const nextKey = responseHeaders?.get('X-Next-Key') || metadata.next_key;
|
||||
// Pour le déchiffrement, utiliser la clé courante d'abord
|
||||
const keyToUse = this.vaultKey;
|
||||
if (!keyToUse) {
|
||||
throw new VaultDecryptionError('Clé de déchiffrement non disponible');
|
||||
}
|
||||
console.log(`🔑 Utilisation de la clé courante pour déchiffrement: ${keyToUse.substring(0, 20)}...`);
|
||||
// Ne pas mettre à jour la clé immédiatement, attendre un déchiffrement réussi
|
||||
try {
|
||||
// Convertir la clé base64 en Uint8Array
|
||||
const key = Buffer.from(keyToUse, 'base64');
|
||||
// Déchiffrement ChaCha20-Poly1305 avec @noble/ciphers
|
||||
const cipher = chacha20poly1305(key, nonce);
|
||||
const decrypted = cipher.decrypt(ciphertext);
|
||||
// Déchiffrement réussi, mettre à jour la clé pour la prochaine requête
|
||||
if (nextKey) {
|
||||
this.updateNextKey(nextKey);
|
||||
}
|
||||
// Retourner le contenu déchiffré
|
||||
return Buffer.from(decrypted).toString('utf-8');
|
||||
}
|
||||
catch (decryptError) {
|
||||
// Si le déchiffrement échoue, essayer avec la prochaine clé si elle est différente
|
||||
if (nextKey && nextKey !== keyToUse) {
|
||||
console.log(`🔄 Tentative de déchiffrement avec la prochaine clé...`);
|
||||
try {
|
||||
const nextKeyBuffer = Buffer.from(nextKey, 'base64');
|
||||
const cipherNext = chacha20poly1305(nextKeyBuffer, nonce);
|
||||
const decryptedNext = cipherNext.decrypt(ciphertext);
|
||||
console.log(`✅ Déchiffrement réussi avec la prochaine clé !`);
|
||||
// Déchiffrement réussi avec la prochaine clé, mettre à jour
|
||||
this.updateNextKey(nextKey);
|
||||
return Buffer.from(decryptedNext).toString('utf-8');
|
||||
}
|
||||
catch (nextDecryptError) {
|
||||
console.warn(`⚠️ Déchiffrement avec la prochaine clé échoué: ${nextDecryptError instanceof Error ? nextDecryptError.message : 'Erreur inconnue'}`);
|
||||
}
|
||||
}
|
||||
throw new VaultDecryptionError(`Erreur de déchiffrement ChaCha20-Poly1305: ${decryptError instanceof Error ? decryptError.message : 'Inconnue'}`);
|
||||
}
|
||||
}
|
||||
catch (error) {
|
||||
if (error instanceof VaultAuthenticationError || error instanceof VaultDecryptionError) {
|
||||
throw error;
|
||||
}
|
||||
throw new VaultDecryptionError(`Erreur de déchiffrement: ${error instanceof Error ? error.message : 'Inconnue'}`);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Met à jour la prochaine clé pour les requêtes suivantes et le fichier .env
|
||||
*/
|
||||
updateNextKey(nextKey) {
|
||||
if (nextKey) {
|
||||
this.vaultKey = nextKey; // Mettre à jour la clé courante
|
||||
// Mettre à jour le fichier .env avec la nouvelle clé
|
||||
this.updateEnvFile(nextKey);
|
||||
console.log(`🔑 Prochaine clé mise à jour: ${nextKey.substring(0, 20)}...`);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Retourne le répertoire du fichier .env trouvé
|
||||
*/
|
||||
_getEnvFileDirectory() {
|
||||
// Chercher le fichier .env dans l'ordre de priorité
|
||||
const possibleEnvPaths = [
|
||||
path_1.default.join(__dirname, '.env'), // Répertoire du SDK (priorité 1)
|
||||
path_1.default.join(process.cwd(), '.env'), // Répertoire de travail (priorité 2)
|
||||
'.env', // Répertoire courant (priorité 3)
|
||||
'../.env', // Répertoire parent (priorité 4)
|
||||
'../../.env', // Répertoire grand-parent (priorité 5)
|
||||
path_1.default.join(__dirname, '../.env'), // Parent du SDK (priorité 6)
|
||||
path_1.default.join(__dirname, '../../.env'), // Grand-parent du SDK (priorité 7)
|
||||
];
|
||||
for (const envPath of possibleEnvPaths) {
|
||||
try {
|
||||
if (fs_1.default.existsSync(envPath)) {
|
||||
// Retourner le répertoire du fichier .env
|
||||
const envDir = path_1.default.dirname(path_1.default.resolve(envPath));
|
||||
return envDir;
|
||||
}
|
||||
}
|
||||
catch (error) {
|
||||
// Ignorer les erreurs et continuer avec le chemin suivant
|
||||
continue;
|
||||
}
|
||||
}
|
||||
// Fallback vers le répertoire du SDK si aucun .env n'est trouvé
|
||||
return __dirname;
|
||||
}
|
||||
/**
|
||||
* Charge les variables d'environnement depuis plusieurs emplacements possibles
|
||||
*/
|
||||
_loadEnvironmentVariables() {
|
||||
const possibleEnvPaths = [
|
||||
'.env', // Répertoire courant
|
||||
'../.env', // Répertoire parent
|
||||
'../../.env', // Répertoire grand-parent
|
||||
path_1.default.join(__dirname, '.env'), // Répertoire du SDK
|
||||
path_1.default.join(__dirname, '../.env'), // Parent du SDK
|
||||
path_1.default.join(__dirname, '../../.env'), // Grand-parent du SDK
|
||||
path_1.default.join(process.cwd(), '.env'), // Répertoire de travail
|
||||
];
|
||||
let envLoaded = false;
|
||||
for (const envPath of possibleEnvPaths) {
|
||||
try {
|
||||
if (fs_1.default.existsSync(envPath)) {
|
||||
const result = dotenv_1.default.config({ path: envPath });
|
||||
if (!result.error) {
|
||||
console.log(`📄 Variables d'environnement chargées depuis: ${envPath}`);
|
||||
envLoaded = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (error) {
|
||||
// Ignorer les erreurs et continuer avec le chemin suivant
|
||||
continue;
|
||||
}
|
||||
}
|
||||
// Si aucun fichier .env n'a été trouvé, essayer le chargement par défaut
|
||||
if (!envLoaded) {
|
||||
try {
|
||||
dotenv_1.default.config();
|
||||
console.log('📄 Variables d\'environnement chargées depuis .env par défaut');
|
||||
}
|
||||
catch (error) {
|
||||
console.log('⚠️ Aucun fichier .env trouvé, utilisation des variables système uniquement');
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Met à jour le fichier .env avec la nouvelle clé
|
||||
*/
|
||||
updateEnvFile(newKey) {
|
||||
try {
|
||||
const envPath = path_1.default.join(__dirname, '../../.env');
|
||||
// Lire le fichier .env actuel
|
||||
let envContent = '';
|
||||
if (fs_1.default.existsSync(envPath)) {
|
||||
envContent = fs_1.default.readFileSync(envPath, 'utf8');
|
||||
}
|
||||
// Mettre à jour ou ajouter la clé VAULT_KEY
|
||||
const keyRegex = /^VAULT_KEY=.*$/m;
|
||||
if (keyRegex.test(envContent)) {
|
||||
envContent = envContent.replace(keyRegex, `VAULT_KEY="${newKey}"`);
|
||||
}
|
||||
else {
|
||||
envContent += `\nVAULT_KEY="${newKey}"\n`;
|
||||
}
|
||||
// Écrire le fichier .env mis à jour
|
||||
fs_1.default.writeFileSync(envPath, envContent, 'utf8');
|
||||
console.log(`📝 Fichier .env mis à jour avec la nouvelle clé`);
|
||||
}
|
||||
catch (error) {
|
||||
console.warn(`⚠️ Impossible de mettre à jour le fichier .env: ${error instanceof Error ? error.message : 'Erreur inconnue'}`);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Effectue une requête vers l'API avec authentification
|
||||
*/
|
||||
async _fetchApi(url) {
|
||||
const controller = new AbortController();
|
||||
const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
|
||||
try {
|
||||
const mergedOptions = {
|
||||
method: 'GET',
|
||||
headers: {
|
||||
'User-Agent': 'SecureVaultClient/2.0.0',
|
||||
'X-User-ID': this.config.userId,
|
||||
'Accept': 'application/octet-stream'
|
||||
},
|
||||
signal: controller.signal
|
||||
};
|
||||
// Configuration SSL pour les certificats auto-signés
|
||||
if (this.config.verifySsl === false) {
|
||||
mergedOptions.agent = new https_1.default.Agent({
|
||||
rejectUnauthorized: false
|
||||
});
|
||||
}
|
||||
const response = await (0, node_fetch_1.default)(url, mergedOptions);
|
||||
clearTimeout(timeoutId);
|
||||
return response;
|
||||
}
|
||||
catch (error) {
|
||||
clearTimeout(timeoutId);
|
||||
if (error instanceof Error && error.name === 'AbortError') {
|
||||
throw new VaultApiError(`Timeout de la requête (${this.config.timeout}ms)`, 'TIMEOUT');
|
||||
}
|
||||
throw new VaultApiError(`Erreur de connexion: ${error instanceof Error ? error.message : 'Inconnue'}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
exports.SecureVaultClient = SecureVaultClient;
|
||||
/**
|
||||
* Fonction utilitaire pour créer un client sécurisé
|
||||
*/
|
||||
function createSecureVaultClient(baseUrl, userId) {
|
||||
return new SecureVaultClient({
|
||||
baseUrl,
|
||||
userId,
|
||||
verifySsl: false, // Pour les certificats auto-signés en développement
|
||||
timeout: 15000
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Fonction utilitaire pour créer un client sécurisé avec configuration complète
|
||||
*/
|
||||
function createSecureVaultClientWithConfig(config) {
|
||||
return new SecureVaultClient(config);
|
||||
}
|
||||
//# sourceMappingURL=index.js.map
|
||||
1
sdk-client/dist/src/index.js.map
vendored
Normal file
1
sdk-client/dist/src/index.js.map
vendored
Normal file
File diff suppressed because one or more lines are too long
1
storage/dev/4NK_miner/.gitkeep
Normal file
1
storage/dev/4NK_miner/.gitkeep
Normal file
@ -0,0 +1 @@
|
||||
./
|
||||
Loading…
x
Reference in New Issue
Block a user