1 /* 2 * Copyright (c) 2017 JingPiao Chen <chenjingpiao (at) gmail.com> 3 * Copyright (c) 2017 The strace developers. 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. The name of the author may not be used to endorse or promote products 15 * derived from this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include "defs.h" 30 31 #ifdef HAVE_LINUX_CRYPTOUSER_H 32 33 # include "netlink.h" 34 # include "nlattr.h" 35 # include "print_fields.h" 36 37 # include <linux/cryptouser.h> 38 39 # include "xlat/crypto_nl_attrs.h" 40 41 static bool 42 decode_crypto_report_generic(struct tcb *const tcp, 43 const kernel_ulong_t addr, 44 const unsigned int len, 45 const void *const opaque_data) 46 { 47 tprints("{type="); 48 printstr_ex(tcp, addr, len, QUOTE_0_TERMINATED); 49 tprints("}"); 50 51 return true; 52 } 53 54 static bool 55 decode_crypto_report_hash(struct tcb *const tcp, 56 const kernel_ulong_t addr, 57 const unsigned int len, 58 const void *const opaque_data) 59 { 60 # ifdef HAVE_STRUCT_CRYPTO_REPORT_HASH 61 struct crypto_report_hash rhash; 62 63 if (len < sizeof(rhash)) 64 printstrn(tcp, addr, len); 65 else if (!umove_or_printaddr(tcp, addr, &rhash)) { 66 PRINT_FIELD_CSTRING("{", rhash, type); 67 PRINT_FIELD_U(", ", rhash, blocksize); 68 PRINT_FIELD_U(", ", rhash, digestsize); 69 tprints("}"); 70 } 71 # else 72 printstrn(tcp, addr, len); 73 # endif 74 75 return true; 76 } 77 78 static bool 79 decode_crypto_report_blkcipher(struct tcb *const tcp, 80 const kernel_ulong_t addr, 81 const unsigned int len, 82 const void *const opaque_data) 83 { 84 # ifdef HAVE_STRUCT_CRYPTO_REPORT_BLKCIPHER 85 struct crypto_report_blkcipher rblkcipher; 86 87 if (len < sizeof(rblkcipher)) 88 printstrn(tcp, addr, len); 89 else if (!umove_or_printaddr(tcp, addr, &rblkcipher)) { 90 PRINT_FIELD_CSTRING("{", rblkcipher, type); 91 PRINT_FIELD_CSTRING(", ", rblkcipher, geniv); 92 PRINT_FIELD_U(", ", rblkcipher, blocksize); 93 PRINT_FIELD_U(", ", rblkcipher, min_keysize); 94 PRINT_FIELD_U(", ", rblkcipher, max_keysize); 95 PRINT_FIELD_U(", ", rblkcipher, ivsize); 96 tprints("}"); 97 } 98 # else 99 printstrn(tcp, addr, len); 100 # endif 101 102 return true; 103 } 104 105 static bool 106 decode_crypto_report_aead(struct tcb *const tcp, 107 const kernel_ulong_t addr, 108 const unsigned int len, 109 const void *const opaque_data) 110 { 111 # ifdef HAVE_STRUCT_CRYPTO_REPORT_AEAD 112 struct crypto_report_aead raead; 113 114 if (len < sizeof(raead)) 115 printstrn(tcp, addr, len); 116 else if (!umove_or_printaddr(tcp, addr, &raead)) { 117 PRINT_FIELD_CSTRING("{", raead, type); 118 PRINT_FIELD_CSTRING(", ", raead, geniv); 119 PRINT_FIELD_U(", ", raead, blocksize); 120 PRINT_FIELD_U(", ", raead, maxauthsize); 121 PRINT_FIELD_U(", ", raead, ivsize); 122 tprints("}"); 123 } 124 # else 125 printstrn(tcp, addr, len); 126 # endif 127 128 return true; 129 } 130 131 static bool 132 decode_crypto_report_rng(struct tcb *const tcp, 133 const kernel_ulong_t addr, 134 const unsigned int len, 135 const void *const opaque_data) 136 { 137 # ifdef HAVE_STRUCT_CRYPTO_REPORT_RNG 138 struct crypto_report_rng rrng; 139 140 if (len < sizeof(rrng)) 141 printstrn(tcp, addr, len); 142 else if (!umove_or_printaddr(tcp, addr, &rrng)) { 143 PRINT_FIELD_CSTRING("{", rrng, type); 144 PRINT_FIELD_U(", ", rrng, seedsize); 145 tprints("}"); 146 } 147 # else 148 printstrn(tcp, addr, len); 149 # endif 150 151 return true; 152 } 153 154 static bool 155 decode_crypto_report_cipher(struct tcb *const tcp, 156 const kernel_ulong_t addr, 157 const unsigned int len, 158 const void *const opaque_data) 159 { 160 # ifdef HAVE_STRUCT_CRYPTO_REPORT_CIPHER 161 struct crypto_report_cipher rcipher; 162 163 if (len < sizeof(rcipher)) 164 printstrn(tcp, addr, len); 165 else if (!umove_or_printaddr(tcp, addr, &rcipher)) { 166 PRINT_FIELD_CSTRING("{", rcipher, type); 167 PRINT_FIELD_U(", ", rcipher, blocksize); 168 PRINT_FIELD_U(", ", rcipher, min_keysize); 169 PRINT_FIELD_U(", ", rcipher, max_keysize); 170 tprints("}"); 171 } 172 # else 173 printstrn(tcp, addr, len); 174 # endif 175 176 return true; 177 } 178 179 static const nla_decoder_t crypto_user_alg_nla_decoders[] = { 180 [CRYPTOCFGA_PRIORITY_VAL] = decode_nla_u32, 181 [CRYPTOCFGA_REPORT_LARVAL] = decode_crypto_report_generic, 182 [CRYPTOCFGA_REPORT_HASH] = decode_crypto_report_hash, 183 [CRYPTOCFGA_REPORT_BLKCIPHER] = decode_crypto_report_blkcipher, 184 [CRYPTOCFGA_REPORT_AEAD] = decode_crypto_report_aead, 185 [CRYPTOCFGA_REPORT_COMPRESS] = decode_crypto_report_generic, 186 [CRYPTOCFGA_REPORT_RNG] = decode_crypto_report_rng, 187 [CRYPTOCFGA_REPORT_CIPHER] = decode_crypto_report_cipher, 188 [CRYPTOCFGA_REPORT_AKCIPHER] = decode_crypto_report_generic, 189 [CRYPTOCFGA_REPORT_KPP] = decode_crypto_report_generic, 190 [CRYPTOCFGA_REPORT_ACOMP] = decode_crypto_report_generic 191 }; 192 193 static void 194 decode_crypto_user_alg(struct tcb *const tcp, 195 const kernel_ulong_t addr, 196 const unsigned int len) 197 { 198 struct crypto_user_alg alg; 199 200 if (len < sizeof(alg)) 201 printstrn(tcp, addr, len); 202 else if (!umove_or_printaddr(tcp, addr, &alg)) { 203 PRINT_FIELD_CSTRING("{", alg, cru_name); 204 PRINT_FIELD_CSTRING(", ", alg, cru_driver_name); 205 PRINT_FIELD_CSTRING(", ", alg, cru_module_name); 206 PRINT_FIELD_X(", ", alg, cru_type); 207 PRINT_FIELD_X(", ", alg, cru_mask); 208 PRINT_FIELD_U(", ", alg, cru_refcnt); 209 PRINT_FIELD_X(", ", alg, cru_flags); 210 tprints("}"); 211 212 const size_t offset = NLMSG_ALIGN(sizeof(alg)); 213 if (len > offset) { 214 tprints(", "); 215 decode_nlattr(tcp, addr + offset, len - offset, 216 crypto_nl_attrs, "CRYPTOCFGA_???", 217 crypto_user_alg_nla_decoders, 218 ARRAY_SIZE(crypto_user_alg_nla_decoders), 219 NULL); 220 } 221 } 222 } 223 224 bool 225 decode_netlink_crypto(struct tcb *const tcp, 226 const struct nlmsghdr *const nlmsghdr, 227 const kernel_ulong_t addr, 228 const unsigned int len) 229 { 230 switch (nlmsghdr->nlmsg_type) { 231 case CRYPTO_MSG_NEWALG: 232 case CRYPTO_MSG_DELALG: 233 case CRYPTO_MSG_UPDATEALG: 234 case CRYPTO_MSG_GETALG: 235 decode_crypto_user_alg(tcp, addr, len); 236 break; 237 default: 238 return false; 239 } 240 241 return true; 242 } 243 244 #endif /* HAVE_LINUX_CRYPTOUSER_H */ 245
