release/src-rt-6.x/linux/linux-2.6/fs/ecryptfs/debug.c

   1 /**
   2  * eCryptfs: Linux filesystem encryption layer
   3  * Functions only useful for debugging.
   4  *
   5  * Copyright (C) 2006 International Business Machines Corp.
   6  *   Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of the
  11  * License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  21  * 02111-1307, USA.
  22  */
  23
  24 #include "ecryptfs_kernel.h"
  25
  26 /**
  27  * ecryptfs_dump_auth_tok - debug function to print auth toks
  28  *
  29  * This function will print the contents of an ecryptfs authentication
  30  * token.
  31  */
  32 void ecryptfs_dump_auth_tok(struct ecryptfs_auth_tok *auth_tok)
  33 {
  34         char salt[ECRYPTFS_SALT_SIZE * 2 + 1];
  35         char sig[ECRYPTFS_SIG_SIZE_HEX + 1];
  36
  37         ecryptfs_printk(KERN_DEBUG, "Auth tok at mem loc [%p]:\n",
  38                         auth_tok);
  39         if (auth_tok->flags & ECRYPTFS_PRIVATE_KEY) {
  40                 ecryptfs_printk(KERN_DEBUG, " * private key type\n");
  41                 ecryptfs_printk(KERN_DEBUG, " * (NO PRIVATE KEY SUPPORT "
  42                                 "IN ECRYPTFS VERSION 0.1)\n");
  43         } else {
  44                 ecryptfs_printk(KERN_DEBUG, " * passphrase type\n");
  45                 ecryptfs_to_hex(salt, auth_tok->token.password.salt,
  46                                 ECRYPTFS_SALT_SIZE);
  47                 salt[ECRYPTFS_SALT_SIZE * 2] = '\0';
  48                 ecryptfs_printk(KERN_DEBUG, " * salt = [%s]\n", salt);
  49                 if (auth_tok->token.password.flags &
  50                     ECRYPTFS_PERSISTENT_PASSWORD) {
  51                         ecryptfs_printk(KERN_DEBUG, " * persistent\n");
  52                 }
  53                 memcpy(sig, auth_tok->token.password.signature,
  54                        ECRYPTFS_SIG_SIZE_HEX);
  55                 sig[ECRYPTFS_SIG_SIZE_HEX] = '\0';
  56                 ecryptfs_printk(KERN_DEBUG, " * signature = [%s]\n", sig);
  57         }
  58         ecryptfs_printk(KERN_DEBUG, " * session_key.flags = [0x%x]\n",
  59                         auth_tok->session_key.flags);
  60         if (auth_tok->session_key.flags
  61             & ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT)
  62                 ecryptfs_printk(KERN_DEBUG,
  63                                 " * Userspace decrypt request set\n");
  64         if (auth_tok->session_key.flags
  65             & ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT)
  66                 ecryptfs_printk(KERN_DEBUG,
  67                                 " * Userspace encrypt request set\n");
  68         if (auth_tok->session_key.flags & ECRYPTFS_CONTAINS_DECRYPTED_KEY) {
  69                 ecryptfs_printk(KERN_DEBUG, " * Contains decrypted key\n");
  70                 ecryptfs_printk(KERN_DEBUG,
  71                                 " * session_key.decrypted_key_size = [0x%x]\n",
  72                                 auth_tok->session_key.decrypted_key_size);
  73                 ecryptfs_printk(KERN_DEBUG, " * Decrypted session key "
  74                                 "dump:\n");
  75                 if (ecryptfs_verbosity > 0)
  76                         ecryptfs_dump_hex(auth_tok->session_key.decrypted_key,
  77                                           ECRYPTFS_DEFAULT_KEY_BYTES);
  78         }
  79         if (auth_tok->session_key.flags & ECRYPTFS_CONTAINS_ENCRYPTED_KEY) {
  80                 ecryptfs_printk(KERN_DEBUG, " * Contains encrypted key\n");
  81                 ecryptfs_printk(KERN_DEBUG,
  82                                 " * session_key.encrypted_key_size = [0x%x]\n",
  83                                 auth_tok->session_key.encrypted_key_size);
  84                 ecryptfs_printk(KERN_DEBUG, " * Encrypted session key "
  85                                 "dump:\n");
  86                 if (ecryptfs_verbosity > 0)
  87                         ecryptfs_dump_hex(auth_tok->session_key.encrypted_key,
  88                                           auth_tok->session_key.
  89                                           encrypted_key_size);
  90         }
  91 }
  92
  93 /**
  94  * ecryptfs_dump_hex - debug hex printer
  95  * @data: string of bytes to be printed
  96  * @bytes: number of bytes to print
  97  *
  98  * Dump hexadecimal representation of char array
  99  */
 100 void ecryptfs_dump_hex(char *data, int bytes)
 101 {
 102         int i = 0;
 103         int add_newline = 1;
 104
 105         if (ecryptfs_verbosity < 1)
 106                 return;
 107         if (bytes != 0) {
 108                 printk(KERN_DEBUG "0x%.2x.", (unsigned char)data[i]);
 109                 i++;
 110         }
 111         while (i < bytes) {
 112                 printk("0x%.2x.", (unsigned char)data[i]);
 113                 i++;
 114                 if (i % 16 == 0) {
 115                         printk("\n");
 116                         add_newline = 0;
 117                 } else
 118                         add_newline = 1;
 119         }
 120         if (add_newline)
 121                 printk("\n");
 122 }
 123