Proteja com senha um banco de dados SQLite. É possível?

Eu tenho que enfrentar um pequeno projeto novo. Terá cerca de 7 ou 9 tabelas, a maior delas crescerá a uma taxa máxima de 1000 linhas por mês.

Pensei no SQLite como meu banco de dados ... Mas vou precisar proteger o banco de dados caso alguém queira alterar os dados do banco de dados

Minha pergunta principal é:

É possível proteger com senha um banco de dados sqlite como você faria no acesso?

Que outro RDBMS você recomendaria para uma solução tão pequena?

O desenvolvimento seria em C #, mas estou procurando algo grátis.

Você pode proteger com senha um banco de dados SQLite3. Antes de fazer qualquer operação, defina a senha da seguinte forma.

SQLiteConnection conn = new SQLiteConnection("Data Source=MyDatabase.sqlite;Version=3;");
conn.SetPassword("password");
conn.Open();

então da próxima vez você pode acessá-lo como

conn = new SQLiteConnection("Data Source=MyDatabase.sqlite;Version=3;Password=password;");
conn.Open();

Isso não permitirá que nenhum editor de GUI visualize seus dados. Alguns editores podem descriptografar o banco de dados se você fornecer a senha. O algoritmo usado é RSA.

Posteriormente, se desejar alterar a senha, use

conn.ChangePassword("new_password");

Para redefinir ou remover a senha, use

conn.ChangePassword(String.Empty);

Você pode usar a criptografia interna do provedor sqlite .net (System.Data.SQLite). Veja mais detalhes em http://web.archive.org/web/20070813071554/http://sqlite.phxsoftware.com/forums/t/130.aspx

Para criptografar um banco de dados não criptografado existente ou para alterar a senha de um banco de dados criptografado , abra o banco de dados e use a função ChangePassword () de SQLiteConnection:

// Opens an unencrypted database
SQLiteConnection cnn = new SQLiteConnection("Data Source=c:\\test.db3");
cnn.Open();
// Encrypts the database. The connection remains valid and usable afterwards.
cnn.ChangePassword("mypassword");

Para descriptografar uma chamada de banco de dados criptografada existenteChangePassword() com uma senha NULLou "":

// Opens an encrypted database
SQLiteConnection cnn = new SQLiteConnection("Data Source=c:\\test.db3;Password=mypassword");
cnn.Open();
// Removes the encryption on an encrypted database.
cnn.ChangePassword(null);

Para abrir um banco de dados criptografado existente ou para criar um novo banco de dados criptografado, especifique uma senha ConnectionStringcomo mostrado no exemplo anterior ou chame a SetPassword()função antes de abrir um novo SQLiteConnection. As senhas especificadas no ConnectionStringdevem ser em texto não criptografado, mas as senhas fornecidas na SetPassword()função podem ser matrizes de bytes binários.

// Opens an encrypted database by calling SetPassword()
SQLiteConnection cnn = new SQLiteConnection("Data Source=c:\\test.db3");
cnn.SetPassword(new byte[] { 0xFF, 0xEE, 0xDD, 0x10, 0x20, 0x30 });
cnn.Open();
// The connection is now usable

Por padrão, a palavra-chave ATTACH usará a mesma chave de criptografia do banco de dados principal ao anexar outro arquivo de banco de dados a uma conexão existente. Para alterar esse comportamento, você usa o modificador KEY da seguinte maneira:

Se você estiver anexando um banco de dados criptografado usando uma senha de texto não criptografado:

// Attach to a database using a different key than the main database
SQLiteConnection cnn = new SQLiteConnection("Data Source=c:\\test.db3");
cnn.Open();
cmd = new SQLiteCommand("ATTACH DATABASE 'c:\\pwd.db3' AS [Protected] KEY 'mypassword'", cnn);
cmd.ExecuteNonQuery();

Para anexar um banco de dados criptografado usando uma senha binária:

// Attach to a database encrypted with a binary key
SQLiteConnection cnn = new SQLiteConnection("Data Source=c:\\test.db3");
cnn.Open();
cmd = new SQLiteCommand("ATTACH DATABASE 'c:\\pwd.db3' AS [Protected] KEY X'FFEEDD102030'", cnn);
cmd.ExecuteNonQuery();

Use SQLCipher, é uma extensão de código aberto para SQLite que fornece criptografia AES de 256 bits transparente de arquivos de banco de dados. http://sqlcipher.net

Você pode criptografar seu banco de dados SQLite com o addon SEE. Desta forma, você evita acesso / modificação não autorizada.

Citando a documentação do SQLite:

O SQLite Encryption Extension (SEE) é uma versão aprimorada do SQLite que criptografa arquivos de banco de dados usando AES de 128 ou 256 bits para ajudar a prevenir o acesso não autorizado ou modificação. Todo o arquivo do banco de dados é criptografado para que, para um observador externo, o arquivo do banco de dados pareça conter ruído branco. Não há nada que identifique o arquivo como um banco de dados SQLite.

Você pode encontrar mais informações sobre este addon neste link .

Uma opção seria o VistaDB . Eles permitem que bancos de dados (ou mesmo tabelas) sejam protegidos por senha (e opcionalmente criptografados).

Se você usar FluentNHibernate, poderá usar o seguinte código de configuração:

private ISessionFactory createSessionFactory()
{
    return Fluently.Configure()
            .Database(SQLiteConfiguration.Standard.UsingFileWithPassword(filename, password))
            .Mappings(m => m.FluentMappings.AddFromAssemblyOf<DBManager>())
            .ExposeConfiguration(this.buildSchema)
            .BuildSessionFactory();    
}

private void buildSchema(Configuration config)
{
        if (filename_not_exists == true)
        {
            new SchemaExport(config).Create(false, true);
        }
}    

O método UsingFileWithPassword (nome do arquivo, senha) criptografa um arquivo de banco de dados e define a senha.
Ele é executado apenas se o novo arquivo de banco de dados for criado. O antigo não criptografado falha quando é aberto com este método.

Eu sei que esta é uma questão antiga, mas a solução simples não seria apenas proteger o arquivo no nível do sistema operacional? Apenas evite que os usuários acessem o arquivo e então eles não devem ser capazes de tocá-lo. Isso é apenas um palpite e não tenho certeza se essa é uma solução ideal.

Por que você precisa criptografar o banco de dados? O usuário pode facilmente desmontar seu programa e descobrir a chave. Se você estiver criptografando-o para transferência de rede, considere usar PGP em vez de espremer uma camada de criptografia em uma camada de banco de dados.