LXR linux/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 */
  32void 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        } else {
  42                ecryptfs_printk(KERN_DEBUG, " * passphrase type\n");
  43                ecryptfs_to_hex(salt, auth_tok->token.password.salt,
  44                                ECRYPTFS_SALT_SIZE);
  45                salt[ECRYPTFS_SALT_SIZE * 2] = '\0';
  46                ecryptfs_printk(KERN_DEBUG, " * salt = [%s]\n", salt);
  47                if (auth_tok->token.password.flags &
  48                    ECRYPTFS_PERSISTENT_PASSWORD) {
  49                        ecryptfs_printk(KERN_DEBUG, " * persistent\n");
  50                }
  51                memcpy(sig, auth_tok->token.password.signature,
  52                       ECRYPTFS_SIG_SIZE_HEX);
  53                sig[ECRYPTFS_SIG_SIZE_HEX] = '\0';
  54                ecryptfs_printk(KERN_DEBUG, " * signature = [%s]\n", sig);
  55        }
  56        ecryptfs_printk(KERN_DEBUG, " * session_key.flags = [0x%x]\n",
  57                        auth_tok->session_key.flags);
  58        if (auth_tok->session_key.flags
  59            & ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT)
  60                ecryptfs_printk(KERN_DEBUG,
  61                                " * Userspace decrypt request set\n");
  62        if (auth_tok->session_key.flags
  63            & ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT)
  64                ecryptfs_printk(KERN_DEBUG,
  65                                " * Userspace encrypt request set\n");
  66        if (auth_tok->session_key.flags & ECRYPTFS_CONTAINS_DECRYPTED_KEY) {
  67                ecryptfs_printk(KERN_DEBUG, " * Contains decrypted key\n");
  68                ecryptfs_printk(KERN_DEBUG,
  69                                " * session_key.decrypted_key_size = [0x%x]\n",
  70                                auth_tok->session_key.decrypted_key_size);
  71                ecryptfs_printk(KERN_DEBUG, " * Decrypted session key "
  72                                "dump:\n");
  73                if (ecryptfs_verbosity > 0)
  74                        ecryptfs_dump_hex(auth_tok->session_key.decrypted_key,
  75                                          ECRYPTFS_DEFAULT_KEY_BYTES);
  76        }
  77        if (auth_tok->session_key.flags & ECRYPTFS_CONTAINS_ENCRYPTED_KEY) {
  78                ecryptfs_printk(KERN_DEBUG, " * Contains encrypted key\n");
  79                ecryptfs_printk(KERN_DEBUG,
  80                                " * session_key.encrypted_key_size = [0x%x]\n",
  81                                auth_tok->session_key.encrypted_key_size);
  82                ecryptfs_printk(KERN_DEBUG, " * Encrypted session key "
  83                                "dump:\n");
  84                if (ecryptfs_verbosity > 0)
  85                        ecryptfs_dump_hex(auth_tok->session_key.encrypted_key,
  86                                          auth_tok->session_key.
  87                                          encrypted_key_size);
  88        }
  89}
  90
  91/**
  92 * ecryptfs_dump_hex - debug hex printer
  93 * @data: string of bytes to be printed
  94 * @bytes: number of bytes to print
  95 *
  96 * Dump hexadecimal representation of char array
  97 */
  98void ecryptfs_dump_hex(char *data, int bytes)
  99{
 100        int i = 0;
 101        int add_newline = 1;
 102
 103        if (ecryptfs_verbosity < 1)
 104                return;
 105        if (bytes != 0) {
 106                printk(KERN_DEBUG "0x%.2x.", (unsigned char)data[i]);
 107                i++;
 108        }
 109        while (i < bytes) {
 110                printk("0x%.2x.", (unsigned char)data[i]);
 111                i++;
 112                if (i % 16 == 0) {
 113                        printk("\n");
 114                        add_newline = 0;
 115                } else
 116                        add_newline = 1;
 117        }
 118        if (add_newline)
 119                printk("\n");
 120}
 121
 122