mirror of
https://github.com/Luzifer/cloudkeys-go.git
synced 2024-11-09 22:50:05 +00:00
Knut Ahlers
a1df72edc5
commitf0db1ff1f8Author: Knut Ahlers <knut@ahlers.me> Date: Sun Dec 24 12:19:56 2017 +0100 Mark option as deprecated Signed-off-by: Knut Ahlers <knut@ahlers.me> commit9891df2a16Author: Knut Ahlers <knut@ahlers.me> Date: Sun Dec 24 12:11:56 2017 +0100 Fix: Typo Signed-off-by: Knut Ahlers <knut@ahlers.me> commit836006de64Author: Knut Ahlers <knut@ahlers.me> Date: Sun Dec 24 12:04:20 2017 +0100 Add new dependencies Signed-off-by: Knut Ahlers <knut@ahlers.me> commitd64fee60c8Author: Knut Ahlers <knut@ahlers.me> Date: Sun Dec 24 11:55:52 2017 +0100 Replace insecure password hashing Prior this commit passwords were hashed with a static salt and using the SHA1 hashing function. This could lead to passwords being attackable in case someone gets access to the raw data stored inside the database. This commit introduces password hashing using bcrypt hashing function which addresses this issue. Old passwords are not automatically re-hashed as they are unknown. Replacing the old password scheme is not that easy and needs #10 to be solved. Therefore the old hashing scheme is kept for compatibility reason. Signed-off-by: Knut Ahlers <knut@ahlers.me> Signed-off-by: Knut Ahlers <knut@ahlers.me> closes #14 closes #15
290 lines
8.5 KiB
ArmAsm
290 lines
8.5 KiB
ArmAsm
// Copyright 2016 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// +build amd64,!gccgo,!appengine
|
|
|
|
#include "textflag.h"
|
|
|
|
DATA ·iv0<>+0x00(SB)/8, $0x6a09e667f3bcc908
|
|
DATA ·iv0<>+0x08(SB)/8, $0xbb67ae8584caa73b
|
|
GLOBL ·iv0<>(SB), (NOPTR+RODATA), $16
|
|
|
|
DATA ·iv1<>+0x00(SB)/8, $0x3c6ef372fe94f82b
|
|
DATA ·iv1<>+0x08(SB)/8, $0xa54ff53a5f1d36f1
|
|
GLOBL ·iv1<>(SB), (NOPTR+RODATA), $16
|
|
|
|
DATA ·iv2<>+0x00(SB)/8, $0x510e527fade682d1
|
|
DATA ·iv2<>+0x08(SB)/8, $0x9b05688c2b3e6c1f
|
|
GLOBL ·iv2<>(SB), (NOPTR+RODATA), $16
|
|
|
|
DATA ·iv3<>+0x00(SB)/8, $0x1f83d9abfb41bd6b
|
|
DATA ·iv3<>+0x08(SB)/8, $0x5be0cd19137e2179
|
|
GLOBL ·iv3<>(SB), (NOPTR+RODATA), $16
|
|
|
|
DATA ·c40<>+0x00(SB)/8, $0x0201000706050403
|
|
DATA ·c40<>+0x08(SB)/8, $0x0a09080f0e0d0c0b
|
|
GLOBL ·c40<>(SB), (NOPTR+RODATA), $16
|
|
|
|
DATA ·c48<>+0x00(SB)/8, $0x0100070605040302
|
|
DATA ·c48<>+0x08(SB)/8, $0x09080f0e0d0c0b0a
|
|
GLOBL ·c48<>(SB), (NOPTR+RODATA), $16
|
|
|
|
#define SHUFFLE(v2, v3, v4, v5, v6, v7, t1, t2) \
|
|
MOVO v4, t1; \
|
|
MOVO v5, v4; \
|
|
MOVO t1, v5; \
|
|
MOVO v6, t1; \
|
|
PUNPCKLQDQ v6, t2; \
|
|
PUNPCKHQDQ v7, v6; \
|
|
PUNPCKHQDQ t2, v6; \
|
|
PUNPCKLQDQ v7, t2; \
|
|
MOVO t1, v7; \
|
|
MOVO v2, t1; \
|
|
PUNPCKHQDQ t2, v7; \
|
|
PUNPCKLQDQ v3, t2; \
|
|
PUNPCKHQDQ t2, v2; \
|
|
PUNPCKLQDQ t1, t2; \
|
|
PUNPCKHQDQ t2, v3
|
|
|
|
#define SHUFFLE_INV(v2, v3, v4, v5, v6, v7, t1, t2) \
|
|
MOVO v4, t1; \
|
|
MOVO v5, v4; \
|
|
MOVO t1, v5; \
|
|
MOVO v2, t1; \
|
|
PUNPCKLQDQ v2, t2; \
|
|
PUNPCKHQDQ v3, v2; \
|
|
PUNPCKHQDQ t2, v2; \
|
|
PUNPCKLQDQ v3, t2; \
|
|
MOVO t1, v3; \
|
|
MOVO v6, t1; \
|
|
PUNPCKHQDQ t2, v3; \
|
|
PUNPCKLQDQ v7, t2; \
|
|
PUNPCKHQDQ t2, v6; \
|
|
PUNPCKLQDQ t1, t2; \
|
|
PUNPCKHQDQ t2, v7
|
|
|
|
#define HALF_ROUND(v0, v1, v2, v3, v4, v5, v6, v7, m0, m1, m2, m3, t0, c40, c48) \
|
|
PADDQ m0, v0; \
|
|
PADDQ m1, v1; \
|
|
PADDQ v2, v0; \
|
|
PADDQ v3, v1; \
|
|
PXOR v0, v6; \
|
|
PXOR v1, v7; \
|
|
PSHUFD $0xB1, v6, v6; \
|
|
PSHUFD $0xB1, v7, v7; \
|
|
PADDQ v6, v4; \
|
|
PADDQ v7, v5; \
|
|
PXOR v4, v2; \
|
|
PXOR v5, v3; \
|
|
PSHUFB c40, v2; \
|
|
PSHUFB c40, v3; \
|
|
PADDQ m2, v0; \
|
|
PADDQ m3, v1; \
|
|
PADDQ v2, v0; \
|
|
PADDQ v3, v1; \
|
|
PXOR v0, v6; \
|
|
PXOR v1, v7; \
|
|
PSHUFB c48, v6; \
|
|
PSHUFB c48, v7; \
|
|
PADDQ v6, v4; \
|
|
PADDQ v7, v5; \
|
|
PXOR v4, v2; \
|
|
PXOR v5, v3; \
|
|
MOVOU v2, t0; \
|
|
PADDQ v2, t0; \
|
|
PSRLQ $63, v2; \
|
|
PXOR t0, v2; \
|
|
MOVOU v3, t0; \
|
|
PADDQ v3, t0; \
|
|
PSRLQ $63, v3; \
|
|
PXOR t0, v3
|
|
|
|
#define LOAD_MSG(m0, m1, m2, m3, src, i0, i1, i2, i3, i4, i5, i6, i7) \
|
|
MOVQ i0*8(src), m0; \
|
|
PINSRQ $1, i1*8(src), m0; \
|
|
MOVQ i2*8(src), m1; \
|
|
PINSRQ $1, i3*8(src), m1; \
|
|
MOVQ i4*8(src), m2; \
|
|
PINSRQ $1, i5*8(src), m2; \
|
|
MOVQ i6*8(src), m3; \
|
|
PINSRQ $1, i7*8(src), m3
|
|
|
|
// func hashBlocksSSE4(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte)
|
|
TEXT ·hashBlocksSSE4(SB), 4, $288-48 // frame size = 272 + 16 byte alignment
|
|
MOVQ h+0(FP), AX
|
|
MOVQ c+8(FP), BX
|
|
MOVQ flag+16(FP), CX
|
|
MOVQ blocks_base+24(FP), SI
|
|
MOVQ blocks_len+32(FP), DI
|
|
|
|
MOVQ SP, BP
|
|
MOVQ SP, R9
|
|
ADDQ $15, R9
|
|
ANDQ $~15, R9
|
|
MOVQ R9, SP
|
|
|
|
MOVOU ·iv3<>(SB), X0
|
|
MOVO X0, 0(SP)
|
|
XORQ CX, 0(SP) // 0(SP) = ·iv3 ^ (CX || 0)
|
|
|
|
MOVOU ·c40<>(SB), X13
|
|
MOVOU ·c48<>(SB), X14
|
|
|
|
MOVOU 0(AX), X12
|
|
MOVOU 16(AX), X15
|
|
|
|
MOVQ 0(BX), R8
|
|
MOVQ 8(BX), R9
|
|
|
|
loop:
|
|
ADDQ $128, R8
|
|
CMPQ R8, $128
|
|
JGE noinc
|
|
INCQ R9
|
|
|
|
noinc:
|
|
MOVQ R8, X8
|
|
PINSRQ $1, R9, X8
|
|
|
|
MOVO X12, X0
|
|
MOVO X15, X1
|
|
MOVOU 32(AX), X2
|
|
MOVOU 48(AX), X3
|
|
MOVOU ·iv0<>(SB), X4
|
|
MOVOU ·iv1<>(SB), X5
|
|
MOVOU ·iv2<>(SB), X6
|
|
|
|
PXOR X8, X6
|
|
MOVO 0(SP), X7
|
|
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 0, 2, 4, 6, 1, 3, 5, 7)
|
|
MOVO X8, 16(SP)
|
|
MOVO X9, 32(SP)
|
|
MOVO X10, 48(SP)
|
|
MOVO X11, 64(SP)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 8, 10, 12, 14, 9, 11, 13, 15)
|
|
MOVO X8, 80(SP)
|
|
MOVO X9, 96(SP)
|
|
MOVO X10, 112(SP)
|
|
MOVO X11, 128(SP)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 14, 4, 9, 13, 10, 8, 15, 6)
|
|
MOVO X8, 144(SP)
|
|
MOVO X9, 160(SP)
|
|
MOVO X10, 176(SP)
|
|
MOVO X11, 192(SP)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 1, 0, 11, 5, 12, 2, 7, 3)
|
|
MOVO X8, 208(SP)
|
|
MOVO X9, 224(SP)
|
|
MOVO X10, 240(SP)
|
|
MOVO X11, 256(SP)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 11, 12, 5, 15, 8, 0, 2, 13)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 10, 3, 7, 9, 14, 6, 1, 4)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 7, 3, 13, 11, 9, 1, 12, 14)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 2, 5, 4, 15, 6, 10, 0, 8)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 9, 5, 2, 10, 0, 7, 4, 15)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 14, 11, 6, 3, 1, 12, 8, 13)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 2, 6, 0, 8, 12, 10, 11, 3)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 4, 7, 15, 1, 13, 5, 14, 9)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 12, 1, 14, 4, 5, 15, 13, 10)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 0, 6, 9, 8, 7, 3, 2, 11)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 13, 7, 12, 3, 11, 14, 1, 9)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 5, 15, 8, 2, 0, 4, 6, 10)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 6, 14, 11, 0, 15, 9, 3, 8)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 12, 13, 1, 10, 2, 7, 4, 5)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 10, 8, 7, 1, 2, 4, 6, 5)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
LOAD_MSG(X8, X9, X10, X11, SI, 15, 9, 3, 13, 11, 14, 12, 0)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)
|
|
SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, 16(SP), 32(SP), 48(SP), 64(SP), X11, X13, X14)
|
|
SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, 80(SP), 96(SP), 112(SP), 128(SP), X11, X13, X14)
|
|
SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, 144(SP), 160(SP), 176(SP), 192(SP), X11, X13, X14)
|
|
SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, 208(SP), 224(SP), 240(SP), 256(SP), X11, X13, X14)
|
|
SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)
|
|
|
|
MOVOU 32(AX), X10
|
|
MOVOU 48(AX), X11
|
|
PXOR X0, X12
|
|
PXOR X1, X15
|
|
PXOR X2, X10
|
|
PXOR X3, X11
|
|
PXOR X4, X12
|
|
PXOR X5, X15
|
|
PXOR X6, X10
|
|
PXOR X7, X11
|
|
MOVOU X10, 32(AX)
|
|
MOVOU X11, 48(AX)
|
|
|
|
LEAQ 128(SI), SI
|
|
SUBQ $128, DI
|
|
JNE loop
|
|
|
|
MOVOU X12, 0(AX)
|
|
MOVOU X15, 16(AX)
|
|
|
|
MOVQ R8, 0(BX)
|
|
MOVQ R9, 8(BX)
|
|
|
|
MOVQ BP, SP
|
|
RET
|
|
|
|
// func supportsSSE4() bool
|
|
TEXT ·supportsSSE4(SB), 4, $0-1
|
|
MOVL $1, AX
|
|
CPUID
|
|
SHRL $19, CX // Bit 19 indicates SSE4 support
|
|
ANDL $1, CX // CX != 0 if support SSE4
|
|
MOVB CX, ret+0(FP)
|
|
RET
|