Modo sicuro per archiviare dettagli API sensibili degli utenti (localStorage o database?)

Che ne dici di memorizzare i token API in un modo che nemmeno tu puoi usarli?

Cifra i token dell'API con una chiave derivata dalla password dell'utente. Per evitare di dover inviare la password al server in testo normale, è possibile utilizzare un hash come chiave - assicurandosi di utilizzare un diverso salt sul lato client per la normale procedura di archiviazione della password del server. Al login i token possono essere estratti dal database e decrittografati. Se l'utente dimentica la sua password, i dettagli dell'API non possono essere recuperati dalle tue copie, ma va bene perché possono riceverli e rientrare dagli scambi di nuovo.

Se stai adottando questo approccio, devi prendere le misure necessarie per assicurarti che i token non vengano cercati sul tuo server. Non ha molto senso fare questo sforzo per poi farli scrivere sul disco comunque. È inoltre necessario assicurarsi che vengano scaricati dalla memoria alla disconnessione.

Un'altra alternativa sarebbe quella di derivare e utilizzare i token chiavi / API sul computer client - in questo modo non si ha mai accesso ad essi in testo semplice. Ciò presuppone che le API di Exchange abbiano politiche CORS che consentono alla tua applicazione di chiamarle dal computer client. Un esempio di derivazione / utilizzo della chiave utilizzando l'API WebCrypto (codice più completo qui - link

var _algorithm = "AES-CBC";
var _key_size = 256;
var _pbkdf_iterations = 100;

// Do not change this once used in production
// If copying from StackExchange replace with a new random value for your app 
// or pass in a user specific value from the DB
var _defaultSalt = "af95a2b25229d227269a54fdec562d93";

// Derives a key from the given password.
// Salt is not required. If supplied should be a hex string.
function deriveKey(passphrase, salt)
{   
    if (typeof(salt) === 'undefined')
    {
        salt = _defaultSalt;
    }

    return passphrase == null || passphrase.length < 10 ?
        Promise.reject("Password must be at least 10 characters") :
        crypto.subtle.importKey(
            'raw',
            stringToUtf8ByteArray(passphrase),
            { name: 'PBKDF2'},
            false,
            ['deriveBits', 'deriveKey' ]
        ).then(function(passwordKey) {
            return crypto.subtle.deriveKey(
                {
                    "name": 'PBKDF2',
                    "salt": hexStringToByteArray(salt),
                    "iterations": _pbkdf_iterations,
                    "hash": 'SHA-256'
                },
                passwordKey,
                { "name": _algorithm, "length": _key_size },
                false, // Extractable is set to false so that underlying key details cannot be accessed.
                [ "encrypt", "decrypt" ]
            );
        });
}

function encryptData(keyObject, data)
{
    let iv = crypto.getRandomValues(new Uint8Array(16));

    return crypto.subtle.encrypt(
        {name: _algorithm, iv: iv},
        keyObject,
        data
    ).then(function(encryptedData) {
        return {
            iv:iv,
            data:encryptedData
        }
    });
}

function decryptData(keyObject, iv, encryptedData)
{   
    return crypto.subtle.decrypt(
        {name: _algorithm, iv: iv},
        keyObject,
        encryptedData
    );
}