A criptografia pode ajudar a proteger os dados contra visualização e modificação e pode ajudar a fornecer um meio de comunicação seguro em canais que de outra forma seriam inseguros. Por exemplo, os dados podem ser criptografados usando um algoritmo de criptografia, transmitidos em um estado criptografado e depois descriptografados pelo destinatário pretendido. Se terceiros interceptarem dados criptografados, será difícil descriptografá-los.
Para atingir esses objetivos, você cria esquemas de criptografia usando uma combinação de algoritmos e convenções, chamados de primitivos de criptografia. Incluindo criptografia de chave privada (criptografia simétrica), criptografia de chave pública (criptografia assimétrica), assinaturas criptográficas e hashes criptográficos.
Usamos criptografia de chave pública (criptografia assimétrica) para implementar o algoritmo do código de registro.
A criptografia de chave pública usa uma chave privada que deve ser mantida em segredo de usuários não autorizados e uma chave pública que pode ser tornada pública para qualquer pessoa. As chaves pública e privada estão matematicamente relacionadas; os dados criptografados com a chave pública só podem ser descriptografados com a chave privada, enquanto os dados assinados com a chave privada só podem ser verificados com a chave pública.
Para o código de registro, usamos a chave privada para assinar uma string (nome de usuário) e depois usamos a chave pública para verificar a assinatura (código de registro). Como a chave pública só pode ser usada para verificação, podemos distribuir a chave pública com confiança, a chave privada é usada para assinatura, portanto a chave privada deve ser mantida nas mãos do desenvolvedor. Desta forma, o objetivo da certificação do registro é alcançado. Todos os softwares atualmente registrados no modo "nome de usuário, código de registro" devem utilizar esta tecnologia.
Primeiro, geramos uma chave pública e uma chave privada que queremos usar.
Rsa privado como novo Security.Cryptography.RSACryptoServiceProvider
A classe RSACryptoServiceProvider fornece uma implementação do algoritmo RSA para executar criptografia e descriptografia assimétricas. As chaves públicas e privadas de que precisamos podem ser geradas por meio de ToXMLString.
rsa.ToXmlString(False)
rsa.ToXmlString(True)
Quando o parâmetro for False, somente a chave pública será gerada; quando True, serão geradas tanto a chave pública quanto a chave privada. Geralmente obtemos uma string de chave pública por meio de ToXmlString(False); obtemos uma string de chave privada por meio de ToXmlString(True) (embora contenha a chave pública). Podemos salvar essas duas chaves na máquina local, defini-las e utilizá-las por meio de constantes de string. Em outras palavras, nossas informações de registro utilizarão chaves públicas e privadas exclusivas.
Em seguida, assinamos a string especificada com as chaves pública e privada.
rsa.FromXmlString(PRIVATE_KEY)
Dim f As New Security.Cryptography.RSAPKCS1SignatureFormatter(rsa)
f.SetHashAlgorithm("SHA1")
Dim source() As Byte = System.Text.ASCIIEncoding.ASCII.GetBytes(UID)
Dim sha como nova segurança .Cryptography.SHA1Managed
Dim result() As Byte = sha.ComputeHash(source)
Dim regkey() As Byte = f.CreateSignature(result)
SerialNumber = Convert.ToBase64String(regkey)
Reinicialize o objeto rsa com a chave privada que acabamos de obter e, em seguida, a assinatura é executada por meio da classe RSAPKCS1SignatureFormatter. Convertemos a string de entrada em uma matriz de bytes (nosso nome de usuário padrão aqui só pode ser composto de caracteres ASCII) e calculamos seu valor de hash por meio do algoritmo de hash SHA1. Em seguida, use o método CreateSignature para assinar o valor hash obtido. Finalmente, convertemos a matriz de bytes obtida em uma string como código de registro. Este é o processo de geração de um código de registro. Podemos reutilizar este programa para assinar diferentes nomes de usuário para obter diferentes códigos de registro correspondentes a eles.
Por fim, verificamos o nome de usuário e o código de registro que acabamos de obter.
rsa.FromXmlString(PUBLIC_KEY)
Dim f As New Security.Cryptography.RSAPKCS1SignatureDeformatter(rsa)
f.SetHashAlgorithm("SHA1")
Dim key() As Byte = Convert.FromBase64String(SerialNumber)
Dim sha As New Security.Cryptography.SHA1Managed
Dim name () As Byte = sha.ComputeHash(System.Text.ASCIIEncoding.ASCII.GetBytes(UID))
Result = f.VerifySignature(name, key)
Desta vez, usamos a chave pública para inicializar o objeto rsa e, em seguida, verificar a assinatura através da classe RSAPKCS1SignatureDeformatter. Convertemos inversamente o código de registro obtido em uma matriz de bytes e realizamos cálculo de hash no nome do usuário para obter o valor de hash; Por fim, verifique-o através do VerifySignature.
Como pode ser visto no programa acima, uma chave privada é necessária para gerar um código de registro (a chave privada é acompanhada por informações de chave pública), e qualquer número de pares de nome de usuário e código de registro pode ser gerado. Com a chave pública, podemos apenas verificar, mas não gerar. Portanto, a chave pública pode ser distribuída com segurança a todos os usuários para verificação, mas a chave privada não. Portanto, a chave pública e o algoritmo de verificação podem ser incluídos na versão lançada. Porque mesmo que o usuário obtenha a chave pública e o algoritmo de verificação, ela não pode ser facilmente quebrada.
As populares máquinas de registro na Internet hoje em dia quebram em grande parte a chave privada do software, conseguindo assim a geração ilimitada das informações de registro necessárias. Mas se os usuários descompilarem seu produto e modificarem o código intermediário, isso ignorará a lógica de julgamento de registro. Este não é um problema que este artigo possa resolver. Porque mesmo se você usar a tecnologia de serviço da Web para ativação ou registro online, ainda poderá analisar as informações do servidor por meio da escuta da rede e simular um servidor falso.
http://www.cnblogs.com/farrio/archive/2006/12/01/579296.html