comment utiliser CryptoAPI dans le noyau linux 2.6

J'ai été la recherche de quelques temps mais n'ont pas trouvé n'importe où près de suffisamment de documentation et des exemples sur la façon d'utiliser le CryptoAPI qui est livré avec linux dans la création de syscalls /dans le noyau de la terre.

Si quelqu'un connaît une bonne source s'il vous plaît laissez-moi savoir, je voudrais savoir comment faire SHA1 et MD5 et Blowfish /AES au sein de l'espace du noyau.

source d'informationauteur Conor

  1. 6

    Il y a quelques endroits dans le noyau qui utilisent le module crypto: le eCryptfs système de fichiers (linux/fs/ecryptfs/) et la norme 802.11 sans fil pile (linux/drivers/mise en scène/rtl8187se/ieee80211/). Ces deux utiliser AES, mais vous pouvez être en mesure d'extrapoler ce que vous y trouvez du MD5.

  2. 11
    #include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/crypto.h>
#include <linux/err.h>
#include <linux/scatterlist.h>

#define SHA1_LENGTH     20

static int __init sha1_init(void)
{
    struct scatterlist sg;
    struct crypto_hash *tfm;
    struct hash_desc desc;
    unsigned char output[SHA1_LENGTH];
    unsigned char buf[10];
    int i;

    printk(KERN_INFO "sha1: %s\n", __FUNCTION__);

    memset(buf, 'A', 10);
    memset(output, 0x00, SHA1_LENGTH);

    tfm = crypto_alloc_hash("sha1", 0, CRYPTO_ALG_ASYNC);

    desc.tfm = tfm;
    desc.flags = 0;

    sg_init_one(&sg, buf, 10);
    crypto_hash_init(&desc);

    crypto_hash_update(&desc, &sg, 10);
    crypto_hash_final(&desc, output);

    for (i = 0; i < 20; i++) {
        printk(KERN_ERR "%d-%d\n", output[i], i);
    }

    crypto_free_hash(tfm);

    return 0;
}

static void __exit sha1_exit(void)
{
    printk(KERN_INFO "sha1: %s\n", __FUNCTION__);
}

module_init(sha1_init);
module_exit(sha1_exit);

MODULE_LICENSE("Dual MIT/GPL");
MODULE_AUTHOR("Me");
  3. 6

    Un autre bon exemple est le noyau 2.6.18 source de sécurité/seclvl.c

    Remarque: Vous pouvez modifier CRYPTO_TFM_REQ_MAY_SLEEP si nécessaire

    static int
plaintext_to_sha1(unsigned char *hash, const char *plaintext, unsigned int len)
{
  struct crypto_tfm *tfm;
  struct scatterlist sg;
  if (len > PAGE_SIZE) {
    seclvl_printk(0, KERN_ERR, "Plaintext password too large (%d "
            "characters).  Largest possible is %lu "
            "bytes.\n", len, PAGE_SIZE);
    return -EINVAL;
  }
  tfm = crypto_alloc_tfm("sha1", CRYPTO_TFM_REQ_MAY_SLEEP);
  if (tfm == NULL) {
    seclvl_printk(0, KERN_ERR,
            "Failed to load transform for SHA1\n");
    return -EINVAL;
  }
  sg_init_one(&sg, (u8 *)plaintext, len);
  crypto_digest_init(tfm);
  crypto_digest_update(tfm, &sg, 1);
  crypto_digest_final(tfm, hash);
  crypto_free_tfm(tfm);
  return 0;
}
  4. 2

    Cryptodev-linux

    https://github.com/cryptodev-linux/cryptodev-linux

    C'est un module du noyau qui expose le noyau de la crypto API vers l'espace utilisateur, par le biais de /dev/crypto .

    SHA exemple de calcul: https://github.com/cryptodev-linux/cryptodev-linux/blob/da730106c2558c8e0c8e1b1b1812d32ef9574ab7/examples/sha.c

    Comme d'autres l'ont mentionné, le noyau ne semble pas exposer l'API de chiffrement à l'espace utilisateur lui-même, ce qui est dommage puisque le noyau peut déjà utiliser natif de l'accélération matérielle de la crypto fonctions en interne.

    Crypto opérations cryptodev prend en charge: https://github.com/nmav/cryptodev-linux/blob/383922cabeea7dca354415e8c590f8e932f4d7a8/crypto/cryptodev.h

    Crypto opérations Linux x86 prend en charge: https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/arch/x86/crypto?id=refs/tags/v4.0

  5. 1

    Le meilleur endroit pour commencer est de Documentation/crytpo dans les sources du noyau. dm-crypt est l'un des nombreux composants qui utilise probablement le noyau de la crypto API et vous pouvez vous y reporter pour avoir une idée sur l'utilisation.

  6. 1

    comment faire SHA1 et MD5 et Blowfish /AES au sein de l'espace du noyau.

    Exemple de hachage de données à l'aide de deux éléments scatterlist:

    struct crypto_hash *tfm = crypto_alloc_hash("sha1", 0, CRYPTO_ALG_ASYNC); 
si (tfm == NULL) 
l'échec; 
char *output_buf = kmalloc(crypto_hash_digestsize(tfm), GFP_KERNEL); 
si (output_buf == NULL) 
l'échec; 
struct scatterlist sg[2]; 
struct hash_desc desc = {.tfm = tfm}; 
ret = crypto_hash_init(&desc); 
if (ret != 0) 
l'échec; 
sg_init_table(sg, ARRAY_SIZE(sg)); 
sg_set_buf(&sg[0], "Bonjour", 5); 
sg_set_buf(&sg[1], "le Monde", 6); 
ret = crypto_hash_digest(&desc, sg, 11, output_buf); 
if (ret != 0) 
l'échec;
  7. 1

    Une critique remarque:

    Ne jamais comparer la valeur de retour de crypto_alloc_hash la fonction NULL pour la détection de la défaillance.

    Suit:

    Toujours utiliser IS_ERR la fonction de ce but. En comparant à NULL ne capture pas l'erreur, par conséquent, vous obtenez la segmentation des fautes plus tard.

    Si IS_ERR retourne échouent, vous avez probablement manque un algorithme de chiffrement compilé dans l'image du noyau (ou un module). Assurez-vous d'avoir choisi la crypto algo. forme make menuconfig.