Is ЮБуст - VPN для YouTube. Обход блокировки Ютуб без ВПН. VPN для браузера safe?

const Tracker = new class GoogleAnalyticsTracker {
  // Reads the persistent UUID from chrome.storage.local under StorageKeys.ClientId.
  // If missing, mints a new UUID and saves it. Result: a per-install ID that
  // survives forever (until the user explicitly clears the extension's storage).
  async getOrCreateClientId() {
    const { clientId } = await Storage.get(StorageKeys.ClientId);
    if (typeof clientId === 'string') return clientId;
    const fresh = self.crypto.randomUUID();
    await Storage.set({ [StorageKeys.ClientId]: fresh });
    return fresh;
  }

  // Standard GA4 30-minute rolling session window.
  async getOrCreateSessionId() {
    const { sessionData } = await Storage.get(StorageKeys.SessionData);
    let session = sessionData ? { ...sessionData } : null;
    const now = Date.now();
    if (session) {
      if ((now - session.timestamp) / 60000 > 30) session = null;
      else { session.timestamp = now; await Storage.set({ sessionData: session }); }
    }
    if (!session) {
      session = { session_id: now.toString(), timestamp: now };
      await Storage.set({ sessionData: session });
    }
    return session.session_id;
  }

  // Builds a GA4 Measurement Protocol payload and POSTs it to Google.
  // The measurement_id and api_secret are HARDCODED in the URL — anyone
  // who unzips the extension can read them; conversely, every install of
  // ЮБуст is reporting against the same GA property keyed on client_id.
  async sendEvent({ name, params }) {
    try {
      const [client_id, session_id] = await Promise.all([
        this.getOrCreateClientId(),
        this.getOrCreateSessionId(),
      ]);
      const body = {
        client_id,
        events: [{
          name,
          params: { ...params, session_id, engagement_time_msec: 100 },
        }],
      };
      const url = 'https://www.google-analytics.com/mp/collect'
        + '?measurement_id=G-XCPV2XK66M'
        + '&api_secret=<redacted>';
      const resp = await fetch(url, { method: 'POST', body: JSON.stringify(body) });
      if (!resp.ok) console.error('Failed to send GA event:', await resp.text());
    } catch (e) { console.error('Error sending GA event:', e); }
  }

  trackPageView(page) {
    return this.sendEvent({
      name: 'page_view',
      params: { page_title: page, page_location: chrome.runtime.getURL(page) },
    });
  }

  trackUserAction(action, category, label) {
    return this.sendEvent({
      name: 'user_action',
      params: { action, category, label },
    });
  }

  trackError(error_message, error_type) {
    return this.sendEvent({
      name: 'extension_error',
      params: { error_message, error_type },
    });
  }
};

// Whenever ЮБуст walks chrome.management to look for other VPN / proxy /
// ad-blocker / 'internal' extensions, it reports each conflict to GA along
// with the OTHER extension's Chrome Web Store ID and human-readable name.
// Result: the developer's GA dashboard tells them which competing privacy
// tools each one of their users has installed.
if (proxyConflict.hasConflictingExtension) {
  Tracker.trackUserAction(
    'proxy_controlled_by_other_extension',
    proxyConflict.conflictingExtensionName ?? 'unknown',  // e.g. 'AdBlock Plus'
    proxyConflict.conflictingExtensionId,                  // e.g. 'cfhdojbkjhnklbpkdaibdccddilifddb'
  );
}
// Same shape for internal_extension_conflict, vpn_extension_conflict,
// ad_blocker_conflict.

// Onboarding / lifecycle:
await Tracker.trackUserAction('install',      'extension');                       // first install
await Tracker.trackUserAction('update',       'extension', previousVersion);      // version bump
await Tracker.trackUserAction('user_created', 'premium');                          // premium signup
await Tracker.trackUserAction('manual_start', 'proxy');                            // proxy started

// YouTube video routing — the YouTube URL is forwarded as the GA event label.
await Tracker.trackUserAction('video_redirect', 'youtube', youtubeUrl);

// Background alarm handler for the scheduled mid-roll.
if (alarm.name === Alarms.ShowMidpointMedia) {
  const { hasPremium } = await getLocal(Keys.HasPremium);
  const { featuresList } = await featureStore.getSnapshotAsync();
  const midpointEnabled = Boolean(featuresList?.[Features.MidpointMedia]);
  if (hasPremium || !midpointEnabled) return;        // skip paying users / disabled flag
  const tabs = await chrome.tabs.query({
    active: true, currentWindow: true, url: ['*://*.youtube.com/*'],
  });
  await Promise.all(tabs.map(t =>
    t.id ? chrome.tabs.sendMessage(t.id, { action: ContentAction.ShowMidpoint }) : null));
}

// Content script: inject the full-screen ad overlay over the player.
const overlay = document.createElement('div');
overlay.id = OVERLAY_ID;
overlay.style.cssText =
  'position:absolute;top:0;left:0;width:100%;height:100%;' +
  'background:black;z-index:9999;display:flex;justify-content:center;align-items:center;';
const frame = document.createElement('iframe');
frame.id = IFRAME_ID;
frame.src = midpointMediaUrls[regionKey];   // URL comes from downloaded remote config
frame.style.cssText = 'width:100%;height:100%;object-fit:contain;';
window.addEventListener('message', onFrameMessage);
overlay.appendChild(frame);
moviePlayer.appendChild(overlay);           // moviePlayer = document.getElementById('movie_player')

// Content script: pause playback and swallow YouTube keyboard shortcuts.
const blockKey = (e) => {
  if (['', 'ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown',
       'k','K','j','J','l','L','m','M','f','F','i','I'].includes(e.key)) {
    e.preventDefault(); e.stopPropagation(); e.stopImmediatePropagation();
  }
};
const pauseForOverlay = () => {
  postToPlayerBridge('pauseVideo');               // YT_METHOD_CALL -> injected wrapper
  document.querySelector('video')?.pause();
  document.getElementById('movie_player')?.pauseVideo?.();
  document.addEventListener('keydown', blockKey, true);   // capture phase
  document.addEventListener('keyup',   blockKey, true);
};

// Runs in the page MAIN world (web-accessible resource).
window.addEventListener('message', (event) => {
  const data = event.data;
  // Only accept the extension's own tagged messages.
  if (!(data && data.source === 'YT_API_WRAPPER'
        && data.type === 'YT_METHOD_CALL'
        && ['pauseVideo','playVideo','getPlayerState'].includes(data.method))) return;
  const player = document.getElementById('movie_player');
  if (!isYoutubePlayer(player)) return;
  const result = data.method === 'getPlayerState'
    ? player.getPlayerState()      // -1..5 player state
    : (player[data.method](), true);
  window.postMessage({ source: 'YT_API_WRAPPER', type: 'YT_METHOD_RESULT',
                       method: data.method, result }, '*');
});