Miqo.License

Visão geral

O Miqo.License fornece todas as ferramentas necessárias para emitir, assinar e verificar a autenticidade de uma licença. Os arquivos de licença são assinados digitalmente usando um algoritmo de assinatura digital da curva elípticos de ponta (ECDSA) para garantir que as licenças não possam ser adulteradas após a criação.

A biblioteca está disponível para o .NET Standard 2.0 e .NET Framework 4.0 e superior. O projeto de testes usa .NET Core 2.0. A biblioteca e o pacote Nuget são assinados.

Características

A biblioteca Miqo.license facilita:

• Crie, assine e valide suas licenças com segurança.
• Apoie vários tipos/modelos de licença, incluindo teste, padrão, pessoal, etc.
• Ativar/desativar os recursos do produto.
• Adicione atributos adicionais à licença, conforme necessário.
• Salve como um arquivo JSON ou em uma string formatada JSON.

Instalação

A biblioteca está disponível como um pacote Nuget assinado.

 PM> Install-Package Miqo.License

Uso

Crie uma chave pública e privada para o seu produto

Antes de assinar um arquivo de licença, você precisará de uma chave pública e privada. O MIQO.LICense usa um algoritmo de assinatura digital da curva elípticos (ECDSA) para garantir que os arquivos de licença não possam ser adulterados após a criação. A chave privada é usada para assinar o arquivo de licença e a chave pública é usada para verificar a autenticidade da licença.

Você pode usar a ferramenta de criação de chaves em agrupamento ou criar um novo par usando Signer() como este:

 var signer = new Miqo . License . ECC . Signer ( ) ;
var privateKey = signer . PrivateKey ;
var publicKey = signer . PublicKey ;

Use Signer(privateKeyString) para fornecer uma chave privada gerada anteriormente.

A chave privada deve ser armazenada com segurança e deve ser única para cada um de seus produtos. A chave pública é distribuída com seu software. Se você deseja que seu cliente compre uma nova licença em cada grande lançamento, você pode criar um par de chaves para cada lançamento e produto.

Crie uma nova licença

Depois de gerar os pares de chaves para o seu produto, você está pronto para criar uma nova licença. A maneira mais fácil de fazer isso é usar a classe fluentlicense.

 var license = FluentLicense . CreateLicense ( )
	. WithUniqueIdentifier ( Guid . NewGuid ( ) )
	. As ( LicenseType . Standard )
	. ExpiresAt ( DateTime . Today . AddYears ( 1 ) )
	. ForProduct ( "Chewing Gum" )
	. LicensedTo ( new Customer {
				Name = @"Angus 'Mac' MacGyver" ,
				Email = "[email protected]" ,
				Company = "Phoenix Foundation"
			} )
	. SignLicenseWithPrivateKey ( privateKey ) ;

A licença agora está assinada e você está pronto para salvá -lo como um arquivo JSON:

 license . Save ( "ChewingGum.License" ) ;

Se você deseja armazenar o arquivo de licença de um banco de dados ou outra moda, pode usar:

 var jsonString = license . ToJsonString ( ) ;

Carregando uma licença

Carregue a licença de um arquivo:

 var license = License . Load ( "ChewingGum.License" ) ;

Você também pode carregar uma licença de uma string:

 var license = License . LoadFromString ( jsonString ) ;

Validar a licença em seu aplicativo

Agora você pode começar a validar a licença:

 using Miqo . License . Validation ;

var validationFailures = license . Validate ( )
	. ProductName ( "Chewing Gum" )
	. And ( )
	. ExpirationDate ( )
	. And ( )
	. Signature ( publicKey )
	. AssertValidLicense ( ) ;

O Miqo.license não lançará nenhuma exceção quando uma validação falhar, mas retornará uma enumeração de falhas de validação.

Basta verificar se há alguma falha:

 if ( validationFailures . Any ( ) ) {
	.. .

Ou se você quiser iterar sobre cada falha.

 foreach ( var failure in validationFailures ) {
	Console . WriteLine ( $ " { failure . GetType ( ) . Name } : { failure . Message } - { failure . HowToResolve } " ) ;
}

Use validationFailures.ToList(); Antes de tentar usar o resultado várias vezes.

Convertendo entre byte[] e string hexadecipal

Observe que o miqo.license usa byte[] para as chaves privadas e públicas. Você pode usar a classe de extensão HexExtensions para converter rapidamente entre a string byte[] e Hex.

 byte [ ] publicKey = ECC . HexExtensions . ToHex ( publicKeyHexString ) ;
string hex = ECC . HexExtensions . HexToBytes ( publicKey ) 

Formato do arquivo de licença

O arquivo de licença é salvo no formato JSON padrão.

{
  "license" : {
    "id" : " 39bca166-e7ad-471a-955c-873673a9115d " ,
    "createdAt" : " 2018-07-24T19:36:57.1917491Z " ,
    "product" : " Chewing Gum " ,
    "licenseType" : " Standard " ,
    "customer" : {
      "name" : " Angus 'Mac' MacGyver " ,
      "company" : " Phoenix Foundation " ,
      "email" : " [email protected] "
    },
    "expiresAt" : " 2019-07-24T00:00:00+02:00 "
  },
  "signature" : " ee9wYUeADZUlP7+Q+3PdrtBXqb4ricPlebTBbkMmYEdsPt/D3f6vVwlKQ4jrN1pGECaCTmljMOWWfDUNknLGdA== "
}

Ferramenta de criação -chave

Você pode usar a ferramenta de criação de chaves agrupadas para gerar rapidamente um novo par de chaves no formato de string hexadecimal.

Agradecimentos

Miqo.license foi inspirado por portátil.licensing (por Daniel Nauck, nauck It) e usa parte do código de validação.

Duas outras bibliotecas também são usadas para a parte do ECDSA.

• A assinatura é feita usando a criptografia.Ecdsa (por cadeias)
• A verificação da assinatura é feita usando o Charengine.cryptography.ecdsa.secpp256k1 (por uchaindb)

Licença

Miqo.license é disponibilizado sob a licença do MIT.