Damn Vulnerable Web Application

Mi sto leggendo avanza tempo il libro HackLog  Manuale di Sicurezza Informatica ed Hacking Etico di Stefano Novelli. Nel libro viene  DVWA - Damn Vulnerable Web Application, una applicazione web studiata appositamente per fare pratica con le vulnerabilita' principalmente di webserver

Si puo' ottenere la DVWA da questo link in formato iso o docker. Ho scelto la ISO ma ho scoperto su Debian Testing VirtualBox non ne vuole sapere di installarsi....sono passato a QEmu

qemu-system-x86_64 -cdrom  DVWA-1.0.7.iso -m 2G -enable-kvm -net user,hostfwd=tcp::8080-:80 -net nic

a questo punto basta puntare il browser su  http://localhost:8080/login.php con credenziali admin/password

Di esempi ce ne sono tanti ma molto semplici ad impegnativi.

QTCustomPlot da dati CSV

Un progettino semplice per graficare dati derivanti da un file CSV (si tratta di un progetto satellite di un progetto Android con cui, tramite applicazione, vengono salvati i dati di accelerazione)

Come libreria per plottare i dati ho usato QTCustomPlot per la semplicita' di zoom/pan mentre per la lettura di CSV e' stata impiegata QtCSV

Il codice e' disponibile su GitHub. E' possibile zoom/pan ed avere le coordinate del puntatore

Per impostare QTCustomPlot su QtCreator si devono imporate i file qtcustomplot.cpp/ qtcustomplot.h, si aggiunge al file .pro  QT += printsupport, si trascina sul form un QWidget, tasto destro Promote To e si fa il promote a QtCustomPlot (il metodo e' cambiato rispetto al precedente post https://debiaonoldcomputers.blogspot.com/2013/11/software-per-progetto-force-gauge.html)

======================================================
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "qcustomplot.h"

#include "variantdata.h"
#include "reader.h"

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    QString filePath = "/home/luca/ss/7.csv";

    QList<QStringList> readData = QtCSV::Reader::readToList(filePath,";");

    QVector<double> x(readData.size()), y(readData.size());

    //l.resize(readData.size());

  for ( int i = 0; i < readData.size(); ++i )
  {
      x[i] = readData.at(i).value(1).toDouble()-1587149254484;
      y[i] = readData.at(i).value(2).toDouble();

  }
   //Abilita Drag e Zoom
    ui->customPlot->setInteraction(QCP::iRangeDrag,true);
    ui->customPlot->setInteraction(QCP::iRangeZoom,true);


    ui->customPlot->addGraph();
    ui->customPlot->graph(0)->setData(x,y);
    ui->customPlot->graph(0)->setBrush(QBrush(QColor(0, 0, 255, 20)));
    ui->customPlot->graph(0)->setPen(QPen(Qt::blue));
    connect(ui->customPlot,SIGNAL(mousePress(QMouseEvent *)),SLOT (clickedGraph(QMouseEvent*)));
    connect(ui->customPlot,SIGNAL(mouseMove(QMouseEvent *)),SLOT (MouseGraph(QMouseEvent*)));

    ui->customPlot->addGraph();

    ui->customPlot->xAxis->setLabel("Time");
    ui->customPlot->yAxis->setLabel("Acc");

    //double x_min = *std::min_element(x.constBegin(), x.constEnd());
    //double x_max = *std::max_element(x.constBegin(), x.constEnd());
    //double y_min = *std::min_element(y.constBegin(), y.constEnd());
    //double y_max = *std::max_element(y.constBegin(), y.constEnd());
    //ui->customPlot->xAxis->setRange(x_min, x_max);
    //ui->customPlot->yAxis->setRange(y_min, y_max);

    ui->customPlot->rescaleAxes();
    ui->customPlot->replot();
    //qDebug() << ui->customPlot->xAxis->pixelToCoord(mouseEvent->pos().x()) << ui->customPlot->yAxis->pixelToCoord(mouseEvent->pos().y());
}

void MainWindow::clickedGraph(QMouseEvent *event)
{
    QPoint point = event->pos();
    qDebug() << ui->customPlot->xAxis->pixelToCoord(point.x());
    qDebug() << ui->customPlot->yAxis->pixelToCoord(point.y());

}

void MainWindow::MouseGraph(QMouseEvent *event)
{
    QPoint point = event->pos();
    qDebug() << ui->customPlot->xAxis->pixelToCoord(point.x());
    qDebug() << ui->customPlot->yAxis->pixelToCoord(point.y());

    QVariant xi = ui->customPlot->xAxis->pixelToCoord(point.x());
    QVariant yi = ui->customPlot->yAxis->pixelToCoord(point.y());

    ui->xmouse->setText(xi.toString());
    ui->ymouse->setText(yi.toString());


}


MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::on_horizontalSlider_valueChanged(int value)
{
}

Millenium Falcon

Passatempo da quarantena....comprato due anni fa ma mai avuto il tempo nemmeno di iniziarlo

Da Arduino ad Internet tramite Android

Avevo la necessita' di collegare una Arduino Nano 33 BLE ad internet ma non avevo molte idee quando ho pensato di usare come ponte un telefono Android

La Arduino e' contenuta nella scatolina bianca 

Per leggere i dati della porta seriale di Arduino ho collegato un cavo OTG alla USB di Android usando la libreria https://github.com/felHR85/UsbSerial. I dati poi sono stati inviati in HTTP Get tramite OKHttp. Il progetto della applicazione Android si trova sul mio GitHub https://github.com/c1p81/Seriale (si tratta di una modifica dell'esempio della libreria UsbSerial)

Questo e' invece lo skecth Arduino

=========================================================
#include <Arduino_LSM9DS1.h>
#include <Arduino_HTS221.h>
#include <Arduino_LPS22HB.h>
#include <Arduino_APDS9960.h>

int conteggio;

void setup() {
  conteggio = 0;
  Serial.begin(9600);
  while (!Serial);

  if (!IMU.begin()) {
    Serial.println("Failed to initialize IMU!");
    while (1);
  }

  if (!HTS.begin()) {
    Serial.println("Failed to initialize humidity temperature sensor!");
    while (1);
  }

  
  if (!BARO.begin()) {
    Serial.println("Failed to initialize pressure sensor!");
    while (1);
  }

   if (!APDS.begin()) {
    Serial.println("Error initializing APDS9960 sensor.");
  }

}

void loop() {
  float  x, y, z;
  double dx,dy,dz;
  double mx,my,mz;
  double fx,fy,fz;
  double pitch,roll = 0.0;
  double mpitch,mroll = 0.0;
  const float alpha = 0.5;

  float pressure = BARO.readPressure();
  float temperature = HTS.readTemperature();
  float humidity    = HTS.readHumidity();

   while (! APDS.colorAvailable()) {
    delay(5);
  }
  int r, g, b, light_int;

  APDS.readColor(r, g, b, light_int);

  

  if (IMU.accelerationAvailable()) {
    IMU.readAcceleration(x, y, z);
    dx = (double)x;
    dy = (double)y;
    dz = (double)z;
    
    mx = mx + dx;
    my = mx + dy;
    mz = mx + dz;
    
    fx = (dx*alpha) + (fx*(1-alpha));
    fy = (dy*alpha) + (fy*(1-alpha));
    fz = (dz*alpha) + (fz*(1-alpha));

    conteggio++;
  }

  if (conteggio > 10000)
      {
        mx = mx /conteggio;
        my = my /conteggio;        
        mz = mz /conteggio;
        
        roll = atan2(fy,fz)*57.29577;
        pitch = atan2(-fx,sqrt((fy*fy)+(fz*fz)))*57.29577;

        mroll = atan2(my,mz)*57.29577;
        mpitch = atan2(-mx,sqrt((my*my)+(mz*mz)))*57.29577;

        Serial.println(String(mpitch)+";"+String(mroll)+";"+String(pitch)+";"+String(roll)+";"+String(temperature)+";"+String(humidity)+";"+String(pressure)+";"+String(light_int));
        conteggio = 0;
        fx = fy = fz = 0;
        mx = my = mz = 0;
      
      }

  
  delay(10);
  //delay(5000);
}

=========================================================

I dati sono plottati sul server mediante JSCanvas. Gli script si trovano qui https://github.com/c1p81/Seriale/tree/master/app/seriale_html

Trasmissione dati con ultrasuoni

Leggendo le caratteristiche di Arduino Nano 33 BLE ho scoperto che era compatibile con la trasmissione dati via ultrasuoni tramite le librerie CHIRP. La ditta pero' e' stata acquisita da Sonos e non e' piu' possibile usare le librerie per l'impossibilita' di acquisire la API KEY.

Ho scoperto che si puo' fare qualche test anche con un semplice browser (meglio Chrome) usando le librerie Quiet JS puntando a questa pagina https://quiet.github.io/quiet-js/

La cosa divertente e' che mio figlio di 10 anni sente distintamente la frequenza agli ultrasuoni mentre io no (questa predisposizione dei bambini a sentire gli ultrasuoni l'ho vista usare da un prestigiatore per un trucco magico che prevedeva la collaborazione del figlio..... in pratica il figlio indovinava sempre la carta nascosta ma solo perche' il padre con emettitore indicava il valore della carta con un codice condiviso)

QML Mandelbrot in UBPorts / Ubuntu Touch (2)

Avevo gia' provato qui a creare l'insieme di Mandelbrot su UBPorts in QML ma il programma era scandalosamente lento ed ho provato a migliorare

In questo codice il risultato di calcolo per ogni pixel viene salvato in un array imgData che poi 

trasferito in un colpo sul Canvas. In questo modo il tempo di calcolo e' divenuto inferiore ad un terzo di quello della precedente prova

==============================================================
/*
 * Copyright (C) 2020  Luca Innocenit
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 3.
 *
 * ubuntu-calculator-app is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

import QtQuick 2.7
import Ubuntu.Components 1.3
//import QtQuick.Controls 2.2
import QtQuick.Layouts 1.3
import Qt.labs.settings 1.0
import QtQuick.Window 2.2

MainView {
    id: root
    objectName: 'mainView'
    applicationName: 'qtcpp.com.luca.innocenti'
    automaticOrientation: true

    visible: true
      width: Screen.width
      height: Screen.width
      Canvas {
          id: mycanvas
          anchors.centerIn: parent
          width: Screen.width
          height: Screen.width
          onPaint: {
              console.log("width "+ width.toString())
              console.log("height "+ height.toString())

              var ctx = getContext("2d");
              ctx.fillStyle = Qt.rgba(0, 0, 0, 1);
              ctx.fillRect(0, 0, width, height);
              var imgData = ctx.createImageData(height, width);

              ////////
              var re_min = -2.0;
             var im_min = -1.2;
             var re_max = 0.7;
             var im_max = 1.2;
             var iterazioni = 50;

             var r;
             var a,b;
             var x,y,x_new,y_new;
             var test;
             var re_factor = (re_max-re_min);
             var im_factor = (im_max-im_min);
             var indice = 0;

              for (var i=0;i<width;i++)
                          {
                          for (var j=0;j<height;j++)
                           {
                               a = re_min+(j*re_factor/height);
                               b = im_min+(i*im_factor/width);
                               x = 0;
                               y = 0;
                               test = 0;
                              imgData.data[indice+3]= 255;
                              //console.log(indice)

                               for (var k=0;k<iterazioni;k++)
                                    {
                                    x_new = (x*x)-(y*y)+a;
                                    y_new = (2*x*y)+b;
                                    if (((x_new*x_new)+(y_new*y_new))>4)
                                          {
                                            if (k%2)
                                                {
                                                  // colora il punto
                                                  imgData.data[indice]=255;
                                                  imgData.data[indice+1]=255;
                                                  imgData.data[indice+2]=255;  
                                                }

                                            break;
                                          }
                                    x = x_new;
                                    y = y_new;
                                    }
                               indice = indice + 4;
                           }
              }
              ///////
              console.log("terminato")
              ctx.drawImage(imgData, 0, 0);

          }
      }
}

Alpine su Getac M230

Volevo ridare vita a questo GETAC M230, una macchina con un core duo. Il problema e' che questa macchina non ha una porta ethernet (c'e' una scheda di rete per fibra ottica) e non volevo impazzire a caricare i driver da USB della WiFi in fase di installazione come accade per Debian

Ho provato prima una LUbuntu che oggettivamente ha reso la macchina inservibile. Sono passato quindi ad Alpine Linux i386 che ha riconosciuto la scheda WiFi al volo

Avevo gia' configurato una Alpine 

apk add wireless-tools wpa_supplicant

Ingresso fibra ottica

apk add wireless-tools wpa_supplicant

Uno dei problemi e' che al riavvio non viene agganciato l'accesso point al boot.
Ogni volta devo rilanciare questi comandi per ottenre la connessione di rete

wpa_supplicant -B -i wlan0 -c /etc/wpa_supplicant_wpa_supplicant.conf
udhcpc -i wlan0


Per montare i3 window manager si devono aggiungere i pacchetti

apk add i3wm
apk add i3lock i3status
apk add xterm

e si edita il file  .xinitrc
==========================
DEFAULT=13
[ -n $1 ]  && 1
exec ${DEFAULT}
==========================
I3 funziona al meglio in modalita' tabbed

Per avere il controllo della batteria si deve aggiungere il supporto ACPI

apk add acpi

Firefox si installa e funziona ma freeza spesso
Non e' presente Emacs per X, c'e' solo per la consolle in quanto il sistema e' basato su uclib e non glibc. In compenso c'e' una vetusta versione di Qt/ Qt Creator


Per spengere la macchina si deve digitare

poweroff