How to Integrate Replit with Trend Micro

1// verify-cloudone-secrets.js
2const axios = require('axios');
3
4const API_KEY = process.env.CLOUDONE_API_KEY;
5const REGION = process.env.CLOUDONE_REGION || 'us-1';
6
7if (!API_KEY) {
8  console.error('CLOUDONE_API_KEY not found in Replit Secrets (lock icon 🔒).');
9  process.exit(1);
10}
11
12async function testConnection() {
13  // Test using the Workload Security API info endpoint
14  const resp = await axios.get(
15    `https://workloadsecurity.${REGION}.cloudone.trendmicro.com/api/apikeys/current`,
16    {
17      headers: {
18        'Authorization': `ApiKey ${API_KEY}`,
19        'api-version': 'v1',
20        'Content-Type': 'application/json'
21      }
22    }
23  );
24  console.log('Cloud One API connection OK');
25  console.log('API key name:', resp.data.name);
26  console.log('Role ID:', resp.data.roleID);
27}
28
29testConnection().catch(err => {
30  console.error('Connection failed:', err.response?.status, err.response?.data || err.message);
31  if (err.response?.status === 401) console.error('Check CLOUDONE_API_KEY in Replit Secrets.');
32});

1# workload_security.py — Query Cloud One Workload Security (Python)
2import os
3import requests
4from flask import Flask, jsonify
5
6API_KEY = os.environ['CLOUDONE_API_KEY']
7REGION = os.environ.get('CLOUDONE_REGION', 'us-1')
8WS_BASE = f'https://workloadsecurity.{REGION}.cloudone.trendmicro.com/api'
9
10HEADERS = {
11    'Authorization': f'ApiKey {API_KEY}',
12    'api-version': 'v1',
13    'Content-Type': 'application/json'
14}
15
16def get_computers(max_items=100):
17    """List all computers protected by Cloud One Workload Security."""
18    resp = requests.get(
19        f'{WS_BASE}/computers',
20        headers=HEADERS,
21        params={'expand': 'antiMalware,intrusionPrevention,integrityMonitoring', 'maxItems': max_items}
22    )
23    resp.raise_for_status()
24    return resp.json().get('computers', [])
25
26def get_computers_with_alerts():
27    """Return only computers that have active security alerts."""
28    computers = get_computers()
29    return [c for c in computers if c.get('alarmStatus') == 'error' or c.get('tasks')]
30
31def summarize_protection_status(computers):
32    """Group computers by protection status."""
33    summary = {'protected': 0, 'warning': 0, 'error': 0, 'unmanaged': 0}
34    for c in computers:
35        state = c.get('computerStatus', {}).get('agentStatus', 'unmanaged').lower()
36        if state in summary:
37            summary[state] += 1
38        else:
39            summary['unmanaged'] += 1
40    return summary
41
42app = Flask(__name__)
43
44@app.route('/api/security/computers')
45def list_computers():
46    computers = get_computers()
47    return jsonify({
48        'total': len(computers),
49        'summary': summarize_protection_status(computers),
50        'computers': [{
51            'id': c.get('ID'),
52            'hostname': c.get('hostName', 'unknown'),
53            'status': c.get('computerStatus', {}).get('agentStatus'),
54            'alarmStatus': c.get('alarmStatus')
55        } for c in computers]
56    })
57
58@app.route('/api/security/alerts')
59def computers_with_alerts():
60    computers = get_computers_with_alerts()
61    return jsonify({
62        'count': len(computers),
63        'computers': [{'id': c.get('ID'), 'hostname': c.get('hostName')} for c in computers]
64    })
65
66if __name__ == '__main__':
67    app.run(host='0.0.0.0', port=3000)

1// conformity.js — Cloud One Conformity compliance checks (Node.js)
2const axios = require('axios');
3const express = require('express');
4
5const API_KEY = process.env.CLOUDONE_API_KEY;
6const REGION = process.env.CLOUDONE_REGION || 'us-1';
7const CONF_BASE = `https://conformity.${REGION}.cloudone.trendmicro.com/api`;
8
9const conformity = axios.create({
10  baseURL: CONF_BASE,
11  headers: {
12    'Authorization': `ApiKey ${API_KEY}`,
13    'Content-Type': 'application/vnd.api+json'
14  }
15});
16
17async function getFailedChecks(accountId, riskLevel = 'HIGH', maxItems = 100) {
18  const resp = await conformity.get('/checks', {
19    params: {
20      'filter[accountIds]': accountId,
21      'filter[statuses]': 'FAILURE',
22      'filter[riskLevels]': riskLevel,
23      'page[size]': maxItems
24    }
25  });
26  return resp.data.data || [];
27}
28
29async function getAccountList() {
30  const resp = await conformity.get('/accounts');
31  return resp.data.data || [];
32}
33
34const app = express();
35
36// GET /api/conformity/accounts — list all connected cloud accounts
37app.get('/api/conformity/accounts', async (req, res) => {
38  try {
39    const accounts = await getAccountList();
40    res.json({
41      count: accounts.length,
42      accounts: accounts.map(a => ({
43        id: a.id,
44        name: a.attributes?.name,
45        provider: a.attributes?.provider,
46        status: a.attributes?.status
47      }))
48    });
49  } catch (err) {
50    res.status(500).json({ error: err.response?.data || err.message });
51  }
52});
53
54// GET /api/conformity/checks?accountId=xxx&risk=HIGH — get failed checks
55app.get('/api/conformity/checks', async (req, res) => {
56  const { accountId, risk = 'HIGH' } = req.query;
57  if (!accountId) return res.status(400).json({ error: 'accountId required' });
58  try {
59    const checks = await getFailedChecks(accountId, risk);
60    const summary = checks.reduce((acc, c) => {
61      const service = c.attributes?.service || 'Unknown';
62      acc[service] = (acc[service] || 0) + 1;
63      return acc;
64    }, {});
65    res.json({ totalFailed: checks.length, byService: summary, checks: checks.slice(0, 20) });
66  } catch (err) {
67    res.status(500).json({ error: err.response?.data || err.message });
68  }
69});
70
71app.listen(3000, '0.0.0.0', () => console.log('Cloud One Conformity API running'));
72

1# unified_security.py — Combined Cloud One security status API (Python)
2import os
3import time
4import asyncio
5import aiohttp
6from flask import Flask, jsonify
7
8API_KEY = os.environ['CLOUDONE_API_KEY']
9REGION = os.environ.get('CLOUDONE_REGION', 'us-1')
10
11WS_BASE = f'https://workloadsecurity.{REGION}.cloudone.trendmicro.com/api'
12CONF_BASE = f'https://conformity.{REGION}.cloudone.trendmicro.com/api'
13
14# Simple in-memory cache
15_cache = {}
16CACHE_TTL = 600  # 10 minutes
17
18def get_cached(key):
19    entry = _cache.get(key)
20    if entry and time.time() - entry['ts'] < CACHE_TTL:
21        return entry['data']
22    return None
23
24def set_cached(key, data):
25    _cache[key] = {'data': data, 'ts': time.time()}
26
27async def fetch_ws_summary(session):
28    async with session.get(
29        f'{WS_BASE}/computers',
30        headers={'Authorization': f'ApiKey {API_KEY}', 'api-version': 'v1'},
31        params={'maxItems': 500}
32    ) as resp:
33        data = await resp.json()
34    computers = data.get('computers', [])
35    alerts = sum(1 for c in computers if c.get('alarmStatus') == 'error')
36    return {'total_computers': len(computers), 'computers_with_alerts': alerts}
37
38async def fetch_conformity_summary(session, account_id):
39    async with session.get(
40        f'{CONF_BASE}/checks',
41        headers={'Authorization': f'ApiKey {API_KEY}', 'Content-Type': 'application/vnd.api+json'},
42        params={'filter[accountIds]': account_id, 'filter[statuses]': 'FAILURE',
43                'filter[riskLevels]': 'VERY_HIGH,HIGH', 'page[size]': 1}
44    ) as resp:
45        data = await resp.json()
46    total = data.get('meta', {}).get('total', len(data.get('data', [])))
47    return {'high_severity_failures': total}
48
49app = Flask(__name__)
50
51@app.route('/api/security/status')
52def security_status():
53    account_id = os.environ.get('CLOUDONE_ACCOUNT_ID', '')
54    cached = get_cached('status')
55    if cached:
56        cached['from_cache'] = True
57        return jsonify(cached)
58
59    async def gather():
60        async with aiohttp.ClientSession() as session:
61            tasks = [fetch_ws_summary(session)]
62            if account_id:
63                tasks.append(fetch_conformity_summary(session, account_id))
64            results = await asyncio.gather(*tasks, return_exceptions=True)
65            return results
66
67    results = asyncio.run(gather())
68    ws = results[0] if not isinstance(results[0], Exception) else {'error': str(results[0])}
69    conf = results[1] if len(results) > 1 and not isinstance(results[1], Exception) else {}
70
71    overall = 'healthy'
72    if ws.get('computers_with_alerts', 0) > 0 or conf.get('high_severity_failures', 0) > 0:
73        overall = 'needs_attention'
74
75    status = {'overall': overall, 'workload_security': ws, 'conformity': conf}
76    set_cached('status', status)
77    return jsonify(status)
78
79if __name__ == '__main__':
80    app.run(host='0.0.0.0', port=3000)