Classe Crypto

Les méthodes de la classe Crypto fournissent des algorithmes standard pour la création de résumés, de codes d'authentification de messages et de signatures, ainsi que des informations de chiffrement et de déchiffrement. Ils peuvent être utilisés pour la protection de contenus dans Force.com ou l'intégration à des services externes tels que Google ou les services Web Amazon (AWS).

Nom	Arguments	Type de renvoi	Description
`decrypt`	String `algorithmName` Blob `privateKey` Blob `initializationVector` Blob `cipherText`	Blob	Déchiffre le blob `cipherText` en utilisant l'algorithme, la clé privée et le vecteur d'initialisation spécifiés. Utilisez cette méthode pour déchiffrer des bobs cryptés en utilisant une application tierce ou la méthode `encrypt`. Les valeurs valides pour `algorithmName` sont : AES128 AES192 AES256 Ils représentent tous les algorithmes des normes de chiffrement AES (Advanced Encryption Standard) du marché, avec les différentes tailles de clé. Ils utilisent le chaînage pour chiffrement par bloc (CBC) et le padding PKCS5. La longueur de `privateKey` doit correspondre à l'algorithme spécifié : 128 bits, 192 bits ou 256 bits qui correspond respectivement à 16, 24 ou 32 octets. Vous pouvez utiliser une application tierce ou la méthode `generateAesKey` pour générer cette clé. Le vecteur d'initialisation doit être en 128 bits (16 octets). Pour consulter un exemple, reportez-vous à Exemple de chiffrement et de déchiffrement. Pour plus d'informations sur les exceptions qui peuvent être levées durant l'exécution, reportez-vous à Chiffrement et déchiffrement des exceptions.
`decryptWithManagedIV`	String `algorithmName` Blob `privateKey` Blob `IVAndCipherText`	Blob	Déchiffre le blob `IVAndCipherText` en utilisant l'algorithme et la clé privée spécifiés. Utilisez cette méthode pour déchiffrer des blobs cryptés avec une application tierce ou la méthode `encryptWithManagedIV`. Les valeurs valides pour `algorithmName` sont : AES128 AES192 AES256 Ils représentent tous les algorithmes des normes de chiffrement AES (Advanced Encryption Standard) du marché, avec les différentes tailles de clé. Ils utilisent le chaînage pour chiffrement par bloc (CBC) et le padding PKCS5. La longueur de `privateKey` doit correspondre à l'algorithme spécifié : 128 bits, 192 bits ou 256 bits qui correspond respectivement à 16, 24 ou 32 octets. Vous pouvez utiliser une application tierce ou la méthode `generateAesKey` pour générer cette clé. Les 128 premiers bits (16 octets) de `IVAndCipherText` doivent inclure le vecteur d'initialisation. Pour consulter un exemple, reportez-vous à Exemple de chiffrement et de déchiffrement. Pour plus d'informations sur les exceptions qui peuvent être levées durant l'exécution, reportez-vous à Chiffrement et déchiffrement des exceptions.
`encrypt`	String `algorithmName` Blob `privateKey` Blob `initializationVector` Blob `clearText`	Blob	Chiffre le blob `clearText` en utilisant l'algorithme, la clé privée et le vecteur d'initialisation spécifiés. Utilisez cette méthode lorsque vous souhaitez spécifier votre propre vecteur d'initialisation. Le vecteur d'initialisation doit être en 128 bits (16 octets). Utilisez une application tierce ou la méthode `decrypt` pour déchiffrer des blobs cryptés avec cette méthode. Utilisez la méthode `encryptWithManagedIV` si vous souhaitez que Salesforce génère un code d'initialisation pour vous. Il est stocké dans les 128 premiers bits (16 octets) du blob déchiffré. Les valeurs valides pour `algorithmName` sont : AES128 AES192 AES256 Ils représentent tous les algorithmes des normes de chiffrement AES (Advanced Encryption Standard) du marché, avec les différentes tailles de clé. Ils utilisent le chaînage pour chiffrement par bloc (CBC) et le padding PKCS5. La longueur de `privateKey` doit correspondre à l'algorithme spécifié : 128 bits, 192 bits ou 256 bits qui correspond respectivement à 16, 24 ou 32 octets. Vous pouvez utiliser une application tierce ou la méthode `generateAesKey` pour générer cette clé. Pour consulter un exemple, reportez-vous à Exemple de chiffrement et de déchiffrement. Pour plus d'informations sur les exceptions qui peuvent être levées durant l'exécution, reportez-vous à Chiffrement et déchiffrement des exceptions.
`encryptWithManagedIV`	String `algorithmName` Blob `privateKey` Blob `clearText`	Blob	Chiffre le blob `clearText` en utilisant l'algorithme et la clé privée spécifiés. Utilisez cette méthode si vous souhaitez que Salesforce génère un code d'initialisation pour vous. Il est stocké dans les 128 premiers bits (16 octets) du blob déchiffré. Utilisez une application tierce ou la méthode `decryptWithManagedIV` pour déchiffrer des blobs cryptés avec cette méthode. Utilisez la méthode `encrypt` si vous souhaitez générer votre propre vecteur d'initialisation. Les valeurs valides pour `algorithmName` sont : AES128 AES192 AES256 Ils représentent tous les algorithmes des normes de chiffrement AES (Advanced Encryption Standard) du marché, avec les différentes tailles de clé. Ils utilisent le chaînage pour chiffrement par bloc (CBC) et le padding PKCS5. La longueur de `privateKey` doit correspondre à l'algorithme spécifié : 128 bits, 192 bits ou 256 bits qui correspond respectivement à 16, 24 ou 32 octets. Vous pouvez utiliser une application tierce ou la méthode `generateAesKey` pour générer cette clé. Pour consulter un exemple, reportez-vous à Exemple de chiffrement et de déchiffrement. Pour plus d'informations sur les exceptions qui peuvent être levées durant l'exécution, reportez-vous à Chiffrement et déchiffrement des exceptions.
`generateAesKey`	Integer `size`	Blob	Génère une clé Advanced Encryption Standard (AES). Utilisez `size` pour spécifier la taille de la clé en bits. Les valeurs valides sont : 128 192 256
`generateDigest`	String `algorithmName` Blob `input`	Blob	Génère un résumé unidirectionnel haché et sécurisé, basé sur la chaîne d'entrée et le nom de l'algorithme fournis. Les valeurs valides pour `algorithmName` sont : MD5 SHA1 SHA-256 SHA-512
`generateMac`	String `algorithmName` Blob `input` Blob `privateKey`	Blob	Génère un code d'authentification de messages (MAC) pour la chaîne d'entrée, en utilisant la clé privée et l'algorithme spécifié. Les valeurs valides pour `algorithmName` sont : hmacMD5 hmacSHA1 hmacSHA256 hmacSHA512 La valeur de `privateKey` ne doit pas être en format décodé. La valeur ne peut pas dépasser 4 Ko.
`getRandomInteger`		Integer	Renvoie un nombre entier aléatoire.
`getRandomLong`		Long	Renvoie un entier long aléatoire.
`sign`	String `algorithmName` Blob `input` Blob `privateKey`	Blob	Génère une signature numérique unique pour la chaîne d'entrée, en utilisant la clé privée et l'algorithme spécifié. Les valeurs valides pour `algorithmName` sont `RSA-SHA1` ou `RSA`. Les deux valeurs représentent le même algorithme. La valeur de `privateKey` doit être encodée en utilisant la méthode `EncodingUtilbase64Decode` et être en format RSA PKCS #8 (1.2) Private-Key Information Syntax Standard. La valeur ne peut pas dépasser 4 Ko. L'extrait de code suivant est un exemple de déclaration et d'initialisation : String algorithmName = 'RSA'; String key = '`pkcs8 format private key`'; Blob privateKey = EncodingUtil.base64Decode(key); Blob input = Blob.valueOf('12345qwerty'); Crypto.sign(algorithmName, input, privateKey);

Exemple d'intégration des services Web Amazon

L'exemple suivant montre une intégration des services Web Amazon à Salesforce :

public class HMacAuthCallout {



   public void testAlexaWSForAmazon() {

 

   // The date format is yyyy-MM-dd'T'HH:mm:ss.SSS'Z'

      DateTime d = System.now();

      String timestamp = ''+ d.year() + '-' +

      d.month() + '-' +

      d.day() + '\'T\'' +

      d.hour() + ':' +

      d.minute() + ':' +

      d.second() + '.' +

      d.millisecond() + '\'Z\'';

      String timeFormat = d.formatGmt(timestamp);



      String urlEncodedTimestamp = EncodingUtil.urlEncode(timestamp, 'UTF-8');

      String action = 'UrlInfo';

      String inputStr = action + timeFormat;

      String algorithmName = 'HMacSHA1';

      Blob mac = Crypto.generateMac(algorithmName,  Blob.valueOf(inputStr), 

                                                    Blob.valueOf('your_signing_key'));

      String macUrl = EncodingUtil.urlEncode(EncodingUtil.base64Encode(mac), 'UTF-8');

 

      String urlToTest = 'amazon.com';

      String version = '2005-07-11'; 

      String endpoint = 'http://awis.amazonaws.com/';

      String accessKey = 'your_key';

 

      HttpRequest req = new HttpRequest();

      req.setEndpoint(endpoint +

                      '?AWSAccessKeyId=' + accessKey +

                      '&Action=' + action +

                      '&ResponseGroup=Rank&Version=' + version +

                      '&Timestamp=' + urlEncodedTimestamp +

                      '&Url=' + urlToTest +

                      '&Signature=' + macUrl);

 

      req.setMethod('GET');

      Http http = new Http();

      try {

         HttpResponse res = http.send(req);

         System.debug('STATUS:'+res.getStatus());

         System.debug('STATUS_CODE:'+res.getStatusCode());

         System.debug('BODY: '+res.getBody());

      } catch(System.CalloutException e) {

         System.debug('ERROR: '+ e);

      }

   }

}

Exemple de chiffrement et de déchiffrement

L'exemple suivant utilise les méthodes encryptWithManagedIV et decryptWithManagedIV, ainsi que la méthode generateAesKey.

// Use generateAesKey to generate the private key

Blob cryptoKey = Crypto.generateAesKey(256);



// Generate the data to be encrypted.

Blob data = Blob.valueOf('Test data to encrypted');



// Encrypt the data and have Salesforce.com generate the initialization vector 

Blob encryptedData = Crypto.encryptWithManagedIV('AES256', cryptoKey, data);



// Decrypt the data

Blob decryptedData = Crypto.decryptWithManagedIV('AES256', cryptoKey, encryptedData);

L'exemple suivant montre l'écriture d'un test unitaire pour les méthodes encryptWithManagedIV et decryptWithManagedIV.

@isTest

private class CryptoTest {

    public static testMethod void testValidDecryption() {



        // Use generateAesKey to generate the private key

        Blob key = Crypto.generateAesKey(128);

        // Generate the data to be encrypted.

        Blob data = Blob.valueOf('Test data');

        // Generate an encrypted form of the data using base64 encoding

        String b64Data = EncodingUtil.base64Encode(data);

        // Encrypt and decrypt the data

        Blob encryptedData = Crypto.encryptWithManagedIV('AES128', key, data);

        Blob decryptedData = Crypto.decryptWithManagedIV('AES128', key, encryptedData);

        String b64Decrypted = EncodingUtil.base64Encode(decryptedData);

        // Verify that the strings still match

        System.assertEquals(b64Data, b64Decrypted);

    }

    public static testMethod void testInvalidDecryption() {

        // Verify that you must use the same key size for encrypting data

        // Generate two private keys, using different key sizes

        Blob keyOne = Crypto.generateAesKey(128);

        Blob keyTwo = Crypto.generateAesKey(256);

        // Generate the data to be encrypted.

        Blob data = Blob.valueOf('Test data');

        // Encrypt the data using the first key 

        Blob encryptedData = Crypto.encryptWithManagedIV('AES128', keyOne, data);

        try {

         // Try decrypting the data using the second key   

            Crypto.decryptWithManagedIV('AES256', keyTwo, encryptedData);

            System.assert(false);

        } catch(SecurityException e) {

            System.assertEquals('Given final block not properly padded', e.getMessage());

        }

    }

}

Exceptions de chiffrement et de déchiffrement

Les exceptions suivantes peuvent être levées pour ces méthodes :

decrypt
encrypt
decryptWithManagedIV
encryptWithManagedIV

Exception	Message	Description
InvalidParameterValue	Unable to parse initialization vector from encrypted data.	Levée si vous utilisez des vecteurs d'initialisation gérés et si le texte cipher est inférieur à 16 octets.
InvalidParameterValue	Invalid algorithm `algoName`. Must be AES128, AES192, or AES256.	Levée si le nom de l'algorithme ne correspond pas à l'une des valeurs valides.
InvalidParameterValue	Invalid private key. Must be `size` bytes.	Levée si la taille de la clé privée ne correspond pas à l'algorithme spécifié.
InvalidParameterValue	Invalid initialization vector. Must be 16 bytes.	Levée si le vecteur d'initialisation n'est pas 16 octets.
InvalidParameterValue	Invalid data. Input data is `size` bytes, which exceeds the limit of 1048576 bytes.	Levée si les données sont supérieures à 1 Mo. Pour le déchiffrement, 1048608 octets sont autorisés pour l'en-tête du vecteur d'initialisation, plus tout remplissage de chiffrement supplémentaire ajouté pour l'ajuster à la taille du bloc.
NullPointerException	Argument cannot be null.	Levée si l'un des arguments de méthode requis est null.
SecurityException	Given final block not properly padded.	Levée si les données ne sont pas correctement alignées au bloc, ou si des problèmes similaires se produisent durant le chiffrement ou le déchiffrement.
SecurityException	`Le message varie`	Levée si un problème survient durant le chiffrement ou le déchiffrement.