Ir para o conteúdo do rodapé
AJUDA DO .NET

Criptografia AES em C# (Como funciona para desenvolvedores)

O AES (Advanced Encryption Standard) é um dos algoritmos de criptografia simétrica mais utilizados. Ele usa a mesma chave para criptografar e descriptografar dados, tornando a criptografia AES eficiente e rápida para proteger dados confidenciais em diversas aplicações.

Este tutorial irá abordar a criptografia AES em C#, utilizando a classe AES para criptografar e descriptografar dados e a biblioteca IronPDF . Vamos abordar exemplos práticos, analisar o processo de criptografia e ver como usar o modo Cipher Block Chaining (CBC) para aumentar a segurança. Também discutiremos o gerenciamento de chaves de criptografia e o papel do vetor de inicialização (IV).

Introduction of AES Encryption in C

O Advanced Encryption Standard (AES) é um algoritmo de criptografia simétrica padronizado pelo Instituto Nacional de Padrões e Tecnologia (NIST). O algoritmo pode ter tamanhos de chave de 128, 192 ou 256 bits e é altamente seguro para criptografar dados confidenciais. Ele usa a mesma chave de criptografia para criptografar e descriptografar dados.

O AES funciona dividindo os dados originais em blocos e aplicando transformações a esses blocos. Ele opera em diferentes modos de criptografia, como CBC (Cipher Block Chaining) e Electronic CodeBook (ECB), cada um oferecendo diferentes recursos de segurança.

How AES Works in C

O algoritmo de criptografia AES em C# faz parte do namespace System.Security.Cryptography. Este namespace inclui a classe AES, que nos permite criar uma instância do AES, especificar o tamanho da chave, o modo de cifra e o modo de preenchimento, e então criptografar e descriptografar dados usando uma chave secreta.

Para usar AES em C#, siga estes passos básicos:

  1. Crie uma instância da classe AES usando Aes.Create().
  2. Defina a chave, o IV e outros parâmetros relevantes, como o modo de criptografia.
  3. Criptografe os dados usando a interface ICryptoTransform e grave-os em um MemoryStream.
  4. Decifre os dados usando a mesma chave e IV.

Vamos criar um processo básico de criptografia e um programa de descriptografia em C#.

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

class Program
{
    // Declare a static byte array for encrypted data
    public static byte[] encryptedData;

    // Main method to demonstrate encryption and decryption
    public static void Main(string[] args)
    {
        // String plaintext to be encrypted
        string plaintext = "This is some sensitive data!";
        string key = "abcdefghijklmnop"; // 128-bit key (16 characters)

        // Encrypt the plaintext
        string ciphertext = Encrypt(plaintext, key);
        Console.WriteLine("Encrypted Data: " + ciphertext);

        // Decrypt the ciphertext
        string decryptedData = Decrypt(ciphertext, key);
        Console.WriteLine("Decrypted Data: " + decryptedData);
    }

    // Method to encrypt data
    public static string Encrypt(string plaintext, string key)
    {
        // Create a new instance of the AES encryption algorithm
        using (Aes aes = Aes.Create())
        {
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.IV = new byte[16]; // Initialization vector (IV)

            // Create an encryptor to perform the stream transform
            ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);

            // Create the streams used for encryption
            using (MemoryStream ms = new MemoryStream())
            {
                // Create a CryptoStream using the encryptor
                using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
                {
                    using (StreamWriter sw = new StreamWriter(cs))
                    {
                        sw.Write(plaintext);
                    }
                }
                // Store the encrypted data in the public static byte array
                encryptedData = ms.ToArray();
                return Convert.ToBase64String(encryptedData);
            }
        }
    }

    // Method to decrypt data
    public static string Decrypt(string ciphertext, string key)
    {
        using (Aes aes = Aes.Create())
        {
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.IV = new byte[16]; // Initialization vector (IV)

            // Create a decryptor to perform the stream transform
            ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);

            // Create the streams used for decryption
            using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(ciphertext)))
            {
                using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
                {
                    using (StreamReader sr = new StreamReader(cs))
                    {
                        return sr.ReadToEnd();
                    }
                }
            }
        }
    }
}
using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

class Program
{
    // Declare a static byte array for encrypted data
    public static byte[] encryptedData;

    // Main method to demonstrate encryption and decryption
    public static void Main(string[] args)
    {
        // String plaintext to be encrypted
        string plaintext = "This is some sensitive data!";
        string key = "abcdefghijklmnop"; // 128-bit key (16 characters)

        // Encrypt the plaintext
        string ciphertext = Encrypt(plaintext, key);
        Console.WriteLine("Encrypted Data: " + ciphertext);

        // Decrypt the ciphertext
        string decryptedData = Decrypt(ciphertext, key);
        Console.WriteLine("Decrypted Data: " + decryptedData);
    }

    // Method to encrypt data
    public static string Encrypt(string plaintext, string key)
    {
        // Create a new instance of the AES encryption algorithm
        using (Aes aes = Aes.Create())
        {
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.IV = new byte[16]; // Initialization vector (IV)

            // Create an encryptor to perform the stream transform
            ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);

            // Create the streams used for encryption
            using (MemoryStream ms = new MemoryStream())
            {
                // Create a CryptoStream using the encryptor
                using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
                {
                    using (StreamWriter sw = new StreamWriter(cs))
                    {
                        sw.Write(plaintext);
                    }
                }
                // Store the encrypted data in the public static byte array
                encryptedData = ms.ToArray();
                return Convert.ToBase64String(encryptedData);
            }
        }
    }

    // Method to decrypt data
    public static string Decrypt(string ciphertext, string key)
    {
        using (Aes aes = Aes.Create())
        {
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.IV = new byte[16]; // Initialization vector (IV)

            // Create a decryptor to perform the stream transform
            ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);

            // Create the streams used for decryption
            using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(ciphertext)))
            {
                using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
                {
                    using (StreamReader sr = new StreamReader(cs))
                    {
                        return sr.ReadToEnd();
                    }
                }
            }
        }
    }
}
Imports System
Imports System.IO
Imports System.Security.Cryptography
Imports System.Text

Friend Class Program
	' Declare a static byte array for encrypted data
	Public Shared encryptedData() As Byte

	' Main method to demonstrate encryption and decryption
	Public Shared Sub Main(ByVal args() As String)
		' String plaintext to be encrypted
		Dim plaintext As String = "This is some sensitive data!"
		Dim key As String = "abcdefghijklmnop" ' 128-bit key (16 characters)

		' Encrypt the plaintext
		Dim ciphertext As String = Encrypt(plaintext, key)
		Console.WriteLine("Encrypted Data: " & ciphertext)

		' Decrypt the ciphertext
		Dim decryptedData As String = Decrypt(ciphertext, key)
		Console.WriteLine("Decrypted Data: " & decryptedData)
	End Sub

	' Method to encrypt data
	Public Shared Function Encrypt(ByVal plaintext As String, ByVal key As String) As String
		' Create a new instance of the AES encryption algorithm
		Using aes As Aes = System.Security.Cryptography.Aes.Create()
			aes.Key = Encoding.UTF8.GetBytes(key)
			aes.IV = New Byte(15){} ' Initialization vector (IV)

			' Create an encryptor to perform the stream transform
			Dim encryptor As ICryptoTransform = aes.CreateEncryptor(aes.Key, aes.IV)

			' Create the streams used for encryption
			Using ms As New MemoryStream()
				' Create a CryptoStream using the encryptor
				Using cs As New CryptoStream(ms, encryptor, CryptoStreamMode.Write)
					Using sw As New StreamWriter(cs)
						sw.Write(plaintext)
					End Using
				End Using
				' Store the encrypted data in the public static byte array
				encryptedData = ms.ToArray()
				Return Convert.ToBase64String(encryptedData)
			End Using
		End Using
	End Function

	' Method to decrypt data
	Public Shared Function Decrypt(ByVal ciphertext As String, ByVal key As String) As String
		Using aes As Aes = System.Security.Cryptography.Aes.Create()
			aes.Key = Encoding.UTF8.GetBytes(key)
			aes.IV = New Byte(15){} ' Initialization vector (IV)

			' Create a decryptor to perform the stream transform
			Dim decryptor As ICryptoTransform = aes.CreateDecryptor(aes.Key, aes.IV)

			' Create the streams used for decryption
			Using ms As New MemoryStream(Convert.FromBase64String(ciphertext))
				Using cs As New CryptoStream(ms, decryptor, CryptoStreamMode.Read)
					Using sr As New StreamReader(cs)
						Return sr.ReadToEnd()
					End Using
				End Using
			End Using
		End Using
	End Function
End Class
$vbLabelText   $csharpLabel

Criptografia AES em C# (Como funciona para desenvolvedores): Figura 1 - Saída de criptografia e descriptografia usando fluxo de memória

Explicação do código

  1. Aes.Create(): Isso cria uma nova instância do algoritmo de criptografia AES.
  2. aes.Key: A chave usada tanto para criptografia quanto para descriptografia. Deve ter um tamanho válido, como 128 bits (16 bytes), 192 bits ou 256 bits.
  3. aes.IV: O vetor de inicialização (IV) é usado para randomizar o processo de criptografia. Neste exemplo, usamos um vetor de inicialização (IV) igual a zero por simplicidade.
  4. MemoryStream: Isso nos permite trabalhar com os dados criptografados como um fluxo de bytes.
  5. CryptoStream: Transforma o fluxo de dados (criptografia ou descriptografia).

Exemplo avançado: Criptografia AES com chave e IV personalizados

Vamos expandir o exemplo anterior gerando uma chave e um IV aleatórios, garantindo que a criptografia seja mais segura.

public static string EncryptData(string plaintext)
{
    using (Aes aes = Aes.Create())
    {
        aes.Key = new byte[32]; // AES-256 requires a 256-bit key (32 bytes)
        aes.IV = new byte[16];  // 128-bit block size

        // Randomly generate key and IV
        using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(aes.Key); // Generate a random key
            rng.GetBytes(aes.IV);  // Generate a random IV
        }

        // Create an encryptor to perform the stream transform
        ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);

        // Create the streams used for encryption
        using (MemoryStream ms = new MemoryStream())
        {
            using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
            {
                using (StreamWriter sw = new StreamWriter(cs))
                {
                    sw.Write(plaintext);
                }
            }
            return Convert.ToBase64String(ms.ToArray());
        }
    }
}
public static string EncryptData(string plaintext)
{
    using (Aes aes = Aes.Create())
    {
        aes.Key = new byte[32]; // AES-256 requires a 256-bit key (32 bytes)
        aes.IV = new byte[16];  // 128-bit block size

        // Randomly generate key and IV
        using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(aes.Key); // Generate a random key
            rng.GetBytes(aes.IV);  // Generate a random IV
        }

        // Create an encryptor to perform the stream transform
        ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);

        // Create the streams used for encryption
        using (MemoryStream ms = new MemoryStream())
        {
            using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
            {
                using (StreamWriter sw = new StreamWriter(cs))
                {
                    sw.Write(plaintext);
                }
            }
            return Convert.ToBase64String(ms.ToArray());
        }
    }
}
Public Shared Function EncryptData(ByVal plaintext As String) As String
	Using aes As Aes = Aes.Create()
		aes.Key = New Byte(31){} ' AES-256 requires a 256-bit key (32 bytes)
		aes.IV = New Byte(15){} ' 128-bit block size

		' Randomly generate key and IV
		Using rng As RandomNumberGenerator = RandomNumberGenerator.Create()
			rng.GetBytes(aes.Key) ' Generate a random key
			rng.GetBytes(aes.IV) ' Generate a random IV
		End Using

		' Create an encryptor to perform the stream transform
		Dim encryptor As ICryptoTransform = aes.CreateEncryptor(aes.Key, aes.IV)

		' Create the streams used for encryption
		Using ms As New MemoryStream()
			Using cs As New CryptoStream(ms, encryptor, CryptoStreamMode.Write)
				Using sw As New StreamWriter(cs)
					sw.Write(plaintext)
				End Using
			End Using
			Return Convert.ToBase64String(ms.ToArray())
		End Using
	End Using
End Function
$vbLabelText   $csharpLabel

Neste caso, geramos uma nova chave e um novo vetor de inicialização (IV) cada vez que a função é chamada. Isso proporciona uma criptografia mais robusta, pois a mesma chave não é usada para todas as operações. O AES suporta tamanhos de chave como 128, 192 e 256 bits.

Descriptografando dados com AES

A descriptografia é o processo inverso da criptografia de dados . Em nossos exemplos, a mesma chave e o mesmo vetor de inicialização (IV) usados ​​para a criptografia devem ser fornecidos para descriptografar os dados. O processo de descriptografia envolve a conversão dos dados criptografados de volta ao seu formato original.

Aqui está um exemplo que utiliza os dados previamente criptografados:

public static string DecryptData(string ciphertext, byte[] key, byte[] iv)
{
    using (Aes aes = Aes.Create())
    {
        aes.Key = key;
        aes.IV = iv;

        // Create a decryptor to perform the stream transform
        ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);

        // Create the streams used for decryption
        using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(ciphertext)))
        {
            using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
            {
                using (StreamReader sr = new StreamReader(cs))
                {
                    return sr.ReadToEnd();
                }
            }
        }
    }
}
public static string DecryptData(string ciphertext, byte[] key, byte[] iv)
{
    using (Aes aes = Aes.Create())
    {
        aes.Key = key;
        aes.IV = iv;

        // Create a decryptor to perform the stream transform
        ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);

        // Create the streams used for decryption
        using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(ciphertext)))
        {
            using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
            {
                using (StreamReader sr = new StreamReader(cs))
                {
                    return sr.ReadToEnd();
                }
            }
        }
    }
}
Public Shared Function DecryptData(ByVal ciphertext As String, ByVal key() As Byte, ByVal iv() As Byte) As String
	Using aes As Aes = Aes.Create()
		aes.Key = key
		aes.IV = iv

		' Create a decryptor to perform the stream transform
		Dim decryptor As ICryptoTransform = aes.CreateDecryptor(aes.Key, aes.IV)

		' Create the streams used for decryption
		Using ms As New MemoryStream(Convert.FromBase64String(ciphertext))
			Using cs As New CryptoStream(ms, decryptor, CryptoStreamMode.Read)
				Using sr As New StreamReader(cs)
					Return sr.ReadToEnd()
				End Using
			End Using
		End Using
	End Using
End Function
$vbLabelText   $csharpLabel

Este código descriptografa os dados criptografados , convertendo-os novamente em dados originais .

IronPDF com criptografia AES

IronPDF é uma biblioteca .NET simples e amigável para desenvolvedores, projetada para gerar, editar e manipular PDFs usando código C# simples. Permite que os desenvolvedores criem documentos PDF diretamente a partir de HTML , CSS e JavaScript, o que pode ser incrivelmente útil para gerar relatórios, faturas ou outros documentos dinamicamente. Com suporte para mesclagem, divisão e até mesmo adição de recursos de segurança como senhas ou assinaturas digitais, o IronPDF é uma solução completa para geração de PDFs em aplicações .NET .

Integrando o IronPDF com criptografia AES

Criptografia AES em C# (Como funciona para desenvolvedores): Figura 2 - IronPDF

Ao gerar relatórios ou documentos confidenciais, pode ser necessário garantir que os dados contidos nesses PDFs estejam criptografados antes de compartilhá-los. A criptografia AES (Advanced Encryption Standard) é uma solução perfeita para criptografar com segurança o conteúdo de arquivos PDF. Ao combinar o IronPDF com a criptografia AES, você pode proteger os dados contidos em seus PDFs, mantendo a capacidade de trabalhar com o próprio documento.

Passo 1: Criar um PDF usando o IronPDF

Utilize a classe ChromePdfRenderer para gerar um PDF a partir de conteúdo HTML e salvá-lo em um arquivo:

var htmlContent = "<h1>Confidential</h1><p>This is sensitive data.</p>";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs(@"C:\Reports\ConfidentialReport.pdf");
var htmlContent = "<h1>Confidential</h1><p>This is sensitive data.</p>";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs(@"C:\Reports\ConfidentialReport.pdf");
Dim htmlContent = "<h1>Confidential</h1><p>This is sensitive data.</p>"
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("C:\Reports\ConfidentialReport.pdf")
$vbLabelText   $csharpLabel

Etapa 2: Criptografe o PDF usando AES

Após a criação do PDF, criptografe-o com AES:

byte[] pdfBytes = File.ReadAllBytes(@"C:\Reports\ConfidentialReport.pdf");
using (Aes aes = Aes.Create())
{
    aes.Key = Encoding.UTF8.GetBytes("abcdefghijklmnop");
    aes.IV = new byte[16];
    using (var encryptor = aes.CreateEncryptor(aes.Key, aes.IV))
    using (var ms = new MemoryStream())
    {
        using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
        {
            cs.Write(pdfBytes, 0, pdfBytes.Length);
        }
        File.WriteAllBytes(@"C:\Reports\ConfidentialReport.encrypted", ms.ToArray());
    }
}
byte[] pdfBytes = File.ReadAllBytes(@"C:\Reports\ConfidentialReport.pdf");
using (Aes aes = Aes.Create())
{
    aes.Key = Encoding.UTF8.GetBytes("abcdefghijklmnop");
    aes.IV = new byte[16];
    using (var encryptor = aes.CreateEncryptor(aes.Key, aes.IV))
    using (var ms = new MemoryStream())
    {
        using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
        {
            cs.Write(pdfBytes, 0, pdfBytes.Length);
        }
        File.WriteAllBytes(@"C:\Reports\ConfidentialReport.encrypted", ms.ToArray());
    }
}
Dim pdfBytes() As Byte = File.ReadAllBytes("C:\Reports\ConfidentialReport.pdf")
Using aes As Aes = Aes.Create()
	aes.Key = Encoding.UTF8.GetBytes("abcdefghijklmnop")
	aes.IV = New Byte(15){}
	Using encryptor = aes.CreateEncryptor(aes.Key, aes.IV)
	Using ms = New MemoryStream()
		Using cs = New CryptoStream(ms, encryptor, CryptoStreamMode.Write)
			cs.Write(pdfBytes, 0, pdfBytes.Length)
		End Using
		File.WriteAllBytes("C:\Reports\ConfidentialReport.encrypted", ms.ToArray())
	End Using
	End Using
End Using
$vbLabelText   $csharpLabel

Conclusão

Criptografia AES em C# (Como funciona para desenvolvedores): Figura 3 - Licenciamento

A integração do IronPDF com a criptografia AES permite gerar documentos dinâmicos e seguros que são simultaneamente acessíveis e criptografados. Seja para desenvolver aplicações que exigem geração segura de documentos ou para gerenciar relatórios confidenciais, a combinação do IronPDF com criptografia robusta protege seus dados. O IronPDF simplifica o trabalho com PDFs, enquanto o AES garante que o conteúdo permaneça seguro.

O IronPDF oferece um período de teste gratuito , facilitando aos desenvolvedores explorarem seus recursos antes de se comprometerem com a compra. Se você estiver pronto para implementar o IronPDF em seus projetos, as licenças começam em $799 para uma compra única.

Perguntas frequentes

Como posso converter HTML para PDF em C#?

Você pode usar o método RenderHtmlAsPdf do IronPDF para converter strings HTML em PDFs. Você também pode converter arquivos HTML em PDFs usando o RenderHtmlFileAsPdf .

O que é criptografia AES e como ela é usada em C#?

AES (Advanced Encryption Standard) é um algoritmo de criptografia simétrica usado para proteger dados. Em C#, a criptografia AES é implementada usando a classe AES do namespace System.Security.Cryptography. Você cria uma instância de AES, define os parâmetros de chave e vetor de inicialização (IV) e usa a interface ICryptoTransform para criptografar e descriptografar dados.

Quais são os benefícios de usar o modo Cipher Block Chaining (CBC) na criptografia AES?

O modo Cipher Block Chaining (CBC) aumenta a segurança, garantindo que blocos de texto simples idênticos produzam blocos de texto cifrado diferentes. Isso é obtido usando um vetor de inicialização (IV) para encadear a criptografia dos blocos.

Como posso criptografar um documento PDF usando AES em C#?

Para criptografar um PDF usando AES em C#, você pode utilizar o IronPDF para manipular o arquivo PDF e, em seguida, aplicar a criptografia AES criptografando os bytes do PDF com uma chave e um vetor de inicialização (IV) específicos antes de gravar os dados criptografados de volta em um novo arquivo.

Quais são os passos envolvidos na implementação da criptografia AES em uma aplicação C#?

Para implementar a criptografia AES em C#, você precisa criar uma instância de AES, definir a chave e o vetor de inicialização (IV), criar um criptografador e usar MemoryStream e CryptoStream para transformar os dados.

Posso usar uma chave e um vetor de inicialização (IV) personalizados para criptografia AES em C#?

Sim, na criptografia AES, você pode especificar uma chave e um IV personalizados para aumentar a segurança. Recomenda-se gerar valores aleatórios para cada sessão de criptografia para uma melhor proteção.

Como os desenvolvedores podem aprimorar a segurança de documentos PDF em C#?

Os desenvolvedores podem usar o IronPDF combinado com criptografia AES para aprimorar a segurança de documentos PDF em C#, permitindo a criação, edição e proteção de PDFs, incluindo a adição de senhas e assinaturas digitais.

Como o IronPDF ajuda a proteger o conteúdo de PDFs antes do compartilhamento?

O IronPDF ajuda a proteger o conteúdo de PDFs antes do compartilhamento, permitindo que os desenvolvedores criptografem os PDFs usando AES. Esse processo envolve a geração, edição e manipulação de arquivos PDF com métodos de criptografia para garantir a proteção dos dados.

Por que o gerenciamento de chaves é importante na criptografia AES?

O gerenciamento de chaves é crucial na criptografia AES, pois a segurança dos dados criptografados depende fortemente do sigilo e da força da chave de criptografia. Um gerenciamento adequado impede o acesso não autorizado.

Quais são as principais funcionalidades da biblioteca IronPDF para desenvolvedores C#?

A biblioteca IronPDF permite que desenvolvedores C# criem, editem e manipulem documentos PDF com facilidade. Ela oferece suporte a recursos como mesclagem, divisão e proteção de PDFs com criptografia, aprimorando o gerenciamento e a segurança de documentos.

Curtis Chau
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim