1 /* 2 * Constant-time equality testing of memory regions. 3 * 4 * Authors: 5 * 6 * James Yonan <james@openvpn.net> 7 * Daniel Borkmann <dborkman@redhat.com> 8 * 9 * This file is provided under a dual BSD/GPLv2 license. When using or 10 * redistributing this file, you may do so under either license. 11 * 12 * GPL LICENSE SUMMARY 13 * 14 * Copyright(c) 2013 OpenVPN Technologies, Inc. All rights reserved. 15 * 16 * This program is free software; you can redistribute it and/or modify 17 * it under the terms of version 2 of the GNU General Public License as 18 * published by the Free Software Foundation. 19 * 20 * This program is distributed in the hope that it will be useful, but 21 * WITHOUT ANY WARRANTY; without even the implied warranty of 22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 23 * General Public License for more details. 24 * 25 * You should have received a copy of the GNU General Public License 26 * along with this program; if not, write to the Free Software 27 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. 28 * The full GNU General Public License is included in this distribution 29 * in the file called LICENSE.GPL. 30 * 31 * BSD LICENSE 32 * 33 * Copyright(c) 2013 OpenVPN Technologies, Inc. All rights reserved. 34 * 35 * Redistribution and use in source and binary forms, with or without 36 * modification, are permitted provided that the following conditions 37 * are met: 38 * 39 * * Redistributions of source code must retain the above copyright 40 * notice, this list of conditions and the following disclaimer. 41 * * Redistributions in binary form must reproduce the above copyright 42 * notice, this list of conditions and the following disclaimer in 43 * the documentation and/or other materials provided with the 44 * distribution. 45 * * Neither the name of OpenVPN Technologies nor the names of its 46 * contributors may be used to endorse or promote products derived 47 * from this software without specific prior written permission. 48 * 49 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 50 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 51 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 52 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 53 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 54 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 55 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 56 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 57 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 58 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 59 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 60 */ 61 62 #include <asm/unaligned.h> 63 #include <crypto/algapi.h> 64 #include <linux/module.h> 65 66 #ifndef __HAVE_ARCH_CRYPTO_MEMNEQ 67 68 /* Generic path for arbitrary size */ 69 static inline unsigned long 70 __crypto_memneq_generic(const void *a, const void *b, size_t size) 71 { 72 unsigned long neq = 0; 73 74 #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) 75 while (size >= sizeof(unsigned long)) { 76 neq |= get_unaligned((unsigned long *)a) ^ 77 get_unaligned((unsigned long *)b); 78 OPTIMIZER_HIDE_VAR(neq); 79 a += sizeof(unsigned long); 80 b += sizeof(unsigned long); 81 size -= sizeof(unsigned long); 82 } 83 #endif /* CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS */ 84 while (size > 0) { 85 neq |= *(unsigned char *)a ^ *(unsigned char *)b; 86 OPTIMIZER_HIDE_VAR(neq); 87 a += 1; 88 b += 1; 89 size -= 1; 90 } 91 return neq; 92 } 93 94 /* Loop-free fast-path for frequently used 16-byte size */ 95 static inline unsigned long __crypto_memneq_16(const void *a, const void *b) 96 { 97 unsigned long neq = 0; 98 99 #ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS 100 if (sizeof(unsigned long) == 8) { 101 neq |= get_unaligned((unsigned long *)a) ^ 102 get_unaligned((unsigned long *)b); 103 OPTIMIZER_HIDE_VAR(neq); 104 neq |= get_unaligned((unsigned long *)(a + 8)) ^ 105 get_unaligned((unsigned long *)(b + 8)); 106 OPTIMIZER_HIDE_VAR(neq); 107 } else if (sizeof(unsigned int) == 4) { 108 neq |= get_unaligned((unsigned int *)a) ^ 109 get_unaligned((unsigned int *)b); 110 OPTIMIZER_HIDE_VAR(neq); 111 neq |= get_unaligned((unsigned int *)(a + 4)) ^ 112 get_unaligned((unsigned int *)(b + 4)); 113 OPTIMIZER_HIDE_VAR(neq); 114 neq |= get_unaligned((unsigned int *)(a + 8)) ^ 115 get_unaligned((unsigned int *)(b + 8)); 116 OPTIMIZER_HIDE_VAR(neq); 117 neq |= get_unaligned((unsigned int *)(a + 12)) ^ 118 get_unaligned((unsigned int *)(b + 12)); 119 OPTIMIZER_HIDE_VAR(neq); 120 } else 121 #endif /* CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS */ 122 { 123 neq |= *(unsigned char *)(a) ^ *(unsigned char *)(b); 124 OPTIMIZER_HIDE_VAR(neq); 125 neq |= *(unsigned char *)(a+1) ^ *(unsigned char *)(b+1); 126 OPTIMIZER_HIDE_VAR(neq); 127 neq |= *(unsigned char *)(a+2) ^ *(unsigned char *)(b+2); 128 OPTIMIZER_HIDE_VAR(neq); 129 neq |= *(unsigned char *)(a+3) ^ *(unsigned char *)(b+3); 130 OPTIMIZER_HIDE_VAR(neq); 131 neq |= *(unsigned char *)(a+4) ^ *(unsigned char *)(b+4); 132 OPTIMIZER_HIDE_VAR(neq); 133 neq |= *(unsigned char *)(a+5) ^ *(unsigned char *)(b+5); 134 OPTIMIZER_HIDE_VAR(neq); 135 neq |= *(unsigned char *)(a+6) ^ *(unsigned char *)(b+6); 136 OPTIMIZER_HIDE_VAR(neq); 137 neq |= *(unsigned char *)(a+7) ^ *(unsigned char *)(b+7); 138 OPTIMIZER_HIDE_VAR(neq); 139 neq |= *(unsigned char *)(a+8) ^ *(unsigned char *)(b+8); 140 OPTIMIZER_HIDE_VAR(neq); 141 neq |= *(unsigned char *)(a+9) ^ *(unsigned char *)(b+9); 142 OPTIMIZER_HIDE_VAR(neq); 143 neq |= *(unsigned char *)(a+10) ^ *(unsigned char *)(b+10); 144 OPTIMIZER_HIDE_VAR(neq); 145 neq |= *(unsigned char *)(a+11) ^ *(unsigned char *)(b+11); 146 OPTIMIZER_HIDE_VAR(neq); 147 neq |= *(unsigned char *)(a+12) ^ *(unsigned char *)(b+12); 148 OPTIMIZER_HIDE_VAR(neq); 149 neq |= *(unsigned char *)(a+13) ^ *(unsigned char *)(b+13); 150 OPTIMIZER_HIDE_VAR(neq); 151 neq |= *(unsigned char *)(a+14) ^ *(unsigned char *)(b+14); 152 OPTIMIZER_HIDE_VAR(neq); 153 neq |= *(unsigned char *)(a+15) ^ *(unsigned char *)(b+15); 154 OPTIMIZER_HIDE_VAR(neq); 155 } 156 157 return neq; 158 } 159 160 /* Compare two areas of memory without leaking timing information, 161 * and with special optimizations for common sizes. Users should 162 * not call this function directly, but should instead use 163 * crypto_memneq defined in crypto/algapi.h. 164 */ 165 noinline unsigned long __crypto_memneq(const void *a, const void *b, 166 size_t size) 167 { 168 switch (size) { 169 case 16: 170 return __crypto_memneq_16(a, b); 171 default: 172 return __crypto_memneq_generic(a, b, size); 173 } 174 } 175 EXPORT_SYMBOL(__crypto_memneq); 176 177 #endif /* __HAVE_ARCH_CRYPTO_MEMNEQ */ 178 179 MODULE_LICENSE("GPL"); 180