Miqo.License

Aperçu

Miqo.License vous fournit tous les outils nécessaires pour émettre, signer et vérifier l'authenticité d'une licence. Les fichiers de licence sont signés numériquement à l'aide d'un algorithme de signature numérique de courbe elliptique de pointe (ECDSA) pour s'assurer que les licences ne peuvent pas être falsifiées après la création.

La bibliothèque est disponible pour .NET Standard 2.0 et .NET Framework 4.0 et plus. Le projet Tests utilise .NET Core 2.0. La bibliothèque et le package NuGet sont signés.

Caractéristiques

La bibliothèque Miqo.License facilite la question de:

• Créer, signer et valider en toute sécurité vos licences.
• Soutenez divers types de licences / modèles, y compris l'essai, la norme, le personnel, etc.
• Activer / désactiver les fonctionnalités du produit.
• Ajoutez des attributs supplémentaires à la licence au besoin.
• Enregistrer en tant que fichier JSON ou dans une chaîne formatée JSON.

Installation

La bibliothèque est disponible en tant que package NuGet signé.

 PM> Install-Package Miqo.License

Usage

Créez une clé privée et publique pour votre produit

Avant de signer un fichier de licence, vous aurez besoin d'une clé privée et publique. Miqo.License utilise un algorithme de signature numérique de courbe elliptique (ECDSA) pour s'assurer que les fichiers de licence ne peuvent pas être falsifiés après la création. La clé privée est utilisée pour signer le fichier de licence et la clé publique est utilisée pour vérifier l'authenticité de la licence.

Vous pouvez utiliser l'outil de création de clés groupé ou créer une nouvelle paire en utilisant Signer() comme ceci:

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

Utilisez Signer(privateKeyString) pour fournir une clé privée précédemment générée.

La clé privée doit être stockée en toute sécurité et doit être unique pour chacun de vos produits. La clé publique est distribuée avec votre logiciel. Si vous souhaitez que votre client achète une nouvelle licence sur chaque version majeure, vous pouvez créer une paire de clés pour chaque version et produit.

Créer une nouvelle licence

Après avoir généré les paires clés de votre produit, vous êtes prêt à créer une nouvelle licence. La façon la plus simple de le faire est d'utiliser la classe Cluentlicence.

 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 ) ;

La licence est désormais signée et vous êtes prêt à l'enregistrer en tant que fichier JSON:

 license . Save ( "ChewingGum.License" ) ;

Si vous souhaitez stocker le fichier de licence dans une base de données ou une autre manière, vous pouvez utiliser:

 var jsonString = license . ToJsonString ( ) ;

Chargement d'une licence

Chargez la licence à partir d'un fichier:

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

Vous pouvez également charger une licence à partir d'une chaîne:

 var license = License . LoadFromString ( jsonString ) ;

Valider la licence dans votre demande

Vous pouvez maintenant commencer à valider la licence:

 using Miqo . License . Validation ;

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

MIQO.LICENCE ne lancera aucune exception lorsqu'une validation échoue, mais renvoie plutôt une énumération des défaillances de validation.

Vérifiez simplement s'il y a un échec:

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

Ou si vous souhaitez itérer sur chaque utilisation de l'échec:

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

Utiliser validationFailures.ToList(); avant d'essayer d'utiliser le résultat plusieurs fois.

Conversion entre byte[] et string hexagonale

Notez que Miqo.License utilise byte[] pour les clés privées et publiques. Vous pouvez utiliser la classe d'extension HexExtensions pour vous convertir rapidement entre l' byte[] et string hexagonale.

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

Format de fichier de licence

Le fichier de licence est enregistré au format JSON standard.

{
  "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== "
}

Outil de création clé

Vous pouvez utiliser l'outil de création de clés groupé pour générer rapidement une nouvelle paire de clés au format de chaîne hexagonale.

Remerciements

Miqo.License a été inspiré par Portable.licensing (par Daniel Nauck, Nauck It) et utilise une partie du code de validation.

Deux autres bibliothèques sont également utilisées pour la partie ECDSA.

• La signature se fait à l'aide de cryptographie.ecdsa (par des chaînes)
• La vérification de la signature se fait à l'aide de Chainngine.cryptography.ecdsa.secp256k1 (par uchaindb)

Licence

MIQO.LICENCE est mis à disposition sous la licence MIT.