Protezione dei dati di un defunto

So che l'argomento non è dei più leggeri, soprattutto vista l'estate e la crescente voglia di vacanze, ma la questione a mio avviso guadagnerà sempre più importanza man mano che la generazione dei nativi digitali (ma anche un po' la mia, nato nel '75) avanzerà con gli anni.
La domanda è semplice: cosa accade a tutti i miei dati memorizzati in centinaia di banche dati quando un sarò mancato all'affetto dei miei cari?
Chi potrà accedere alla mia posta elettronica? Chi potrà gestire il mio account facebook?
I miei discendenti potranno accedere alle mie foto salvate lungo tutta una vita nel mio account flikr?

Ma la domanda più importante è: che diritti potranno vantare i miei successori nei confronti di chi questi dati li gestisce (i vari Google, Facebook, Microsoft,...)?

A questa domanda sembra dare una risposta semplice e, a mio avviso, sorprendente il nuovo regolamento europeo sui dati personali.

Il considerando numero 27 del GDPR cita, testualmente:
"Il presente regolamento non si applica ai dati personali delle persone decedute. Gli Stati membri possono prevedere norme riguardanti il trattamento dei dati personali delle persone decedute".

Cosa significa quindi?

Sembrerebbe che i colossi dell'informazione potranno utilizzare i miei dati a loro libero piacimento, senza doverne rispondere a nessuno.

Possibile?

In realtà questo sembra stridere con uno dei principi cardine della carta dei diritti dell'unione europea da cui il regolamento sulla protezione dei dati prende forma, ovvero la salvaguardia della dignità del interessato.

Forse tutto questo sembrerebbe perdere di significato, dato che risulta difficile pensare che i vari Facebook, Google, ... vengano a sapere che un proprio utente sia passato a miglior vita; e ancor meno potrà sapere se l'account è stato ceduto ad un erede.

Non ci resta che attendere i primi casi: saranno di sicuro interesse.

Localization with Angular.JS

In a previous post covering the use of Angular.JS on an ASP.NET (or better, DotNetNuke) web app, a was wondering how to solve the problem of localize the js content.

In fact I discovered pretty soon that many strings of the presentation layer were specified inside the js file, defining the angular app, controller, directive,....

So my first thought was to create a specific handler in order to generate the javascript at runtime so that I would have the capability to use the native localization management of ASP.NET or DotNetNuke.

IMHO the handler would have as many cons than pro, or even worst; for example, every js file would have been addressed by the unique handler, breaking the easy file organization of each DNN module or ascx control, ...: much work for a small problem.

So I passed to another approach:
why not concentrate all the strings to localize in a js object inside the ascx file?
the Angular.JS app (controller/directive,...) would be kept in a separate pure js file, with the capability to access the variable once on the client's browser.

The solution is composed by:
1) a method to run on load, in a base class of the module (or User control), with a couple of properties override-able in the specialized module class.

     protected void LoadResourcesToJavascript()
        {
            if (this.ResourceKeysToJavascript.Count() > 0)
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder();
                sb.Append("var " + this.ResourceJSVariableName + " = {};\n");

                foreach (String s in this.ResourceKeysToJavascript)
                {
                    sb.Append(this.ResourceJSVariableName + "." + s + "= '" + Localization.GetString(s + ".Text", LocalResourceFile) + "';\n");
                }

                Page.ClientScript.RegisterClientScriptBlock(this.GetType(), this.ResourceJSVariableName + "Resources", sb.ToString(), true);
            }
        }

        protected virtual List ResourceKeysToJavascript
        {
            get
            {
                return new List();
            }
        }
        protected virtual String ResourceJSVariableName
        {
            get
            {
                return this.ID;
            }

        }

Note: I use the DNN method to get the localized string. Change it in case of standard ASP.NET project.
Note: The javascript variable name is the control's ID, but it can be specialized in the inherited module class.

2) in the inherited module / user control specialize the ResourceKeyToJavascript list with the resource string required in the javascript.

 protected override List ResourceKeysToJavascript
        {
            get
            {
                return new List() { 
                                "ConfirmRemoving",
                                "SailingName",
                                "Types",
                                "UnableToFindFriend",
                                "Saved",
                                "Error"};
            }
        }

3) in javascrpit file use the variable name (ASP.NET control's ID) to access the single resource strings:

var str = CrewMemberCollectionV2View.ConfirmRemoving;
if (confirm(str.replace("{sailingName}", entity.SailingName))) {
     //do something  
}

4) last but not least, use the standard resx files to add the required resource strings.

Security using client-side javascript frameworks

In a previous post I put the focus on the security of Angular.JS.

I found a quite easy way to solve this problem:

the problem simply... does not arise.

I am going to explain a bit deeper this concept.

Usually security has to address one main goal: allow to access data/services only if the user has the right authorization.
There is a second, less important goal: adapt the presentation layer to the gained authorization.

Example: if I do not have the the authorization to change the info in a form, the "save button" should be absent on the page!

IMHO this is the real difference between standard "server-side-generated" page (php, asp.net,....) and "client-side-generated" page (Angular.JS,...); this difference can be summarized in this question:

"Who is going to decide if the button should or should not be shown?"

The first solution solve the complete security logic server side, sending to the client only the strictly necessary functions (if not authorized, the server will not even send the the button to the page), while the second solution delegates part (even significant one) of the security logic to client side.

This means that, Angular.JS (as every client side technology) can not solve the security issue itself: all the security logic has to be addressed by separate APIs entitle to check every service exchange among client web page and server web app.

But,even if I put in place this logic (server or client side) I should not forget to put in place the main security check: verify that the operation put in place is allowed!

Conclusion:

Working with client side logic helps a lot to focus on security issue leading to the correct sw architecture, and avoiding to mix up the main security goal with the secondary one.

My first time with Angular.js

I have started learning Angular.JS from scratch and here my first impressions:

• Very coll (impressive!)
• A real way to easy down the UI interface (my nightmare!)
• It seems simple... too simple...
• Yes, but wait... remember... nothing more than the presentation layer.

I was worried by a couple of things:

• how to use security in Angular JS;
• how to localize the strings that have to be set during js runtime.

I am going to explain how I solved these two worries in my next posts.

My first "test projects" for practicing on Angular.JS were focused on:

• simplest ng-module in order to receive info via json and render them to the page;
• simplest form bidirectional (coming / going to db);
• UI grid;
• Google Map (have to try!!);
• put everything in DotNetNuke!

I found this link particularly helpful:
angular-ui.github.io

I found a quite easy way to solve the second problem (I am going to write something about that in another post).

The first problem was solved pretty soon:
the problem simply... does not arise.

I am going to explain a bit deeper this concept.

Usually security has to address one main goal: allow to access data/services only if the user has the right authorization.
There is a second, less important goal: adapt the presentation layer to the gained authorization.

Example: if I do not have the the authorization to change the info in a form, the "save button" should be absent on the page!

IMHO this is the real difference between standard "server-side-generated" page (php, asp.net,....) and "client-side-generated" page (Angular.JS,...); this difference can be summarized in this question:

"Who is going to decide if the button should or should not be shown?"

The first solution solve the complete security logic server side, sending to the client only the strictly necessary functions (if not authorized, the server will not even send the the button to the page), while the second solution delegates part (even significant one) of the security logic to client side.

This means that, Angular.JS (as every client side technology) can not solve the security issue itself: all the security logic has to be addressed by separate APIs entitle to check every service exchange among client web page and server web app.

But,even if I put in place this logic (server or client side) I should not forget to put in place the main security check: verify that the operation put in place is allowed!

Conclusion:

Working with client side logic helps a lot to focus on security issue leading to the correct sw architecture, and avoiding to mix up the main security goal with the secondary one.

FileSystemWatcher

La classe FileSysnteWatcher è un componente con delle potenzialità notevoli.
Riesce a mettersi in ascolto di una cartella e "avverte" quando una modifica è accaduta.
Con modifica intendo, la creazione, la modifica, la cancellazione di files o sotto cartelle.

Premetto che non l'ho ancora utilizzato in alcuna produzione ma questo strumento è decisamente interessante in quanto la mia esperienza ha mostrato che ancora oggi il sistema più usato per scambiare dati tra processi diversi è il deposito di un file in una cartella di scambio e di un loop che controlla l'esistenza di nuovi file (in moltissime realtà il concetto stesso di soap service non è ancora arrivato).
Ebbene, questa classe consente invece di evitare la creazione del loop ma affidarsi agli eventi scatenati, con ovvi benefici in sicurezza, affidabilità e robustezza.

Come usaer Page_Load e Page_Init

Nel Page_Init bisogna lanciare tutto quello che riguarda la costruzione della pagina (o del controllo in generale) che NON RIGUARDA I DATI che eventualmente possono essere caricati da un post.

Nel Page_Load invece si mette tutto ciò che è inerente alla manipolazione del dato da visualizzare.

Ad esempio: il caricamento dinamico di una drodownlist deve avvenire in init, almeno nel caso in cui il caricamento non fosse in funzione di dati della pagina stessa.

Questa distrinzione vale anche per i partial postback di Ajax.
Da ricordarsi comunque che in questo caso this.IsPostBack è sempre a true.

Resizing image on the fly

Per risolvere questo problema in maniera definitiva ho deciso di creare un servizio on line di ridimensionamento delle immagini "al volo".
Il sistema è molto semplice:
1) registrarsi al servizio contattandomi marco@ghizzi.it e comunicandomi la cartella delle immagini pubblicate on line.
2) vi verrà fornito un codice utente.
3) utilizzare il link del seguente tipo anziché l'immagine locale:
htttp://www.ghizzi.it/outimage/<codice_utente>/<nome_immagine_compresa_di_estensione>.ashx
4) a questo url aggiungere in query string uno o più parametri dei seguenti:
width=<larghezza_in_pixel>, height=<altezza_in_pixel>, align=<near_far_o_center>, color=<colore_di sfondo>
5) al posto di tali settaggi si può precaricare dei preset identificati da dei codici all'atto della registrazione.

Per ulteriori informazioni, contattatemi alla email marco@ghizzi.it

Come memorizzare le password

Recentemente mi sono posto questo problema:
qual'è il metodo migliore per memorizzare una password in un database, evitando ovviamente di metterla in chiaro?
A tale domanda la mia prima risposta è stata quella di utilizzare la funzione di hashing della stringa, presente praticamente in ogni liunguaggio di programmazione "attuale" (ho diretta esperienza in Java e .NET).
Questa scelta però non è vincente in quanto l'hash non garantisce la "portabilità" tra tecnologie diverse (la funzione di hashing di Java e C# sono diverse!) ma nemmeno tra versioni diverse della stessa tecnologia: infatti non si garantisce che tale algoritmo di hashing non venga cambiato in future versioni dello stesso linguaggio.

A mio avvio quindi la scelta migliore è quella di usare uno degli algoritmi di generazione del digest come può essere l'SHA-1 o qualsiasi altro algoritmo superiore.
Riporto sotto il codice per generare tale digest nei due linguaggi che utilizzo di norma.

 C#.NET:


        ///

        /// Create Digest of one string
        ///

        ///

        ///
        public static byte[] GetDigest(String arg)
        {
            System.Security.Cryptography.SHA1 sha = new System.Security.Cryptography.SHA1Managed();
            ASCIIEncoding ae = new ASCIIEncoding();
            byte[] data = ae.GetBytes(arg);
            byte[] digest = sha.ComputeHash(data);
            return digest;
        }

        ///

        /// COnverts an array of bytes in the UNICODE value of the string.
        ///

        ///
        ///
        public static string GetAsString(byte[] bytes)
        {
            StringBuilder s = new StringBuilder();
            int length = bytes.Length;
            for (int n = 0; n < length; n++)
            {
                s.Append(Convert.ToChar(bytes[n]));
            }
            return s.ToString();
        }


JAVA:
    public byte[] getDigest(String arg) throws java.security.NoSuchAlgorithmException, UnsupportedEncodingException {
        java.security.MessageDigest digest = java.security.MessageDigest.getInstance("SHA-1");
        digest.reset();
        return digest.digest(arg.getBytes("UTF-8"));
    }

    public static String GetAsString(byte[] bytes) {
        StringBuilder s = new StringBuilder();
        int length = bytes.length;
        for (int n = 0; n < length; n++) {
            s.append((char) (bytes[n] & 0xff));
        }
        return s.toString();
    }

Efficienza vs efficacia

Spesso nel mio lavoro mi capita di dover pensare se la soluzione che ho in mente e che chiedo alla direzione di (far) realizzare, sia proprio la soluzione migliore in quell'istante per l'azienda, cercando di trovare il giusto compromesso tra soluzioni formalmente curate, frutto di architetture flessibili e manutenibili,... contro soluzioni veloci, che puntano alla risoluzione del mero problema del cliente, il così detto "quick and dirty"
La teoria della Qualità, del sistema Toyota non lascia alcun dubbio sulla strada da seguire: quello che bisogna fare è risolvere il problema, nel più breve tempo possibile, tanto da sostenere che, se nel giro di una settimana (la famosa Settimana Kaizen) non si riesce a trovare, e implementare una soluzione, significa che si sta sbagliando strategia.

La regola d'oro sembra quindi essere: puntare all'efficacia piuttosto che all'efficienza.

Ho sempre sostenuto che questa logica di miglioramento a piccoli passi, atta a risolvere velocemente il mero problema del cliente,  non fosse applicabile ad ogni realtà, ma solo a quelle che hanno superato una certa "massa critica" nell'organizzazione e standardizzazione aziendale, massa critica che deve essere raggiunta a
suon di pesanti investimenti.

Questo mio convincimento porta anche a ripensare al valore dell'efficienza che deve essere uguale o forse maggiore a quella dell'efficacia.
Mi piace vedere l'efficacia come il fine che deve obbligatoriamente essere raggiunto con un processo efficiente, ovvero "di qualità" che riesca a garantire flessibilità e manutenibilità nel tempo.

SQL Server, IIS 7 e Windows Server 2008

Che user viene utilizzato per far girare web app ASP.NET su IIS 7? E più concretamente, qual'è lo user con cui una web app si collega a SQL Server? In pratica, se SQL Server si trova sulla stessa macchina su cui gira IIS 7 e si volesse utilizzare l'integrated security evitando di mettere in chiaro una password nella configurazione, a quale user bisognerebbe garantire l'accesso al DB (modulando l'autorizzazione minima necessaria per fare tutto il lavoro)? La risposta è: IIS_IUSR.
Tale discorso vale anche se SQL Server e IIS 7 si trovassero su due macchine differenti, entrambe sotto lo stesso dominio.

IIS 7 su sistema x64

In questi giorni ho scoperto che esistono due moduli distinti asp.net per IIS: oltre a quello standard ne esiste uno specifico per macchine a 64 bit.

Volendo pubblicare una web app in ASP.NET su un tale sistema a 64 bit bisogna ricordarsi di agganciare eventuali estensioni particolari (oltre alle solite *.aspx) ad entrambi i moduli, pena l'impossibilità di visualizzare tali   pagine.

Considerazioni su SQL

Credo che concentrare in SQL nelle SP una grossa quantità di codice sia controproducente. Bisogna suddividere molto, in modo che il controllo rimanga nel codice e sfruttare tutto ciò che deriva dalla programmazione a oggetti, senza considerare i nuovi strumenti evoluti (LINQ o HIBERNATE).

Rendere SQL Server raggiungibile

Ecco i passaggi per configurare un server in modo che sql server sia raggiungibile da remoto.

1) abilitare il firewall sulla porta 1433.

2) abilitare il firewall sulla porta 1434 udp

3) In Sql server configuration manager abilitare il TCP/IP.

4) abilitare TCP port su 1433 e togliere da dynamic port mettere stringa nulla.

(5) abilitare IP Address /Enabled nelle proprietà del protocollo TCP/IP in network config e Protocols, attivare TCP/IP)

6) Controllare se in Client Protocols il TCP/IP ha il default port su 1433

7) attivare sql server e sql browser.

Attenzione: E' fondamentale attivare anche il SQL Browser PER LA PRIMA CONNESSIONE; poi si può spegnere senza problemi.

Stanotte ho fatto una scoperta sensazionale.

Google mette a disposizione uno strumento per fare i grafici on line.

Il concetto è semplice: giocando con i parametri in query string di un loro sito, si possono creare on-the-fly immagini che riproducono il grafico richiesto.

Questo è il sito: http://code.google.com/intl/en/apis/chart/

Java

In questi giorni sono stato impegnato a chiudere un progetto per realizzare uno strumento per la firma digitale. Il funzionamento è abbastanza classico: si visualizza il documento, e si decide se firmarlo o meno; automaticamente viene visualizzato il documento successivo e così via..

Tecnologia di sviluppo: Java; ambiente di sviluppo: Netbeans.

Verso la fine dello sviluppo mi accorgo che qualcosa non va: i documenti di partenza, una volta firmati non venivano cancellati. Come mai? Non l'ho scoperto. Tutto il progetto stava per collassare solo perchè la funzione File.delete() non fa quello che deve:il file esiste e non è bloccato eppure non si riesce a cancellarlo. Se si prova a cancellarlo a mano via filesystem si cancella senza problema!

Ho provato con un ciclo di delete (magari è solo questione di tempo) ma niente; allo scadere della deadline mi sono deciso a rinominare il file aggiungendo .old al file, in attesa di trovare una soluzione.

Non escludo che abbia fatto qualche cosa di non corretto che abbia causato questo problema, non mi capacito però della scarsità di risorse che il mondo Java mette a disposizione: sembra che venga utilizzato da pochissime persone, invece le statistiche dicono che è il linguaggio più usato.

Dopo un primo studio sembra che il qualche maniera la classe per visualizzare il documento tenga bloccato il file anche dopo aver estratto l'array di byte e abbandonato. Ritorno su internet a cercare qualche soluzione ma nulla, come se la mia libreria non fosse usata da nessuno, invece trovo che molti siti citano la libreria ma i codici di esempi sono scarsissimi: mi piacerebbe sapere se c'è qualcuno che utilizza questi visualizzatori e subito dopo cancella il file.

SQL server 2008 e SQL Servier Browser

Solo per ricordare che dopo aver attivato i vari protocolli di trasmissione, bisogna anche attivare il SQL Server Browser in quanto sql server 2008 ha attivo di default il dynamic port.

Come autenticarsi via codice

Mi è capitato di recente di ricevere da un'altra pagina web di una intranet le credenziali dello user loggato. Il mio problema era quindi utilizzare questo user (non mi veniva ovviamente fornita la password) come IPrincipal della mia web app.

Ecco quello che ho trovato:

if (!this.User.Identity.IsAuthenticated)

        {

            FormsAuthentication.SetAuthCookie(nomeUtente, false);

            Response.Redirect(this.Request.FilePath, true);

        }

Per prova l'ho messo nella Page_Load() ma sicuramente starebbe meglio in un IHTTPModule.

Aggiornamento server SVN

Un altro fornitore di servizi SVN che mi sono dimenticato di citare nel mio passato post è google stesso.

Seguendo il link di project josting sul sito code.google.com si ha a disposizione uno spazio simile a quello di assembla.

  

Formato di data in XML

Per non perdere questa informazione ecco il formato di data ufficiale W3C

'-'? yyyy '-' mm '-' dd 'T' hh ':' mm ':' ss ('.' s+)? (zzzzzz)?


Questo è il sito ufficiale

http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/datatypes.html#dateTime

SVN repositories

Questo è un riassunto di quello che ho ricercato in questi mesi circa gli strumenti di repository e versioning. Tra SVN e CSV ho preferito SVN semplicemente perchè ci sono più strumenti software e più internet repositories (di CVS non ne ho trovato nemmeno uno).
Quindi in locale ho installato TortoiseSVN e il server Subversion; ma in più ho trovato siti che forniscono servizi di SVN server. Ecco quelli che ho trovato:

www.codeplex.com/ e code.google.com/

questi richiedono una licenza open GL o similari.
L'unico che ho trovato che consente di salvare i propri progetti senza licenza open GL è www.assembla.com/