Compare commits
No commits in common. "master" and "v1.0.2" have entirely different histories.
44
changelog.md
44
changelog.md
@ -1,49 +1,5 @@
|
||||
# Changelog
|
||||
|
||||
## 2025-02-05 - 1.3.0 - feat(ClamAvService)
|
||||
Add support for enhanced streaming methods in ClamAvService
|
||||
|
||||
- Add methods to ClamAvService: scanStream for NodeJS streams, scanWebStream for Web API streams, and scanFileFromWebAsStream for fetching and scanning files from URLs.
|
||||
- Update usage examples in readme for new streaming methods.
|
||||
|
||||
## 2025-02-05 - 1.2.0 - feat(ClamAvService)
|
||||
Add stream scanning methods to ClamAvService
|
||||
|
||||
- Added scanStream method to support scanning NodeJS streams directly.
|
||||
- Introduced scanWebStream method for scanning web resources as streams.
|
||||
- Integrated stream scanning into existing ClamAvService class.
|
||||
|
||||
## 2025-02-03 - 1.1.2 - fix(documentation)
|
||||
Update readme with additional legal and trademark information
|
||||
|
||||
- Added legal information related to licensing and trademarks
|
||||
- Provided company details of Task Venture Capital GmbH
|
||||
|
||||
## 2025-02-03 - 1.1.1 - fix(clamav.manager)
|
||||
Improve log handling and add timeout for log reception in ClamAV manager tests
|
||||
|
||||
- Refined the log receiving mechanism in ClamAV manager tests to use promises for better control over log receipt timing.
|
||||
- Introduced a timeout mechanism in the log receiving test case to avoid indefinite waiting.
|
||||
- Fixed the test case setup to accurately reflect log receipt and database information verification.
|
||||
|
||||
## 2025-02-03 - 1.1.0 - feat(ClamAvService)
|
||||
Add ClamAV Manager with Docker container management capabilities.
|
||||
|
||||
- Introduced ClamAVManager class to manage ClamAV Docker containers.
|
||||
- Implemented startContainer and stopContainer methods in ClamAVManager.
|
||||
- Integrated ClamAVManager into ClamAvService for managing container lifecycle.
|
||||
- Added ClamAVManager test setups and helpers in test suite.
|
||||
|
||||
## 2025-01-10 - 1.0.4 - fix(documentation)
|
||||
Removed redundant conclusion section in readme.
|
||||
|
||||
- Removed the conclusion section from the README file for conciseness.
|
||||
|
||||
## 2025-01-10 - 1.0.3 - fix(readme)
|
||||
Fix formatting errors in the README file for consistent Markdown syntax.
|
||||
|
||||
- Removed stray Markdown syntax in README file.
|
||||
|
||||
## 2025-01-10 - 1.0.2 - fix(documentation)
|
||||
Updated README and package metadata to reflect antivirus scanning capabilities and usage instructions.
|
||||
|
||||
|
||||
19
license
19
license
@ -1,19 +0,0 @@
|
||||
Copyright (c) 2025 Task Venture Capital GmbH (hello@task.vc)
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@push.rocks/smartantivirus",
|
||||
"version": "1.3.0",
|
||||
"version": "1.0.2",
|
||||
"private": false,
|
||||
"description": "A Node.js package for integrating antivirus scanning capabilities using ClamAV, allowing in-memory file and data scanning.",
|
||||
"main": "dist_ts/index.js",
|
||||
@ -19,13 +19,11 @@
|
||||
"@git.zone/tsrun": "^1.2.46",
|
||||
"@git.zone/tstest": "^1.0.44",
|
||||
"@push.rocks/tapbundle": "^5.0.15",
|
||||
"@types/node": "^20.8.7",
|
||||
"typescript": "^5.7.3"
|
||||
"@types/node": "^20.8.7"
|
||||
},
|
||||
"dependencies": {
|
||||
"@push.rocks/smartfile": "^11.1.5",
|
||||
"@push.rocks/smartpath": "^5.0.18",
|
||||
"@push.rocks/smartstream": "^3.2.5",
|
||||
"axios": "^1.7.9",
|
||||
"tar": "^7.4.3"
|
||||
},
|
||||
|
||||
13
pnpm-lock.yaml
generated
13
pnpm-lock.yaml
generated
@ -14,9 +14,6 @@ importers:
|
||||
'@push.rocks/smartpath':
|
||||
specifier: ^5.0.18
|
||||
version: 5.0.18
|
||||
'@push.rocks/smartstream':
|
||||
specifier: ^3.2.5
|
||||
version: 3.2.5
|
||||
axios:
|
||||
specifier: ^1.7.9
|
||||
version: 1.7.9
|
||||
@ -42,9 +39,6 @@ importers:
|
||||
'@types/node':
|
||||
specifier: ^20.8.7
|
||||
version: 20.17.12
|
||||
typescript:
|
||||
specifier: ^5.7.3
|
||||
version: 5.7.3
|
||||
|
||||
packages:
|
||||
|
||||
@ -3941,11 +3935,6 @@ packages:
|
||||
engines: {node: '>=14.17'}
|
||||
hasBin: true
|
||||
|
||||
typescript@5.7.3:
|
||||
resolution: {integrity: sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==}
|
||||
engines: {node: '>=14.17'}
|
||||
hasBin: true
|
||||
|
||||
uglify-js@3.19.3:
|
||||
resolution: {integrity: sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ==}
|
||||
engines: {node: '>=0.8.0'}
|
||||
@ -9613,8 +9602,6 @@ snapshots:
|
||||
|
||||
typescript@5.6.3: {}
|
||||
|
||||
typescript@5.7.3: {}
|
||||
|
||||
uglify-js@3.19.3: {}
|
||||
|
||||
uint8array-extras@1.4.0: {}
|
||||
|
||||
184
readme.md
184
readme.md
@ -1,72 +1,29 @@
|
||||
```markdown
|
||||
# @push.rocks/smartantivirus
|
||||
|
||||
A package for performing antivirus testing with ClamAV, featuring both direct daemon communication and Docker container management.
|
||||
|
||||
## Features
|
||||
|
||||
- **Docker Integration**: Automatically manages ClamAV containers for easy setup and testing
|
||||
- **Real-time Logging**: Captures and processes ClamAV logs with type-safe event handling
|
||||
- **Database Management**: Supports automatic database updates and version tracking
|
||||
- **Flexible Scanning**: Scan strings, buffers, and files for malware
|
||||
- **Health Monitoring**: Built-in service readiness checks and connection verification
|
||||
A package for performing antivirus testing, especially suitable for use with ClamAV.
|
||||
|
||||
## Install
|
||||
|
||||
Installing `@push.rocks/smartantivirus` is straightforward. You'll need Node.js and npm installed on your machine:
|
||||
Installing `@push.rocks/smartantivirus` is straightforward. You'll need Node.js and npm installed on your machine to get started. Once they are ready, you can add the `@push.rocks/smartantivirus` package to your project by running the following command:
|
||||
|
||||
```bash
|
||||
npm install @push.rocks/smartantivirus
|
||||
```
|
||||
|
||||
### Prerequisites
|
||||
|
||||
- Node.js and npm
|
||||
- Docker (for container-based usage)
|
||||
- ClamAV daemon (for direct daemon usage)
|
||||
This will add the package to your project's dependencies and allow you to integrate antivirus scanning capabilities directly into your application.
|
||||
|
||||
## Usage
|
||||
|
||||
The package provides two main ways to use ClamAV:
|
||||
The `@push.rocks/smartantivirus` package provides tools to easily integrate antivirus scanning capabilities into your Node.js application by interfacing with the ClamAV daemon. Below is a comprehensive guide on how to use the features of this library.
|
||||
|
||||
1. **Docker-based Usage** (Recommended): Uses `ClamAVManager` to automatically handle container lifecycle
|
||||
2. **Direct Daemon Usage**: Uses `ClamAvService` to communicate with an existing ClamAV daemon
|
||||
### Setting Up the ClamAV Daemon
|
||||
|
||||
Below is a comprehensive guide on how to use both approaches.
|
||||
Before using this package, make sure you have ClamAV installed and running on your system. You can find installation instructions for various operating systems on the [ClamAV official website](https://www.clamav.net/documents/installing-clamav).
|
||||
|
||||
### Docker-based Usage with ClamAVManager
|
||||
After installing ClamAV, start the ClamAV daemon (`clamd`). Make sure it is configured to listen on a port accessible to your Node.js application. You can configure this in the `clamd.conf` file, typically located in `/etc/clamav/clamd.conf`.
|
||||
|
||||
The `ClamAVManager` class provides a high-level interface for managing ClamAV in Docker containers:
|
||||
|
||||
```typescript
|
||||
import { ClamAVManager } from '@push.rocks/smartantivirus';
|
||||
|
||||
async function main() {
|
||||
// Create a new manager instance
|
||||
const manager = new ClamAVManager();
|
||||
|
||||
// Start the ClamAV container
|
||||
await manager.startContainer();
|
||||
|
||||
// Listen for log events
|
||||
manager.on('log', (event) => {
|
||||
console.log(`[ClamAV ${event.type}] ${event.message}`);
|
||||
});
|
||||
|
||||
// Get database information
|
||||
const dbInfo = await manager.getDatabaseInfo();
|
||||
console.log('Database Info:', dbInfo);
|
||||
|
||||
// Update virus definitions
|
||||
await manager.updateDatabase();
|
||||
|
||||
// When done, stop the container
|
||||
await manager.stopContainer();
|
||||
}
|
||||
|
||||
main().catch(console.error);
|
||||
```
|
||||
|
||||
### Direct Daemon Usage with ClamAvService
|
||||
### Basic Usage
|
||||
|
||||
The primary interface provided by the package is the `ClamAvService` class. It allows you to scan data in memory or verify the connection to the ClamAV daemon.
|
||||
|
||||
@ -94,43 +51,6 @@ async function main() {
|
||||
main().catch(console.error);
|
||||
```
|
||||
|
||||
### Streaming Scanning
|
||||
|
||||
The `ClamAvService` supports scanning both NodeJS streams and Web API streams using three specialized methods:
|
||||
|
||||
- `scanStream(stream: NodeJS.ReadableStream)`: Scans any NodeJS readable stream (files, network, etc.)
|
||||
- `scanWebStream(webstream: ReadableStream)`: Scans a Web API ReadableStream
|
||||
- `scanFileFromWebAsStream(url: string)`: Fetches and scans a file from a URL using NodeJS http/https
|
||||
|
||||
#### Example Usage
|
||||
|
||||
```typescript
|
||||
import { ClamAvService } from '@push.rocks/smartantivirus';
|
||||
import { createReadStream } from 'fs';
|
||||
|
||||
async function main() {
|
||||
const clamService = new ClamAvService('127.0.0.1', 3310);
|
||||
|
||||
// Example 1: Scanning a local file stream (NodeJS)
|
||||
const fileStream = createReadStream('path/to/local/file');
|
||||
const streamResult = await clamService.scanStream(fileStream);
|
||||
console.log('Stream Scan Result:', streamResult);
|
||||
|
||||
// Example 2: Scanning a web resource using NodeJS http/https
|
||||
const webResult = await clamService.scanFileFromWebAsStream('http://example.com/file');
|
||||
console.log('Web Stream Scan Result:', webResult);
|
||||
|
||||
// Example 3: Scanning a Web API ReadableStream
|
||||
const response = await fetch('http://example.com/file');
|
||||
if (response.body) {
|
||||
const webStreamResult = await clamService.scanWebStream(response.body);
|
||||
console.log('Web Stream API Scan Result:', webStreamResult);
|
||||
}
|
||||
}
|
||||
|
||||
main().catch(console.error);
|
||||
```
|
||||
|
||||
**Breaking Down the Example:**
|
||||
|
||||
1. **Initialization**: We start by creating an instance of the `ClamAvService` class. It takes two optional parameters: the host and port where your ClamAV daemon is running. By default, it assumes `127.0.0.1` and `3310`.
|
||||
@ -170,24 +90,11 @@ scanBufferExample();
|
||||
|
||||
### Error Handling and Debugging
|
||||
|
||||
Both `ClamAVManager` and `ClamAvService` provide comprehensive error handling:
|
||||
The methods of `ClamAvService` throw errors if there are issues with communication or processing data. Wrap your code in try-catch blocks and use appropriate logging to handle errors gracefully.
|
||||
|
||||
```typescript
|
||||
try {
|
||||
// Using ClamAVManager
|
||||
const manager = new ClamAVManager();
|
||||
await manager.startContainer();
|
||||
|
||||
// Listen for errors in logs
|
||||
manager.on('log', (event) => {
|
||||
if (event.type === 'error') {
|
||||
console.error(`ClamAV Error: ${event.message}`);
|
||||
}
|
||||
});
|
||||
|
||||
// Using ClamAvService
|
||||
const service = new ClamAvService();
|
||||
const scanResult = await service.scanString('Some suspicious string...');
|
||||
const scanResult = await clamService.scanString('Some suspicious string...');
|
||||
console.log(`Infection Status: ${scanResult.isInfected ? 'Infected' : 'Clean'}`);
|
||||
if (scanResult.isInfected) {
|
||||
console.log(`Reason: ${scanResult.reason}`);
|
||||
@ -209,71 +116,12 @@ The tests include creating and utilizing a `ClamAvService` instance and attempts
|
||||
|
||||
### Advanced Usage and Integration
|
||||
|
||||
#### Container Configuration
|
||||
|
||||
The `ClamAVManager` supports customizing the Docker container:
|
||||
|
||||
```typescript
|
||||
const manager = new ClamAVManager();
|
||||
|
||||
// Container properties are configurable
|
||||
console.log(manager.containerName); // 'clamav-daemon'
|
||||
console.log(manager.port); // 3310
|
||||
```
|
||||
|
||||
#### Log Management
|
||||
|
||||
Access and process ClamAV logs:
|
||||
|
||||
```typescript
|
||||
const manager = new ClamAVManager();
|
||||
|
||||
// Get all logs
|
||||
const logs = manager.getLogs();
|
||||
|
||||
// Filter logs by type
|
||||
const errorLogs = logs.filter(log => log.type === 'error');
|
||||
const updateLogs = logs.filter(log => log.type === 'update');
|
||||
```
|
||||
|
||||
#### Health Checks
|
||||
|
||||
Monitor ClamAV service health:
|
||||
|
||||
```typescript
|
||||
const manager = new ClamAVManager();
|
||||
|
||||
// Service automatically checks readiness during initialization
|
||||
await manager.startContainer(); // Includes readiness checks
|
||||
|
||||
// Get database status
|
||||
const dbInfo = await manager.getDatabaseInfo();
|
||||
console.log('Database Version:', dbInfo);
|
||||
```
|
||||
|
||||
You can build upon these functionalities to implement advanced use cases such as:
|
||||
- Automated virus scanning in CI/CD pipelines
|
||||
- Real-time file monitoring in web applications
|
||||
- Cloud-based malware detection services
|
||||
- Integration with security information and event management (SIEM) systems
|
||||
Beyond scanning strings and buffers, you can implement additional advanced use cases based on your specific application needs, such as integrating into web services or automating file scans in cloud environments. Consider building upon provided functionalities and adapting them to meet the requirements of your application architecture.
|
||||
|
||||
With the help of Node.js worker threads or external task queues like RabbitMQ, you can distribute scanning tasks efficiently within high-traffic environments.
|
||||
|
||||
## License and Legal Information
|
||||
### Conclusion
|
||||
|
||||
This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository.
|
||||
|
||||
**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
|
||||
|
||||
### Trademarks
|
||||
|
||||
This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
|
||||
|
||||
### Company Information
|
||||
|
||||
Task Venture Capital GmbH
|
||||
Registered at District court Bremen HRB 35230 HB, Germany
|
||||
|
||||
For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
|
||||
|
||||
By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
|
||||
`@push.rocks/smartantivirus` provides a simple yet effective way to incorporate antivirus checks into your Node.js applications, leveraging the robust ClamAV engine. With features like in-memory scanning and connection verification, you can seamlessly ensure your data security solutions are integrated into your application lifecycle.
|
||||
```
|
||||
undefined
|
||||
@ -1,90 +0,0 @@
|
||||
import { ClamAVManager } from '../../ts/classes.clamav.manager.js';
|
||||
import { execAsync } from '../../ts/plugins.js';
|
||||
|
||||
let clamManager: ClamAVManager | null = null;
|
||||
let isCleaningUp = false;
|
||||
|
||||
export async function getManager(): Promise<ClamAVManager> {
|
||||
if (!clamManager) {
|
||||
throw new Error('ClamAV manager not initialized');
|
||||
}
|
||||
return clamManager;
|
||||
}
|
||||
|
||||
export async function setupClamAV(): Promise<ClamAVManager> {
|
||||
console.log('[Helper] Setting up ClamAV...');
|
||||
|
||||
// First cleanup any existing containers
|
||||
await forceCleanupContainer();
|
||||
|
||||
if (!clamManager) {
|
||||
console.log('[Helper] Creating new ClamAV manager instance');
|
||||
clamManager = new ClamAVManager();
|
||||
await clamManager.startContainer();
|
||||
console.log('[Helper] ClamAV manager initialized');
|
||||
} else {
|
||||
console.log('[Helper] Using existing ClamAV manager instance');
|
||||
}
|
||||
|
||||
return clamManager;
|
||||
}
|
||||
|
||||
export async function cleanupClamAV(): Promise<void> {
|
||||
if (isCleaningUp) {
|
||||
console.log('[Helper] Cleanup already in progress, skipping');
|
||||
return;
|
||||
}
|
||||
|
||||
isCleaningUp = true;
|
||||
console.log('[Helper] Cleaning up ClamAV...');
|
||||
|
||||
try {
|
||||
if (clamManager) {
|
||||
await clamManager.stopContainer();
|
||||
console.log('[Helper] ClamAV container stopped');
|
||||
}
|
||||
await forceCleanupContainer();
|
||||
} catch (error) {
|
||||
console.error('[Helper] Error during cleanup:', error);
|
||||
throw error;
|
||||
} finally {
|
||||
clamManager = null;
|
||||
isCleaningUp = false;
|
||||
}
|
||||
}
|
||||
|
||||
async function forceCleanupContainer(): Promise<void> {
|
||||
try {
|
||||
// Stop any existing container
|
||||
await execAsync('docker stop clamav-daemon').catch(() => {});
|
||||
// Remove any existing container
|
||||
await execAsync('docker rm -f clamav-daemon').catch(() => {});
|
||||
console.log('[Helper] Forced cleanup of existing containers complete');
|
||||
} catch (error) {
|
||||
// Ignore errors as the container might not exist
|
||||
}
|
||||
}
|
||||
|
||||
// Handle interrupts
|
||||
process.on('SIGINT', async () => {
|
||||
console.log('\n[Helper] Received SIGINT. Cleaning up...');
|
||||
try {
|
||||
await cleanupClamAV();
|
||||
process.exit(0);
|
||||
} catch (err) {
|
||||
console.error('[Helper] Error during cleanup:', err);
|
||||
process.exit(1);
|
||||
}
|
||||
});
|
||||
|
||||
// Ensure cleanup on process exit
|
||||
process.on('exit', () => {
|
||||
if (clamManager && !isCleaningUp) {
|
||||
console.log('[Helper] Process exit detected, attempting cleanup');
|
||||
// We can't use async functions in exit handler, so we do our best
|
||||
try {
|
||||
execAsync('docker stop clamav-daemon').catch(() => {});
|
||||
execAsync('docker rm -f clamav-daemon').catch(() => {});
|
||||
} catch {}
|
||||
}
|
||||
});
|
||||
@ -1,73 +0,0 @@
|
||||
import { expect, tap } from '../ts/plugins.js';
|
||||
import type { ClamAVLogEvent } from '../ts/classes.clamav.manager.js';
|
||||
import { setupClamAV, cleanupClamAV, getManager } from './helpers/clamav.helper.js';
|
||||
|
||||
type ClamAVManager = Awaited<ReturnType<typeof setupClamAV>>;
|
||||
|
||||
let manager: ClamAVManager;
|
||||
|
||||
tap.test('setup', async () => {
|
||||
manager = await setupClamAV();
|
||||
expect(manager).toBeTruthy();
|
||||
});
|
||||
|
||||
tap.test('should have initialized container and receive logs', async () => {
|
||||
// Create a promise that resolves when we receive a log
|
||||
const logPromise = new Promise<void>((resolve) => {
|
||||
// First check if we already have logs
|
||||
const existingLogs = manager.getLogs();
|
||||
if (existingLogs.length > 0) {
|
||||
console.log('[Test] Found existing logs:', existingLogs.map(log => `${log.type}: ${log.message}`).join('\n'));
|
||||
resolve();
|
||||
return;
|
||||
}
|
||||
|
||||
// If no existing logs, wait for new ones
|
||||
const handler = (event: ClamAVLogEvent) => {
|
||||
console.log(`[Test] Received log event: ${event.type} - ${event.message}`);
|
||||
manager.removeListener('log', handler);
|
||||
resolve();
|
||||
};
|
||||
manager.on('log', handler);
|
||||
});
|
||||
|
||||
// Wait for logs with timeout
|
||||
const timeoutPromise = new Promise<void>((_, reject) => {
|
||||
setTimeout(() => reject(new Error('Timeout waiting for logs')), 30000);
|
||||
});
|
||||
|
||||
try {
|
||||
await Promise.race([logPromise, timeoutPromise]);
|
||||
} catch (error) {
|
||||
console.error('Error waiting for logs:', error);
|
||||
throw error;
|
||||
}
|
||||
|
||||
console.log('Log received check passed');
|
||||
|
||||
// Verify container is running by checking if we can get database info
|
||||
try {
|
||||
const dbInfo = await manager.getDatabaseInfo();
|
||||
expect(dbInfo).toBeTruthy();
|
||||
console.log('Database info check passed');
|
||||
} catch (error) {
|
||||
console.error('Error getting database info:', error);
|
||||
throw new Error('Failed to get database info - container may not be fully initialized');
|
||||
}
|
||||
});
|
||||
|
||||
tap.test('should get database info', async () => {
|
||||
const dbInfo = await manager.getDatabaseInfo();
|
||||
console.log('Database Info:', dbInfo);
|
||||
expect(dbInfo).toBeTruthy();
|
||||
});
|
||||
|
||||
tap.test('should update database', async () => {
|
||||
await manager.updateDatabase();
|
||||
});
|
||||
|
||||
tap.test('cleanup', async () => {
|
||||
await cleanupClamAV();
|
||||
});
|
||||
|
||||
tap.start();
|
||||
47
test/test.ts
47
test/test.ts
@ -1,40 +1,35 @@
|
||||
import { tap, expect } from '@push.rocks/tapbundle';
|
||||
import { expect, expectAsync, tap } from '@push.rocks/tapbundle';
|
||||
import * as smartantivirus from '../ts/index.js';
|
||||
import { setupClamAV, cleanupClamAV } from './helpers/clamav.helper.js';
|
||||
|
||||
const EICAR_TEST_STRING = 'X5O!P%@AP[4\\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*';
|
||||
let clamService: smartantivirus.ClamAvService;
|
||||
|
||||
tap.test('setup', async () => {
|
||||
await setupClamAV();
|
||||
});
|
||||
|
||||
tap.test('should create a ClamAvService instance and initialize ClamAV', async () => {
|
||||
tap.test('should create a ClamAvService instance', async () => {
|
||||
clamService = new smartantivirus.ClamAvService();
|
||||
expect(clamService).toBeTruthy();
|
||||
// The manager will start the container and wait for initialization
|
||||
await clamService.verifyConnection();
|
||||
expect(clamService).toBeDefined();
|
||||
});
|
||||
|
||||
tap.test('should detect EICAR test string', async () => {
|
||||
const scanResult = await clamService.scanString(EICAR_TEST_STRING);
|
||||
tap.test('should scan a string', async () => {
|
||||
const scanResult = await clamService.scanString('X5O!P%@AP[4\PZX54(P^)7CC)7}' + '$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*');
|
||||
console.log('Scan Result:', scanResult);
|
||||
expect(scanResult.isInfected).toEqual(true);
|
||||
expect(scanResult.reason).toBeTruthy();
|
||||
});
|
||||
|
||||
tap.test('should not detect clean string', async () => {
|
||||
const scanResult = await clamService.scanString('This is a clean string with no virus signature');
|
||||
console.log('Clean Scan Result:', scanResult);
|
||||
expect(scanResult.isInfected).toEqual(false);
|
||||
expect(scanResult.reason).toBeUndefined();
|
||||
});
|
||||
|
||||
tap.test('cleanup', async () => {
|
||||
await cleanupClamAV();
|
||||
// expect(scanResult).toEqual({ isInfected: true, reason: 'FOUND' });
|
||||
});
|
||||
|
||||
tap.start();
|
||||
|
||||
|
||||
/* (async () => {
|
||||
|
||||
try {
|
||||
|
||||
await clamService.updateVirusDefinitions(); // Step 2: Update definitions
|
||||
await clamService.startClamDaemon(); // Step 3: Start daemon
|
||||
|
||||
const scanResult = await clamService.scanString('EICAR test string...');
|
||||
console.log('Scan Result:', scanResult);
|
||||
} catch (error) {
|
||||
console.error('Error:', error);
|
||||
}
|
||||
})(); */
|
||||
|
||||
|
||||
|
||||
|
||||
@ -3,6 +3,6 @@
|
||||
*/
|
||||
export const commitinfo = {
|
||||
name: '@push.rocks/smartantivirus',
|
||||
version: '1.3.0',
|
||||
version: '1.0.2',
|
||||
description: 'A Node.js package for integrating antivirus scanning capabilities using ClamAV, allowing in-memory file and data scanning.'
|
||||
}
|
||||
|
||||
@ -1,281 +0,0 @@
|
||||
import { exec, spawn, net, promisify, EventEmitter, execAsync } from './plugins.js';
|
||||
|
||||
export interface ClamAVLogEvent {
|
||||
timestamp: string;
|
||||
message: string;
|
||||
type: 'update' | 'scan' | 'system' | 'error';
|
||||
}
|
||||
|
||||
export class ClamAVManager extends EventEmitter {
|
||||
private containerId: string | null = null;
|
||||
private containerName = 'clamav-daemon';
|
||||
private imageTag = 'clamav/clamav:latest';
|
||||
private port = 3310;
|
||||
private logs: ClamAVLogEvent[] = [];
|
||||
|
||||
constructor() {
|
||||
super();
|
||||
}
|
||||
|
||||
public getLogs(): ClamAVLogEvent[] {
|
||||
return this.logs;
|
||||
}
|
||||
|
||||
/**
|
||||
* Start the ClamAV container if it's not already running
|
||||
*/
|
||||
public async startContainer(): Promise<void> {
|
||||
try {
|
||||
console.log('[ClamAV] Starting container initialization...');
|
||||
|
||||
// Check if container is already running
|
||||
const { stdout: psOutput } = await execAsync('docker ps --filter name=' + this.containerName);
|
||||
if (psOutput.includes(this.containerName)) {
|
||||
console.log('[ClamAV] Container is already running');
|
||||
this.containerId = (await execAsync(`docker ps -q --filter name=${this.containerName}`)).stdout.trim();
|
||||
console.log('[ClamAV] Container ID:', this.containerId);
|
||||
this.attachLogWatcher();
|
||||
await this.waitForInitialization();
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if container exists but is stopped
|
||||
const { stdout: psaOutput } = await execAsync('docker ps -a --filter name=' + this.containerName);
|
||||
if (psaOutput.includes(this.containerName)) {
|
||||
console.log('[ClamAV] Found stopped container, starting it...');
|
||||
await execAsync(`docker start ${this.containerName}`);
|
||||
this.containerId = (await execAsync(`docker ps -q --filter name=${this.containerName}`)).stdout.trim();
|
||||
console.log('[ClamAV] Started existing container, ID:', this.containerId);
|
||||
} else {
|
||||
// Create and start new container
|
||||
console.log('[ClamAV] Creating new container...');
|
||||
const { stdout } = await execAsync(
|
||||
`docker run -d --name ${this.containerName} -p ${this.port}:3310 ${this.imageTag}`
|
||||
);
|
||||
this.containerId = stdout.trim();
|
||||
console.log('[ClamAV] Created new container, ID:', this.containerId);
|
||||
}
|
||||
|
||||
this.attachLogWatcher();
|
||||
console.log('[ClamAV] Waiting for initialization...');
|
||||
await this.waitForInitialization();
|
||||
console.log('[ClamAV] Container successfully initialized');
|
||||
} catch (error) {
|
||||
console.error('[ClamAV] Error starting container:', error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop the ClamAV container
|
||||
*/
|
||||
public async stopContainer(): Promise<void> {
|
||||
if (!this.containerId) {
|
||||
console.log('No ClamAV container is running');
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
await execAsync(`docker stop ${this.containerId}`);
|
||||
console.log('Stopped ClamAV container');
|
||||
} catch (error) {
|
||||
console.error('Error stopping ClamAV container:', error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Manually trigger a database update
|
||||
*/
|
||||
public async updateDatabase(): Promise<void> {
|
||||
if (!this.containerId) {
|
||||
throw new Error('ClamAV container is not running');
|
||||
}
|
||||
|
||||
try {
|
||||
// First check if freshclam is already running
|
||||
const { stdout: psOutput } = await execAsync(`docker exec ${this.containerId} ps aux | grep freshclam`);
|
||||
if (psOutput.includes('/usr/local/sbin/freshclam -d')) {
|
||||
console.log('Freshclam daemon is already running');
|
||||
// Wait a bit to ensure database is updated
|
||||
await new Promise(resolve => setTimeout(resolve, 2000));
|
||||
return;
|
||||
}
|
||||
|
||||
// If not running as daemon, try to update manually
|
||||
const { stdout, stderr } = await execAsync(`docker exec ${this.containerId} freshclam --no-warnings`);
|
||||
console.log('Database update output:', stdout);
|
||||
if (stderr) {
|
||||
console.error('Database update errors:', stderr);
|
||||
}
|
||||
} catch (error) {
|
||||
// Check if the error is due to freshclam already running
|
||||
if (error.stderr?.includes('ERROR: Problem with internal logger') ||
|
||||
error.stdout?.includes('Resource temporarily unavailable')) {
|
||||
console.log('Freshclam is already running, skipping manual update');
|
||||
return;
|
||||
}
|
||||
console.error('Error updating ClamAV database:', error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current database version information
|
||||
*/
|
||||
public async getDatabaseInfo(): Promise<string> {
|
||||
if (!this.containerId) {
|
||||
throw new Error('ClamAV container is not running');
|
||||
}
|
||||
|
||||
try {
|
||||
// Try both .cld and .cvd files since ClamAV can use either format
|
||||
try {
|
||||
const { stdout } = await execAsync(`docker exec ${this.containerId} sigtool --info /var/lib/clamav/daily.cld`);
|
||||
return stdout;
|
||||
} catch {
|
||||
const { stdout } = await execAsync(`docker exec ${this.containerId} sigtool --info /var/lib/clamav/daily.cvd`);
|
||||
return stdout;
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Error getting database info:', error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Watch container logs and emit events for different types of log messages
|
||||
*/
|
||||
private attachLogWatcher(): void {
|
||||
if (!this.containerId) return;
|
||||
|
||||
const logProcess = spawn('docker', ['logs', '-f', this.containerId]);
|
||||
|
||||
logProcess.stdout.on('data', (data) => {
|
||||
const lines = data.toString().split('\n');
|
||||
lines.forEach(line => {
|
||||
if (!line.trim()) return;
|
||||
|
||||
const event: ClamAVLogEvent = {
|
||||
timestamp: new Date().toISOString(),
|
||||
message: line,
|
||||
type: this.determineLogType(line)
|
||||
};
|
||||
|
||||
this.logs.push(event);
|
||||
this.emit('log', event);
|
||||
console.log(`[ClamAV ${event.type}] ${event.message}`);
|
||||
});
|
||||
});
|
||||
|
||||
logProcess.stderr.on('data', (data) => {
|
||||
const event: ClamAVLogEvent = {
|
||||
timestamp: new Date().toISOString(),
|
||||
message: data.toString(),
|
||||
type: 'error'
|
||||
};
|
||||
|
||||
this.logs.push(event);
|
||||
this.emit('log', event);
|
||||
console.error(`[ClamAV error] ${event.message}`);
|
||||
});
|
||||
|
||||
logProcess.on('error', (error) => {
|
||||
console.error('Error in log watcher:', error);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine the type of log message
|
||||
*/
|
||||
private determineLogType(logMessage: string): ClamAVLogEvent['type'] {
|
||||
const lowerMessage = logMessage.toLowerCase();
|
||||
if (lowerMessage.includes('update') || lowerMessage.includes('freshclam')) {
|
||||
return 'update';
|
||||
} else if (lowerMessage.includes('scan') || lowerMessage.includes('found')) {
|
||||
return 'scan';
|
||||
} else if (lowerMessage.includes('error') || lowerMessage.includes('warning')) {
|
||||
return 'error';
|
||||
}
|
||||
return 'system';
|
||||
}
|
||||
|
||||
/**
|
||||
* Wait for ClamAV to initialize by checking both logs and service readiness
|
||||
*/
|
||||
private async waitForInitialization(): Promise<void> {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (!this.containerId) {
|
||||
reject(new Error('Container ID not set'));
|
||||
return;
|
||||
}
|
||||
|
||||
let timeout: NodeJS.Timeout;
|
||||
let checkCount = 0;
|
||||
const maxChecks = 60; // Check for 60 seconds
|
||||
const startTime = Date.now();
|
||||
|
||||
// Check service readiness
|
||||
const checkService = async () => {
|
||||
try {
|
||||
const elapsedTime = Math.round((Date.now() - startTime) / 1000);
|
||||
console.log(`[ClamAV] Checking service readiness (attempt ${checkCount + 1}, ${elapsedTime}s elapsed)...`);
|
||||
|
||||
// First check if the service is accepting connections
|
||||
const client = new net.Socket();
|
||||
await new Promise<void>((resolveConn, rejectConn) => {
|
||||
const connectTimeout = setTimeout(() => {
|
||||
client.destroy();
|
||||
rejectConn(new Error('Connection timeout'));
|
||||
}, 1000);
|
||||
|
||||
client.connect(this.port, 'localhost', () => {
|
||||
clearTimeout(connectTimeout);
|
||||
client.end();
|
||||
resolveConn();
|
||||
});
|
||||
|
||||
client.on('error', (err) => {
|
||||
clearTimeout(connectTimeout);
|
||||
rejectConn(err);
|
||||
});
|
||||
});
|
||||
|
||||
// Verify the service is responding to commands
|
||||
const { stdout } = await execAsync(`echo PING | nc localhost ${this.port}`);
|
||||
if (!stdout.includes('PONG')) {
|
||||
throw new Error('Service not responding to commands');
|
||||
}
|
||||
|
||||
// If we can connect and get a PONG, the service is ready
|
||||
console.log('[ClamAV] Service is accepting connections and responding to commands');
|
||||
cleanup();
|
||||
resolve();
|
||||
} catch (error) {
|
||||
// Service not ready yet, will retry
|
||||
if (checkCount >= maxChecks) {
|
||||
cleanup();
|
||||
reject(new Error(`ClamAV initialization timed out after ${maxChecks} seconds. Last error: ${error.message}`));
|
||||
return;
|
||||
}
|
||||
checkCount++;
|
||||
}
|
||||
};
|
||||
|
||||
const cleanup = () => {
|
||||
clearTimeout(timeout);
|
||||
clearInterval(serviceCheck);
|
||||
};
|
||||
|
||||
const serviceCheck = setInterval(checkService, 1000);
|
||||
|
||||
timeout = setTimeout(() => {
|
||||
cleanup();
|
||||
reject(new Error('ClamAV initialization timed out after 60 seconds'));
|
||||
}, 60000);
|
||||
|
||||
// Start initial service check
|
||||
checkService();
|
||||
});
|
||||
}
|
||||
}
|
||||
@ -1,187 +0,0 @@
|
||||
import * as plugins from './plugins.js';
|
||||
import * as paths from './paths.js';
|
||||
import { net } from './plugins.js';
|
||||
import { ClamAVManager } from './classes.clamav.manager.js';
|
||||
|
||||
export class ClamAvService {
|
||||
private host: string;
|
||||
private port: number;
|
||||
private manager: ClamAVManager;
|
||||
|
||||
constructor(host: string = '127.0.0.1', port: number = 3310) {
|
||||
this.host = host;
|
||||
this.port = port;
|
||||
this.manager = new ClamAVManager();
|
||||
|
||||
// Listen to ClamAV logs
|
||||
this.manager.on('log', (event) => {
|
||||
if (event.type === 'scan') {
|
||||
console.log(`[ClamAV Scan] ${event.message}`);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private async ensureContainerStarted(): Promise<void> {
|
||||
await this.manager.startContainer();
|
||||
}
|
||||
|
||||
/**
|
||||
* Scans an in-memory Buffer using ClamAV daemon's INSTREAM command.
|
||||
*/
|
||||
public async scanBuffer(buffer: Buffer): Promise<{ isInfected: boolean; reason?: string }> {
|
||||
await this.ensureContainerStarted();
|
||||
return new Promise((resolve, reject) => {
|
||||
const client = new net.Socket();
|
||||
|
||||
client.connect(this.port, this.host, () => {
|
||||
console.log('Connected to ClamAV daemon');
|
||||
client.write('zINSTREAM\0'); // Start the INSTREAM command
|
||||
const chunkSize = 1024;
|
||||
let offset = 0;
|
||||
|
||||
// Send data in chunks
|
||||
while (offset < buffer.length) {
|
||||
const chunk = buffer.slice(offset, offset + chunkSize);
|
||||
console.log('Sending chunk:', chunk.toString('utf8'));
|
||||
|
||||
const sizeBuf = Buffer.alloc(4);
|
||||
sizeBuf.writeUInt32BE(chunk.length, 0);
|
||||
client.write(sizeBuf);
|
||||
client.write(chunk);
|
||||
|
||||
offset += chunkSize;
|
||||
}
|
||||
|
||||
// Send end-of-stream signal
|
||||
const endOfStream = Buffer.alloc(4);
|
||||
endOfStream.writeUInt32BE(0, 0);
|
||||
console.log('Sending end-of-stream signal');
|
||||
client.write(endOfStream);
|
||||
});
|
||||
|
||||
client.on('data', (data) => {
|
||||
const response = data.toString();
|
||||
console.log('Raw Response from ClamAV:', response);
|
||||
|
||||
const isInfected = response.includes('FOUND');
|
||||
const reason = isInfected ? response.split('FOUND')[0].trim() : undefined;
|
||||
|
||||
resolve({ isInfected, reason });
|
||||
client.end();
|
||||
});
|
||||
|
||||
client.on('error', (err) => {
|
||||
console.error('Error communicating with ClamAV:', err);
|
||||
reject(err);
|
||||
});
|
||||
|
||||
client.on('close', () => {
|
||||
console.log('Connection to ClamAV daemon closed');
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Scans a string by converting it to a Buffer and using scanBuffer.
|
||||
*/
|
||||
public async scanString(input: string): Promise<{ isInfected: boolean; reason?: string }> {
|
||||
console.log('Scanning string:', input); // Debug the input string
|
||||
const buffer = Buffer.from(input, 'utf8');
|
||||
console.log('Converted buffer:', buffer.toString('utf8')); // Debug the converted buffer
|
||||
return this.scanBuffer(buffer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Verifies the ClamAV daemon is reachable.
|
||||
*/
|
||||
public async verifyConnection(): Promise<boolean> {
|
||||
await this.ensureContainerStarted();
|
||||
return new Promise((resolve, reject) => {
|
||||
const client = new net.Socket();
|
||||
|
||||
client.connect(this.port, this.host, () => {
|
||||
console.log('Successfully connected to ClamAV daemon');
|
||||
client.end();
|
||||
resolve(true);
|
||||
});
|
||||
|
||||
client.on('error', (err) => {
|
||||
console.error('Failed to connect to ClamAV daemon:', err);
|
||||
reject(err);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Scans data from a NodeJS stream using ClamAV daemon's INSTREAM command.
|
||||
*/
|
||||
public async scanStream(stream: NodeJS.ReadableStream): Promise<{ isInfected: boolean; reason?: string }> {
|
||||
await this.ensureContainerStarted();
|
||||
return new Promise((resolve, reject) => {
|
||||
const client = new net.Socket();
|
||||
|
||||
client.connect(this.port, this.host, () => {
|
||||
console.log('Connected to ClamAV daemon for stream scanning');
|
||||
client.write('zINSTREAM\0');
|
||||
|
||||
stream.on('data', (chunk: Buffer) => {
|
||||
const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
|
||||
const sizeBuf = Buffer.alloc(4);
|
||||
sizeBuf.writeUInt32BE(buf.length, 0);
|
||||
client.write(sizeBuf);
|
||||
client.write(buf);
|
||||
});
|
||||
|
||||
stream.on('end', () => {
|
||||
const endOfStream = Buffer.alloc(4);
|
||||
endOfStream.writeUInt32BE(0, 0);
|
||||
console.log('Stream ended, sending end-of-stream signal');
|
||||
client.write(endOfStream);
|
||||
});
|
||||
|
||||
stream.on('error', (err) => {
|
||||
console.error('Error reading stream:', err);
|
||||
reject(err);
|
||||
});
|
||||
});
|
||||
|
||||
client.on('data', (data) => {
|
||||
const response = data.toString();
|
||||
console.log('Raw Response from ClamAV (stream):', response);
|
||||
const isInfected = response.includes('FOUND');
|
||||
const reason = isInfected ? response.split('FOUND')[0].trim() : undefined;
|
||||
resolve({ isInfected, reason });
|
||||
client.end();
|
||||
});
|
||||
|
||||
client.on('error', (err) => {
|
||||
console.error('Error with ClamAV stream scanning:', err);
|
||||
reject(err);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Scans a file from a web URL as a stream using ClamAV daemon's INSTREAM command.
|
||||
*/
|
||||
public async scanFileFromWebAsStream(url: string): Promise<{ isInfected: boolean; reason?: string }> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const protocol = url.startsWith('https') ? plugins.https : plugins.http;
|
||||
protocol.get(url, (response) => {
|
||||
this.scanStream(response).then(resolve).catch(reject);
|
||||
}).on('error', (err) => {
|
||||
console.error('Error fetching URL:', err);
|
||||
reject(err);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Scans a web resource by URL using ClamAV daemon's INSTREAM command.
|
||||
*/
|
||||
public async scanWebStream(webstreamArg: ReadableStream): Promise<{ isInfected: boolean; reason?: string }> {
|
||||
// Convert the web ReadableStream to a NodeJS ReadableStream
|
||||
const nodeStream = plugins.smartstream.nodewebhelpers.convertWebReadableToNodeReadable(webstreamArg);
|
||||
return this.scanStream(nodeStream);
|
||||
}
|
||||
}
|
||||
103
ts/classes.smartantivirus.ts
Normal file
103
ts/classes.smartantivirus.ts
Normal file
@ -0,0 +1,103 @@
|
||||
import * as plugins from './plugins.js';
|
||||
import * as paths from './paths.js';
|
||||
|
||||
import { exec } from 'child_process';
|
||||
import net from 'net';
|
||||
import { promisify } from 'util';
|
||||
|
||||
const execAsync = promisify(exec);
|
||||
|
||||
export class ClamAvService {
|
||||
private host: string;
|
||||
private port: number;
|
||||
|
||||
constructor(host: string = '127.0.0.1', port: number = 3310) {
|
||||
this.host = host;
|
||||
this.port = port;
|
||||
}
|
||||
|
||||
/**
|
||||
* Scans an in-memory Buffer using ClamAV daemon's INSTREAM command.
|
||||
*/
|
||||
public async scanBuffer(buffer: Buffer): Promise<{ isInfected: boolean; reason?: string }> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const client = new net.Socket();
|
||||
|
||||
client.connect(this.port, this.host, () => {
|
||||
console.log('Connected to ClamAV daemon');
|
||||
client.write('zINSTREAM\0'); // Start the INSTREAM command
|
||||
const chunkSize = 1024;
|
||||
let offset = 0;
|
||||
|
||||
// Send data in chunks
|
||||
while (offset < buffer.length) {
|
||||
const chunk = buffer.slice(offset, offset + chunkSize);
|
||||
console.log('Sending chunk:', chunk.toString('utf8'));
|
||||
|
||||
const sizeBuf = Buffer.alloc(4);
|
||||
sizeBuf.writeUInt32BE(chunk.length, 0);
|
||||
client.write(sizeBuf);
|
||||
client.write(chunk);
|
||||
|
||||
offset += chunkSize;
|
||||
}
|
||||
|
||||
// Send end-of-stream signal
|
||||
const endOfStream = Buffer.alloc(4);
|
||||
endOfStream.writeUInt32BE(0, 0);
|
||||
console.log('Sending end-of-stream signal');
|
||||
client.write(endOfStream);
|
||||
});
|
||||
|
||||
client.on('data', (data) => {
|
||||
const response = data.toString();
|
||||
console.log('Raw Response from ClamAV:', response);
|
||||
|
||||
const isInfected = response.includes('FOUND');
|
||||
const reason = isInfected ? response.split('FOUND')[0].trim() : undefined;
|
||||
|
||||
resolve({ isInfected, reason });
|
||||
client.end();
|
||||
});
|
||||
|
||||
client.on('error', (err) => {
|
||||
console.error('Error communicating with ClamAV:', err);
|
||||
reject(err);
|
||||
});
|
||||
|
||||
client.on('close', () => {
|
||||
console.log('Connection to ClamAV daemon closed');
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Scans a string by converting it to a Buffer and using scanBuffer.
|
||||
*/
|
||||
public async scanString(input: string): Promise<{ isInfected: boolean; reason?: string }> {
|
||||
console.log('Scanning string:', input); // Debug the input string
|
||||
const buffer = Buffer.from(input, 'utf8');
|
||||
console.log('Converted buffer:', buffer.toString('utf8')); // Debug the converted buffer
|
||||
return this.scanBuffer(buffer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Verifies the ClamAV daemon is reachable.
|
||||
*/
|
||||
public async verifyConnection(): Promise<boolean> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const client = new net.Socket();
|
||||
|
||||
client.connect(this.port, this.host, () => {
|
||||
console.log('Successfully connected to ClamAV daemon');
|
||||
client.end();
|
||||
resolve(true);
|
||||
});
|
||||
|
||||
client.on('error', (err) => {
|
||||
console.error('Failed to connect to ClamAV daemon:', err);
|
||||
reject(err);
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
@ -1,2 +1 @@
|
||||
export * from './classes.clamavservice.js';
|
||||
export * from './classes.clamav.manager.js';
|
||||
export * from './classes.smartantivirus.js';
|
||||
@ -1,42 +1,24 @@
|
||||
// Node.js built-in modules
|
||||
// node native scope
|
||||
import * as fs from 'fs';
|
||||
import * as path from 'path';
|
||||
import { exec, spawn } from 'child_process';
|
||||
import { promisify } from 'util';
|
||||
import { EventEmitter } from 'events';
|
||||
import net from 'net';
|
||||
import * as http from 'http';
|
||||
import * as https from 'https';
|
||||
|
||||
export {
|
||||
fs,
|
||||
path,
|
||||
exec,
|
||||
spawn,
|
||||
promisify,
|
||||
EventEmitter,
|
||||
net,
|
||||
http,
|
||||
https
|
||||
};
|
||||
}
|
||||
|
||||
// @push.rocks scope
|
||||
import * as smartpath from '@push.rocks/smartpath';
|
||||
import * as smartfile from '@push.rocks/smartfile';
|
||||
import * as smartstream from '@push.rocks/smartstream';
|
||||
|
||||
export {
|
||||
smartpath,
|
||||
smartfile,
|
||||
smartstream,
|
||||
};
|
||||
}
|
||||
|
||||
// Third party scope
|
||||
// third party scope
|
||||
import axios from 'axios';
|
||||
|
||||
export {
|
||||
axios
|
||||
};
|
||||
|
||||
// Common utilities
|
||||
export const execAsync = promisify(exec);
|
||||
axios,
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user