Quando ho iniziato a riscrivere la versione 2.0 di dawnscanner, ho pensato di introdurre un meccanismo che mi consentisse di mandare dei dati telemetrici sull’utilizzo del tool.

L’idea non era tanto quella di avere il dettaglio di cosa stesse scansionando l’utente, quanto di avere il dato di utilizzo dello strumento e versione dello stesso.

Per questo genere di sviluppi, di solito mi affido a Ruby ed il framework grape per la costruzione di API REST. Visto che però si trattava di qualcosa di molto piccolo, mi sono affidato a Sinatra, un framework MVC per la creazione di semplici applicazioni web.

L’applicazione web, fornirà un identificativo univoco ai client che ne faranno richiesta; ogni istanza di dawnscanner quindi avrà un proprio ID che verrà richiesto dal tool se lo stesso non ne troverà valore salvato all’interno della propria configurazione in locale.

Lato server, implementare un endpoint che se interrogato in GET ti dia un ID univoco è semplice, basta usare la libreria SecureRandom di sistema.

get '/new' do
  i = Id.new
  i.uuid = Id.get_new_id
  i.save

  content_type :json
  {:uuid => i.uuid }.to_json
end

Id è una classe che estende ActiveRecord, che si interfaccia quindi con il database per rendere persistente l’identificativo appena creato.

require 'securerandom'

class Id < ActiveRecord::Base
  def self.get_new_id
    return SecureRandom.uuid
  end
end

Anche in questo caso, abbastanza semplice come classe.

L’inizializzazione del sistema di telemetria avviene nella classe Dawn::Cli. L’idea è quella di avere un’entry point dove i client fanno una POST passando il proprio identificativo, l’indirizzo IP e la versione della knowledge base.

def have_a_telemetry_id?
  debug_me ($telemetry_id != ""  and ! $telemetry_id.nil?)
  return ($telemetry_id != ""  and ! $telemetry_id.nil?)
  
end

def get_a_telemetry_id
  return "" if ($telemetry_url == "" or $telemetry_url.nil?)
  debug_me("T: " + $telemetry_url)

  url = URI.parse($telemetry_url+"/new")
  res = Net::HTTP.get_response(url)

  return "" unless res.code.to_i == 200
  return JSON.parse(res.body)["uuid"]
end


def telemetry
  unless have_a_telemetry_id?
    $telemetry_id = get_a_telemetry_id
    $config[:telemetry][:id] = $telemetry_id
    debug_me($config)
    debug_me("saving config to " + $config_name)
    File.open($config_name, 'w') { |f| f.write $config.to_yaml }
  end

  debug_me("Telemetry ID is: " + $telemetry_id)
  
  uri=URI.parse($telemetry_url+"/"+$telemetry_id)
  header = {'Content-Type': 'text/json'}
  tele = { "kb_version" => Dawn::KnowledgeBase::VERSION , 
           "ip" => Socket.ip_address_list.detect{|intf| intf.ipv4_private?}.ip_address, 
           "message"=> Dawn::KnowledgeBase
        }
  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Post.new(uri.request_uri, header)
  request.body = tele.to_json

  response=http.request(request)
  debug_me(response.inspect)

  return true
  
end

L’url alla quale viene fatta la POST è uguale all’id del client, questo per rendere difficile l’eventuale tampering dei dati da parte di qualche buontempone.

post '/:uuid' do
  request.body.rewind
  @request_payload = JSON.parse request.body.read

  i = Id.find_by("uuid", params['uuid'].to_s)
  unless i.nil? 
    l=Log.new
    l.uuid = params['uuid'].to_s
    l.ip=@request_payload['ip']
    l.kb_version=@request_payload['kb_version']
    l.message=@request_payload['message']
    l.save
  end
end

Ho scelto SQLite3 come database, visto che per piccole moli di dati è decisamente la scelta più ovvia.

Il progetto è su github.com ed è ovviamente open. Ho scelto questa strada per fugare qualsiasi dubbio circa i dati inviati da dawnscanner al mio sistema di telemetria, sistema che ovviamente può essere disabilitato da file di configurazione.