SafeScript – JavaScript xavfsiz kichik tili

Web‑dasturlashda foydalanuvchi tomonidan kiritilgan kodni bajarish har doim xavfsizlik tahdidini tug'diradi. JSON ma'lumot almashinuvi kabi, hisoblashni ham xavfsiz formatga o‘tkazish g‘oyasi SafeScript loyihasida amalda qo‘llanildi. Bu loyiha JavaScriptning qat'iy cheklangan podsetini yaratadi, unda eval, new, global o‘zgaruvchilar yoki prototipga kirish kabi xavfli konstruktsiyalar mavjud emas. Natijada .safe kengaytmali fayllar ichida yozilgan kodni har qanday muhitda (brauzer, Node.js) ishonch bilan ishga tushirish mumkin.

Texnik asos va fayl strukturasining tafsilotlari

SafeScript fayli .safe kengaytmasi bilan saqlanadi va application/safescript MIME turiga ega. Fayl boshida maxsus blok izoh (/** */) orqali quyidagi deklaratsiyalar kiritiladi:

// Node.js
const SafeScript = require('safescript');

const result = await SafeScript.run('return x + y;', { x: 10, y: 20 });
// → 30

// Safe globals are available by default — no injection needed
await SafeScript.run('return Math.floor(3.7);');     // → 3
await SafeScript.run('return JSON.parse("{}");');     // → {} (null-prototype, __proto__ stripped)
await SafeScript.run('return Object.keys({a:1});');   // → ['a']

// Math.random is deterministic by default (mulberry32 PRNG, seed 0)
await SafeScript.run('return Math.random();');  // → same value every time

• @safescript – til versiyasi, masalan 0.2;
• @needs – host muhitidan majburiy talab qilinadigan obyektlar (masalan request: Request);
• @uses – ixtiyoriy, mavjud bo‘lsa ishlatiladigan obyektlar;
• @type – host tomonidan taqdim etiladigan obyektlarning metodlari ro‘yxati (masalan Response { json, text, status });
• @env – kod qaysi muhitlarda (browser, node) ishlashini belgilovchi ro‘yxat.

Bu deklaratsiyalar fayl yuklanish vaqtida load() funksiyasi tomonidan tekshiriladi. Har bir @type nomi hostning allowMethods ro‘yxatida ro‘yxatga olingan bo‘lsa, kod bajarilishiga ruxsat beriladi; aks holda load() xato qaytaradi. Bu yondashuv kodni ishga tushirishdan oldin xavfsizlik nuqtai nazaridan muhim tekshiruvni amalga oshiradi.

<!-- Browser -->
<script src="safescript.min.js"></script>
<script>
  SafeScript.run('return n * 2;', { n: 21 }).then(function(result) {
    // → 42
  });
</script>

SafeScriptning amaliy qo‘llanilishi

Quyidagi sohalarda SafeScriptning xavfsiz hisoblash modeli foydali bo‘lishi mumkin:

/**
 * @safescript 0.2
 * @needs request: Request
 * @needs db: Database
 * @uses logger: Logger
 * @env browser, node
 */
var body = request.json();
if (logger) logger.log('received', body);
return db.store(body);

• Web‑server handlerlari – foydalanuvchi yoki tenantlar tomonidan yuborilgan validatsiya qoidalari, so‘rov transformatsiyalari;
• Browser event handlerlari – onclick kabi foydalanuvchi yozgan skriptlar sandbox ichida ishlaydi;
• Plagin skriptlari – dasturga foydalanuvchi tomonidan taqdim etilgan kengaytmalar xavfsiz tarzda integratsiya qilinadi;
• Formulalar va ifodalar – elektron jadval yoki narx hisoblash tizimlarida foydalanuvchi kiritgan formulalar .safe fayl sifatida bajariladi;
• AI agentlari uchun botlar – Safebots loyihasida AI agentlari chaqiradigan funksiyalar SafeScript orqali izolyatsiyalangan.

Misol uchun, Node.js muhitida quyidagi kod fragmenti SafeScript.run yordamida .safe faylni bajaradi:

/**
 * @safescript 0.2
 * @needs fetch: function
 * @needs log: function
 * @type Response { json, text, status }
 * @type Stream { get, set, fields }
 */
var resp = fetch('/api/data');
var data = resp.json();
log(data);

const SafeScript = require('safescript');
const result = await SafeScript.run('return x + y;', { x: 10, y: 20 });
// → 30

Bu yerda Math.random() standartda deterministik mulberry32 PRNG bilan, boshlang‘ich urug‘ 0 ga o‘rnatilgan, shuning uchun har bir ishga tushirishda bir xil natija olinadi.

const SafeScript = require('safescript');

// 1. Parse the header
const caps = SafeScript.capabilities(source);
// → { version: '0.2', env: ['browser', 'node'],
//     needs: [{name: 'request', type: 'Request'}, ...],
//     uses: [{name: 'logger', type: 'Logger'}] }

// 2. Check that you can satisfy the requirements
const check = SafeScript.checkScope(source, myScope);
if (!check.ok) throw new Error('Missing: ' + check.missing.join(', '));

// 3. Run with the scope you built
const result = await SafeScript.run(source, myScope);

Taqqoslash: SafeScript va an'anaviy JavaScript sandboxlari

Ko‘pgina JavaScript sandboxlari (masalan vm2, iframe sandbox) kodni izolyatsiyalashga harakat qiladi, lekin ular ko‘pincha require yoki import kabi modul tizimlariga tayanadi. Bu esa paket menejerlari orqali yetkazib beriladigan xavfli kodni (supply‑chain attack) kiritish imkoniyatini yaratadi. SafeScript bu muammodan to‘liq chetga chiqadi – .safe fayl hech qanday import, require yoki paket menejeri bilan bog‘lanmaydi. Buning o‘rniga host kerakli funksiyalarni deklaratsiya orqali taqdim etadi.

// Return a computed value
await SafeScript.run('return price * qty;', { price: 9.99, qty: 3 });  // → 29.97

// Return a function (the function itself is async)
var double = await SafeScript.run('return function(n) { return n * 2; };', {});
await double(21);  // → 42

// Return an object — the "module" pattern
var mod = await SafeScript.run(`
  var count = 0;
  return {
    inc: function() { count = count + 1; return count; },
    get: function() { return count; }
  };
`, {});
await mod.inc(); await mod.inc(); await mod.get(); // → 2

// Side-effect only (write to an injected capability, no return needed)
await SafeScript.run('db.store(record);', { db: myDb, record: data });

Shuningdek, SafeScriptning token/grammar allowlist darajasi ancha qat‘iy: class, async, await, template literals, delete kabi sintaksis elementlari bloklanadi. Bu esa kodni tahlil qilishni soddalashtiradi va potentsial exploitlarni oldini oladi.

// Same SafeScript source works identically whether scope is local or proxied:
var el = createElement("div")    // <- auto-awaited, works if createElement
setText(el, "Hello")             //    returns a value OR a Promise
appendTo(el, container)          //    (e.g. from a MessageChannel proxy)
return getText(el)

Cheklovlar va ochiq savollar

SafeScript hali ham rivojlanish bosqichida, shuning uchun ba’zi cheklovlar mavjud:

// Abort after 5 seconds
var result = await SafeScript.run(source, scope, { timeout: 5000 });

// Limit total operations (loop iterations + function entries)
var result = await SafeScript.run(source, scope, { maxOps: 10000 });

// Both
var result = await SafeScript.run(source, scope, { timeout: 5000, maxOps: 50000 });

• Dinamik kod yaratish (new Function yoki eval) umuman qo‘llab‑quvvatlanmaydi, bu ba’zi algoritmlarni (masalan, dinamik SQL generatorlari) yozishni murakkablashtiradi.
• Asinxron operatsiyalar (Promise, async/await) cheklangan; asinxron kodni bajarish uchun host tomonidan maxsus fetch yoki setTimeout kabi funksiyalarni deklaratsiya qilish kerak.
• Typelar deklaratsiyasi faqat deklarativ bo‘lib, runtime tekshiruvni mustahkamlash uchun qo‘shimcha mexanizmlarga ehtiyoj bor.
• Ekotizimning kengayishi – hozirda .safe fayllar faqat JavaScript va PHP ga transpilyatsiya qilinadi, boshqa tillarga qo‘llab‑quvvatlash rejalashtirilgan, lekin hali amalga oshmagan.

Bu savollarni hal qilish uchun loyiha jamoasi defense‑in‑depth tamoyilini davom ettiradi: token darajasi, deklarativ header, host‑side tekshiruvlar va runtime sandbox birgalikda ishlaydi.

Kimlarga va qanday ta'sir qiladi?

SafeScript quyidagi auditoriyalar uchun qimmatli:

• Platforma provayderlari – multi‑tenant SaaS xizmatlari foydalanuvchi kodini izolyatsiyalash orqali platforma xavfsizligini oshiradi.
• Front‑end ishlab chiquvchilar – brauzerda foydalanuvchi yozgan event handlerlarni .safe faylga o‘tkazish orqali XSS tahdidini kamaytiradi.
• AI agent tizimlari – Safebots kabi agentlar uchun “xavfsiz chaqiriq” interfeysi yaratadi, shu bilan birga modelning “hallucination” xavfini pasaytiradi.
• Korxona ichki avtomatlashtirish – konfiguratsiya fayllarida formulalar, hisoblash qoidalari .safe formatida saqlanadi, bu esa IT‑xavfsizlik bo‘limiga auditni osonlashtiradi.

Har bir .safe fayl o‘zining trust boundary (ishonch chegarasi) bo‘lib, deklaratsiyalar orqali xavfsizlik pozitsiyasini bir qarashda ko‘rish mumkin. Bu shaffoflik audit jarayonini tezlashtiradi va xavfsizlik siyosatlarini avtomatlashtirishga imkon beradi.

Xulosa

SafeScript JavaScriptning xavfsiz, transportga yaroqli kichik tili sifatida, kodni sandbox ichida bajarish uchun yangi paradigm yaratadi. Deklarativ header, qat'iy sintaksis cheklovi va host‑side capability mapping kombinatsiyasi kodni ishga tushirishdan oldin ko‘p darajada tekshirishni ta'minlaydi. Hozirgi cheklovlar mavjud bo‘lsa-da, loyiha ekotizimini kengaytirish, asinxron qo‘llab‑quvvatlash va turli platformalarga transpilyatsiya qilish yo‘nalishida faol rivojlanmoqda. Xavfsiz foydalanuvchi‑yaratgan kodni bajarish muammosiga yechim izlayotgan har qanday dasturchi yoki platforma egasi SafeScriptni sinab ko‘rishi lozim.

Manba: SafeScript GitHub

Asl manba: github.com