-o, --output <FILE>
        Sets output file name [default: ABDULRHMAN-PC.zip]

-l, --log-level <LEVEL>
        Sets the log level [default: info] [possible values: trace, debug, info, error]

-f, --log-file <FILE>
        Sets the log file name [default: fennec.log]

-u, --upload-artifact <CONFIG>...
        Upload configuration string. Supported Protocols:
        * s3 : Upload artifact package to S3 bucket (ex. minio)
            * Format :
        s3://<ACCESS_KEY>:<SECRET_ACCESS_KEY>@(http|https)://<HOSTNAME>:<PORT>/<BUCKET_NAME>:<PATH>
            * Example (minio): s3://minioadmin:minioadmin@http://192.168.100.190:9000/fennec:/
        * aws3 : Upload artifact package to AWS S3 bucket
            * Format : aws3://<ACCESS_KEY>:<SECRET_ACCESS_KEY>@<AWS_REGOIN>.<BUCKET_NAME>:<PATH>
            * Example: aws3://AKIAXXX:[email protected]:/
        * scp : Upload artifact package to a server using SCP protocol
            * Format : scp://<USERNAME>:<PASSWORD>@<HOSTNAME>:<PORT>:<PATH>
            * Example: scp://testusername:[email protected]:22:/dev/shm

-q, --quiet
        Do not print logs to stdout

-t, --timeout <SEC>
        Sets osquery queries timeout in seconds [default: 60]

-h, --help
        Print help information

    --non-root
        Run Fennec with non root permisions. This isn't recommended, most artifacts require root
        permissions

    --osquery-path <PATH>
        Sets osquery path, if osquery is embedded it will be writen to this path otherwise the
        path will be used to spawn osquery instance (Embedded : true) [default: ./osqueryd]

    --output-format <FORMAT>
        Sets output format [default: jsonl] [possible values: jsonl, csv, kjson]

    --show-config
        Show the embedded configuration file

    --show-embedded
        Show the embedded files metadata

-V, --version
        Print version information

* `-c`, `--config` : Usa il file di configurazione specificato invece della configurazione incorporata
* `-f`, `--log-file` : Cambia il nome predefinito per il file di log (predefinito: `fennec.log`)
* `-h`, `--help` : Stampa il messaggio di aiuto
* `-l`, `--log-level` : Cambia il livello di log predefinito (predefinito: `info`)
* `-o`, `--output` : Cambia il nome del file di output predefinito per il file zip (predefinito: `{HOSTNAME}.zip`, dove hostname è l'hostname della macchina valutato a runtime)
* `--osquery-path` : Percorso dell'eseguibile osquery. Questo valore verrà utilizzato in base alle seguenti condizioni:
  * Se il binario osquery è incorporato in `fennec`, verrà estratto e salvato in `--osquery-path`
  * Se osquery non è incorporato in `fennec`, verrà utilizzato il binario osquery presente nel percorso `--osquery-path`
* `--output-format` : Scegli il formato di output. Formati supportati:
  * jsonl : Oggetti JSON separati da nuova riga (predefinito)
  * csv: Valori separati da virgola
  * kjson: Usa questo formato se vuoi caricare il file risultante sulla piattaforma di analisi [Kuiper](https://github.com/DFIRKuiper/Kuiper).
* `-q`, `--quiet` : Non stampare i log su `stdout`
* `--non-root`: Esegui Fennec con permessi non root. Di default, Fennec richiede permessi `root` e uscirà con un messaggio di errore se non è root.
* `--show-config` : Stampa la configurazione incorporata e poi esci
* `--show-embedded` : Mostra i file incorporati
* `-t`, `--timeout` : Imposta il timeout in secondi per ogni osquery nei tipi di artefatto query
* `-u`, `--upload-artifact` : Carica il pacchetto artefatto su un server remoto. Protocolli supportati:
  * `s3` : Carica il pacchetto artefatto nel bucket S3
    * `Formato` : s3://<ACCESS_KEY>:<SECRET_ACCESS_KEY>@(http|https)://<HOSTNAME>:<PORT>/<BUCKET_NAME>:<PATH>
    * `Esempio`: s3://minioadmin:minioadmin@http://192.168.100.190:9000/fennec:/
  * `aws3` : Carica il pacchetto artefatto nel bucket AWS S3
    * `Formato` : aws3://<ACCESS_KEY>:<SECRET_ACCESS_KEY>@<AWS_REGOIN>.<BUCKET_NAME>:<PATH>
    * `Esempio`: aws3://AKIAXXXXXXXXXXXXXXXXX:[email protected]:/
  * `scp` : Carica il pacchetto artefatto su un server utilizzando il protocollo SCP
      * `Formato` : scp://`<USERNAME>`:`<PASSWORD>`@`<HOSTNAME>`:`<PORT>`:`<PATH>`
      * `Esempio`: scp://testusername:[email protected]:22:/dev/shm
* `-V`, `--version` : Stampa la versione di `fennec` ed esci

## Compila con le dipendenze 👨‍💻

fennec dipende da `osquery` per eseguire gli artefatti con il tipo `query`. La directory chiamata `deps` contiene il file che verrà incorporato nel binario a seconda del sistema operativo e dell'architettura di destinazione. Prima di compilare, segui i passaggi seguenti:

* Modifica il file di configurazione `deps/<TARGET_OS>/fennec.yaml` secondo necessità

* Compila il binario usando uno dei comandi seguenti:

  * collegato dinamicamente:  ```bash
  cargo build --release

o aggiungi quanto segue alla sezione `args` nella configurazione:```yaml
args:
  - "--output-format"
  - "kjson"

quindi carica il file zip risultante su Kuiper, ecco un esempio:

![kuiper_example](https://assets.kitploit.com/production/public/readmes/5116/8dd59147b5c77e04c01a7cd6d577c977a8f0ebf07053c0502ddeca5172f1a532.gif)

## Configuration🔨

Per impostazione predefinita, la configurazione nel percorso `deps/<TARGET_OS>/fennec.yaml` viene incorporata nell'eseguibile durante la compilazione. La configurazione è in formato YAML e ha due sezioni:

### Args

contiene un elenco di argomenti da passare all'eseguibile come argomenti della riga di comando, di seguito è riportato un esempio per la sezione `args` che imposterà il formato di output su `jsonl` e il nome del file di log su `fennec.log`:```yaml
args:
- "--output-format"
- "jsonl"
- "--log-file"
- "fennec.log"
...

#### Tipi di artefatto: Raccolta

Questo tipo di artefatto raccoglie file/cartelle specificati nel campo **paths**. Il seguente è un esempio di questo tipo di artefatto che raccoglie log di sistema:```yaml
artifacts:
  - name: logs
    type: collection
    description: "Collect system logs"
    paths:
      - '/var/log/**/*'
...

Questo tipo di artefatto eseguirà i comandi nella lista `commands` e analizzerà l'output `stdout` utilizzando l'espressione regolare specificata nel campo `regex`. Nota che l'espressione regolare verrà applicata solo al flusso `stdout` e non a `stderr`. Inoltre, il campo `regex` è opzionale. Ecco un esempio dei risultati sia utilizzando il campo `regex` che senza di esso:
##### Senza campo `regex````json
{
  "line": 0,
  "stdout": "root     pts/1                         2023-09-12T17:13:28+03:00 - 2023-09-12T17:13:28+03:00  (00:00)"
}

#### Tipi di Artefatto: Parse

Questo tipo di artefatto offre la capacità di analizzare file di testo utilizzando regex e restituire i dati in formato strutturato. L'esempio seguente analizza i log di accesso di nginx e restituisce i risultati in formato strutturato:```yaml
artifcats:
  - name: nginx_access
    type: parse
    description: "Nginx access logs"
    paths:
      - /var/log/nginx/access.*
    regex: '(?P<c_ip>[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}) - (?P<remote_user>[^ ]+) \[(?P<time>[0-9]{2}/[a-zA-Z]{3}/[0-9]{4}:[0-9]{2}:[0-9]{2}:[0-9]{2} \+[0-9]{4})\] "(?P<method>[A-Z]+)?[ ]?(?P<uri>.*?)[ ]?(HTTP/(?P<http_prot>[0-9\.]+))?" (?P<status_code>[0-9]{3}) (?P<body_bytes_sent>[0-9]+) "(?P<referer>.*?)" "(?P<user_agent>.*?)"'

* record analizzato  ```json
{
  "c_ip": "192.168.133.70",
  "remote_user": "-",
  "time": "23/Jan/2022:19:14:37 +0000",
  "method": "GET",
  "uri": "/blog/",
  "http_prot": "1.1",
  "status_code": "200",
  "body_bytes_sent": "2497",
  "referer": "https://u0041.co/",
  "user_agent": "Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0",
  "full_path": "/var/log/nginx/access.log.9.gz"
}

* record originale```verilog
192.168.133.70 - - [23/Jan/2022:19:14:37 +0000] "GET /blog/ HTTP/1.1" 200 2497 "https://u0041.co/" "Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0"

Per cambiare il nome del campo `time` in `@timestamp` aggiungiamo la seguente configurazione maps alle configurazioni degli artifact:```yaml
artifcats:
  - name: nginx_access
    type: parse
    description: "Nginx access logs"
    paths:
      - /var/log/nginx/access.*
    regex: '(?P<c_ip>[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}) - (?P<remote_user>[^ ]+) \[(?P<time>[0-9]{2}/[a-zA-Z]{3}/[0-9]{4}:[0-9]{2}:[0-9]{2}:[0-9]{2} \+[0-9]{4})\] "(?P<method>[A-Z]+)?[ ]?(?P<uri>.*?)[ ]?(HTTP/(?P<http_prot>[0-9\.]+))?" (?P<status_code>[0-9]{3}) (?P<body_bytes_sent>[0-9]+) "(?P<referer>.*?)" "(?P<user_agent>.*?)"'
    maps:
    - from: time		#change field name from
      to: '@timestamp'	# to this name

#### Modificatori

`modifiers` fornisce l'elaborazione successiva sul valore del campo dei risultati dell'artefatto. Ad esempio, per riformattare data e ora. Continuando con l'esempio precedente, possiamo cambiare il formato di data e ora nel campo `@timestamp` nel formato `%Y-%m-%d %H:%M:%S`. Possiamo aggiungere quanto segue alle configurazioni dell'artefatto per ottenere questo risultato:```yaml
artifacts:
  - name: nginx_access
    type: parse
    description: "Nginx access logs"
    paths:
      - /var/log/nginx/access.*
    regex: '(?P<c_ip>[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}) - (?P<remote_user>[^ ]+) \[(?P<time>[0-9]{2}/[a-zA-Z]{3}/[0-9]{4}:[0-9]{2}:[0-9]{2}:[0-9]{2} \+[0-9]{4})\] "(?P<method>[A-Z]+)?[ ]?(?P<uri>.*?)[ ]?(HTTP/(?P<http_prot>[0-9\.]+))?" (?P<status_code>[0-9]{3}) (?P<body_bytes_sent>[0-9]+) "(?P<referer>.*?)" "(?P<user_agent>.*?)"'
    maps:
    - from: time
      to: "@timestamp"
      modifier: 
        name: datetime_to_iso
        parameters:
          input_time_format: '%d/%b/%Y:%H:%M:%S %z'
          output_time_format: '%Y-%m-%d %H:%M:%S'

I modificatori disponibili sono:

| Nome                     | Dettagli                                                      | input_time_format                      | output_time_format                                           |
| ------------------------ | ------------------------------------------------------------ | -------------------------------------- | ------------------------------------------------------------ |
| epoch_to_iso             | Converte timestamp epoch in formato data e ora personalizzato      | N/A                                    | specifica il formato di data e ora di output, default è `%Y-%m-%d %H:%M:%S` |
| datetime_to_iso          | Riformatta data e ora dal formato `input_time_format` al formato `output_time_format` | specifica il formato di data e ora di input | specifica il formato di data e ora di output, default è `%Y-%m-%d %H:%M:%S` |
| time_without_year_to_iso | Formatta data e ora senza anno dal formato `input_time_format` al formato `output_time_format` | specifica il formato di data e ora di input | specifica il formato di data e ora di output, default è `%Y-%m-%d %H:%M:%S` |
| to_int | Converte dati stringa (come i tipi di artefatto `command` e `parse`) in interi (`i64`, cioè intero a 64 bit con segno). Utile per campi come la dimensione del file per poter fare controlli come `size < 1024` usando la piattaforma dati di nostra scelta | N/A | N/A |

Il modificatore `time_without_year_to_iso` funziona come segue:

* Aggiunge l'anno corrente, poi verifica se il tempo del parser è < tempo corrente; se lo è, allora è il tempo corretto
* altrimenti è l'anno precedente

Questo modificatore assume che i log siano per **UN SOLO** anno, usalo con cautela