From: Steffen Jaeckel <jaeckel-floss@eyet-services.de>
To: u-boot@lists.denx.de
Subject: [PATCH 1/5] lib: add crypt subsystem
Date: Tue, 13 Apr 2021 00:15:19 +0200 [thread overview]
Message-ID: <20210412221523.3517153-2-jaeckel-floss@eyet-services.de> (raw)
In-Reply-To: <20210412221523.3517153-1-jaeckel-floss@eyet-services.de>
Add the basic functionality required to support the standard crypt
format.
The files crypt-sha256.c and crypt-sha512.c originate from libxcrypt and
their formatting is therefor retained.
The integration is done via a crypt_compare() function in crypt.c.
```
libxcrypt $ git describe --long --always --all
tags/v4.4.17-0-g6b110bc
```
Signed-off-by: Steffen Jaeckel <jaeckel-floss@eyet-services.de>
---
include/crypt.h | 13 ++
lib/Kconfig | 1 +
lib/Makefile | 1 +
lib/crypt/Kconfig | 29 ++++
lib/crypt/Makefile | 10 ++
lib/crypt/alg-sha256.h | 17 ++
lib/crypt/alg-sha512.h | 17 ++
lib/crypt/crypt-port.h | 28 ++++
lib/crypt/crypt-sha256.c | 313 +++++++++++++++++++++++++++++++++++++
lib/crypt/crypt-sha512.c | 328 +++++++++++++++++++++++++++++++++++++++
lib/crypt/crypt.c | 73 +++++++++
11 files changed, 830 insertions(+)
create mode 100644 include/crypt.h
create mode 100644 lib/crypt/Kconfig
create mode 100644 lib/crypt/Makefile
create mode 100644 lib/crypt/alg-sha256.h
create mode 100644 lib/crypt/alg-sha512.h
create mode 100644 lib/crypt/crypt-port.h
create mode 100644 lib/crypt/crypt-sha256.c
create mode 100644 lib/crypt/crypt-sha512.c
create mode 100644 lib/crypt/crypt.c
diff --git a/include/crypt.h b/include/crypt.h
new file mode 100644
index 0000000000..e0be2832ff
--- /dev/null
+++ b/include/crypt.h
@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/* Copyright (C) 2020 Steffen Jaeckel <jaeckel-floss@eyet-services.de> */
+
+/**
+ * Compare should with the processed passphrase.
+ *
+ * @should The crypt-style string to compare against
+ * @passphrase The plaintext passphrase
+ * @equal Pointer to an int where the result is stored
+ * '0' = unequal
+ * '1' = equal
+ */
+void crypt_compare(const char *should, const char *passphrase, int *equal);
diff --git a/lib/Kconfig b/lib/Kconfig
index 80ff2443cb..99a4e1a5a7 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -297,6 +297,7 @@ config AES
source lib/rsa/Kconfig
source lib/crypto/Kconfig
+source lib/crypt/Kconfig
config TPM
bool "Trusted Platform Module (TPM) Support"
diff --git a/lib/Makefile b/lib/Makefile
index c42d4e1233..ab78f32eb1 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -64,6 +64,7 @@ obj-$(CONFIG_$(SPL_)RSA) += rsa/
obj-$(CONFIG_SHA1) += sha1.o
obj-$(CONFIG_SHA256) += sha256.o
obj-$(CONFIG_SHA512_ALGO) += sha512.o
+obj-$(CONFIG_CRYPT_PW) += crypt/
obj-$(CONFIG_$(SPL_)ZLIB) += zlib/
obj-$(CONFIG_$(SPL_)ZSTD) += zstd/
diff --git a/lib/crypt/Kconfig b/lib/crypt/Kconfig
new file mode 100644
index 0000000000..6f828cefd6
--- /dev/null
+++ b/lib/crypt/Kconfig
@@ -0,0 +1,29 @@
+config CRYPT_PW
+ bool "Add crypt support for password-based unlock"
+ help
+ Enable support for crypt-style hashed passphrases.
+ This will then be used as the mechanism of choice to
+ verify whether the entered password to unlock the
+ console is correct or not.
+ To make it fully functional, one has also to enable
+ CONFIG_AUTOBOOT_KEYED and CONFIG_AUTOBOOT_ENCRYPTION
+
+if CRYPT_PW
+
+config CRYPT_PW_SHA256
+ bool "Provide sha256crypt"
+ select SHA256
+ select SHA256_ALGO
+ help
+ Enables support for the sha256crypt password-hashing algorithm.
+ The prefix is "$5$".
+
+config CRYPT_PW_SHA512
+ bool "Provide sha512crypt"
+ select SHA512
+ select SHA512_ALGO
+ help
+ Enables support for the sha512crypt password-hashing algorithm.
+ The prefix is "$6$".
+
+endif
diff --git a/lib/crypt/Makefile b/lib/crypt/Makefile
new file mode 100644
index 0000000000..290231064c
--- /dev/null
+++ b/lib/crypt/Makefile
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: GPL-2.0+
+#
+# Copyright (c) 2013, Google Inc.
+#
+# (C) Copyright 2000-2007
+# Wolfgang Denk, DENX Software Engineering, wd at denx.de.
+
+obj-$(CONFIG_CRYPT_PW) += crypt.o
+obj-$(CONFIG_CRYPT_PW_SHA256) += crypt-sha256.o
+obj-$(CONFIG_CRYPT_PW_SHA512) += crypt-sha512.o
diff --git a/lib/crypt/alg-sha256.h b/lib/crypt/alg-sha256.h
new file mode 100644
index 0000000000..e4b29c9f31
--- /dev/null
+++ b/lib/crypt/alg-sha256.h
@@ -0,0 +1,17 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/* Copyright (C) 2020 Steffen Jaeckel <jaeckel-floss@eyet-services.de> */
+
+#ifndef USE_HOSTCC
+#include "common.h"
+#else
+#include <string.h>
+#endif
+
+#include "u-boot/sha256.h"
+
+#define INCLUDE_sha256crypt 1
+
+#define SHA256_CTX sha256_context
+#define SHA256_Init sha256_starts
+#define SHA256_Update(c, i, l) sha256_update(c, (const void *)i, l)
+#define SHA256_Final(b, c) sha256_finish(c, b)
diff --git a/lib/crypt/alg-sha512.h b/lib/crypt/alg-sha512.h
new file mode 100644
index 0000000000..93b6109fae
--- /dev/null
+++ b/lib/crypt/alg-sha512.h
@@ -0,0 +1,17 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/* Copyright (C) 2020 Steffen Jaeckel <jaeckel-floss@eyet-services.de> */
+
+#ifndef USE_HOSTCC
+#include "common.h"
+#else
+#include <string.h>
+#endif
+
+#include "u-boot/sha512.h"
+
+#define INCLUDE_sha512crypt 1
+
+#define SHA512_CTX sha512_context
+#define SHA512_Init sha512_starts
+#define SHA512_Update(c, i, l) sha512_update(c, (const void *)i, l)
+#define SHA512_Final(b, c) sha512_finish(c, b)
diff --git a/lib/crypt/crypt-port.h b/lib/crypt/crypt-port.h
new file mode 100644
index 0000000000..680ffe9349
--- /dev/null
+++ b/lib/crypt/crypt-port.h
@@ -0,0 +1,28 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/* Copyright (C) 2020 Steffen Jaeckel <jaeckel-floss@eyet-services.de> */
+
+#include <linux/types.h>
+#include <vsprintf.h>
+
+#define NO_GENSALT
+#define CRYPT_OUTPUT_SIZE 384
+#define ALG_SPECIFIC_SIZE 8192
+
+#define ARG_UNUSED(x) (x)
+
+#define static_assert(a, b) _Static_assert(a, b)
+
+#define strtoul(cp, endp, base) simple_strtoul(cp, endp, base)
+
+extern const unsigned char ascii64[65];
+
+#define b64t ((const char *)ascii64)
+
+void crypt_sha256crypt_rn(const char *phrase, size_t phr_size,
+ const char *setting, size_t ARG_UNUSED(set_size),
+ uint8_t *output, size_t out_size, void *scratch,
+ size_t scr_size);
+void crypt_sha512crypt_rn(const char *phrase, size_t phr_size,
+ const char *setting, size_t ARG_UNUSED(set_size),
+ uint8_t *output, size_t out_size, void *scratch,
+ size_t scr_size);
diff --git a/lib/crypt/crypt-sha256.c b/lib/crypt/crypt-sha256.c
new file mode 100644
index 0000000000..37127d41e1
--- /dev/null
+++ b/lib/crypt/crypt-sha256.c
@@ -0,0 +1,313 @@
+/* One way encryption based on the SHA256-based Unix crypt implementation.
+ *
+ * Written by Ulrich Drepper <drepper@redhat.com> in 2007 [1].
+ * Modified by Zack Weinberg <zackw@panix.com> in 2017, 2018.
+ * Composed by Bj?rn Esser <besser82@fedoraproject.org> in 2018.
+ * Modified by Bj?rn Esser <besser82@fedoraproject.org> in 2020.
+ * Modified by Steffen Jaeckel <jaeckel-floss@eyet-services.de> in 2020.
+ * To the extent possible under law, the named authors have waived all
+ * copyright and related or neighboring rights to this work.
+ *
+ * See https://creativecommons.org/publicdomain/zero/1.0/ for further
+ * details.
+ *
+ * This file is a modified except from [2], lines 648 up to 909.
+ *
+ * [1] https://www.akkadia.org/drepper/sha-crypt.html
+ * [2] https://www.akkadia.org/drepper/SHA-crypt.txt
+ */
+
+#include "crypt-port.h"
+#include "alg-sha256.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if INCLUDE_sha256crypt
+
+/* Define our magic string to mark salt for SHA256 "encryption"
+ replacement. */
+static const char sha256_salt_prefix[] = "$5$";
+
+/* Prefix for optional rounds specification. */
+static const char sha256_rounds_prefix[] = "rounds=";
+
+/* Maximum salt string length. */
+#define SALT_LEN_MAX 16
+/* Default number of rounds if not explicitly specified. */
+#define ROUNDS_DEFAULT 5000
+/* Minimum number of rounds. */
+#define ROUNDS_MIN 1000
+/* Maximum number of rounds. */
+#define ROUNDS_MAX 999999999
+
+/* The maximum possible length of a SHA256-hashed password string,
+ including the terminating NUL character. Prefix (including its NUL)
+ + rounds tag ("rounds=$" = "rounds=\0") + strlen(ROUNDS_MAX)
+ + salt (up to SALT_LEN_MAX chars) + '$' + hash (43 chars). */
+
+#define LENGTH_OF_NUMBER(n) (sizeof #n - 1)
+
+#define SHA256_HASH_LENGTH \
+ (sizeof (sha256_salt_prefix) + sizeof (sha256_rounds_prefix) + \
+ LENGTH_OF_NUMBER (ROUNDS_MAX) + SALT_LEN_MAX + 1 + 43)
+
+static_assert (SHA256_HASH_LENGTH <= CRYPT_OUTPUT_SIZE,
+ "CRYPT_OUTPUT_SIZE is too small for SHA256");
+
+/* A sha256_buffer holds all of the sensitive intermediate data. */
+struct sha256_buffer
+{
+ SHA256_CTX ctx;
+ uint8_t result[32];
+ uint8_t p_bytes[32];
+ uint8_t s_bytes[32];
+};
+
+static_assert (sizeof (struct sha256_buffer) <= ALG_SPECIFIC_SIZE,
+ "ALG_SPECIFIC_SIZE is too small for SHA256");
+
+
+/* Feed CTX with LEN bytes of a virtual byte sequence consisting of
+ BLOCK repeated over and over indefinitely. */
+static void
+SHA256_Update_recycled (SHA256_CTX *ctx,
+ unsigned char block[32], size_t len)
+{
+ size_t cnt;
+ for (cnt = len; cnt >= 32; cnt -= 32)
+ SHA256_Update (ctx, block, 32);
+ SHA256_Update (ctx, block, cnt);
+}
+
+void
+crypt_sha256crypt_rn (const char *phrase, size_t phr_size,
+ const char *setting, size_t ARG_UNUSED (set_size),
+ uint8_t *output, size_t out_size,
+ void *scratch, size_t scr_size)
+{
+ /* This shouldn't ever happen, but... */
+ if (out_size < SHA256_HASH_LENGTH
+ || scr_size < sizeof (struct sha256_buffer))
+ {
+ errno = ERANGE;
+ return;
+ }
+
+ struct sha256_buffer *buf = scratch;
+ SHA256_CTX *ctx = &buf->ctx;
+ uint8_t *result = buf->result;
+ uint8_t *p_bytes = buf->p_bytes;
+ uint8_t *s_bytes = buf->s_bytes;
+ char *cp = (char *)output;
+ const char *salt = setting;
+
+ size_t salt_size;
+ size_t cnt;
+ /* Default number of rounds. */
+ size_t rounds = ROUNDS_DEFAULT;
+ bool rounds_custom = false;
+
+ /* Find beginning of salt string. The prefix should normally always
+ be present. Just in case it is not. */
+ if (strncmp (sha256_salt_prefix, salt, sizeof (sha256_salt_prefix) - 1) == 0)
+ /* Skip salt prefix. */
+ salt += sizeof (sha256_salt_prefix) - 1;
+
+ if (strncmp (salt, sha256_rounds_prefix, sizeof (sha256_rounds_prefix) - 1)
+ == 0)
+ {
+ const char *num = salt + sizeof (sha256_rounds_prefix) - 1;
+ /* Do not allow an explicit setting of zero rounds, nor of the
+ default number of rounds, nor leading zeroes on the rounds. */
+ if (!(*num >= '1' && *num <= '9'))
+ {
+ errno = EINVAL;
+ return;
+ }
+
+ errno = 0;
+ char *endp;
+ rounds = strtoul (num, &endp, 10);
+ if (endp == num || *endp != '$'
+ || rounds < ROUNDS_MIN
+ || rounds > ROUNDS_MAX
+ || errno)
+ {
+ errno = EINVAL;
+ return;
+ }
+ salt = endp + 1;
+ rounds_custom = true;
+ }
+
+ /* The salt ends at the next '$' or the end of the string.
+ Ensure ':' does not appear in the salt (it is used as a separator in /etc/passwd).
+ Also check for '\n', as in /etc/passwd the whole parameters of the user data must
+ be on a single line. */
+ salt_size = strcspn (salt, "$:\n");
+ if (!(salt[salt_size] == '$' || !salt[salt_size]))
+ {
+ errno = EINVAL;
+ return;
+ }
+
+ /* Ensure we do not use more salt than SALT_LEN_MAX. */
+ if (salt_size > SALT_LEN_MAX)
+ salt_size = SALT_LEN_MAX;
+
+ /* Compute alternate SHA256 sum with input PHRASE, SALT, and PHRASE. The
+ final result will be added to the first context. */
+ SHA256_Init (ctx);
+
+ /* Add phrase. */
+ SHA256_Update (ctx, phrase, phr_size);
+
+ /* Add salt. */
+ SHA256_Update (ctx, salt, salt_size);
+
+ /* Add phrase again. */
+ SHA256_Update (ctx, phrase, phr_size);
+
+ /* Now get result of this (32 bytes). */
+ SHA256_Final (result, ctx);
+
+ /* Prepare for the real work. */
+ SHA256_Init (ctx);
+
+ /* Add the phrase string. */
+ SHA256_Update (ctx, phrase, phr_size);
+
+ /* The last part is the salt string. This must be at most 8
+ characters and it ends at the first `$' character (for
+ compatibility with existing implementations). */
+ SHA256_Update (ctx, salt, salt_size);
+
+ /* Add for any character in the phrase one byte of the alternate sum. */
+ for (cnt = phr_size; cnt > 32; cnt -= 32)
+ SHA256_Update (ctx, result, 32);
+ SHA256_Update (ctx, result, cnt);
+
+ /* Take the binary representation of the length of the phrase and for every
+ 1 add the alternate sum, for every 0 the phrase. */
+ for (cnt = phr_size; cnt > 0; cnt >>= 1)
+ if ((cnt & 1) != 0)
+ SHA256_Update (ctx, result, 32);
+ else
+ SHA256_Update (ctx, phrase, phr_size);
+
+ /* Create intermediate result. */
+ SHA256_Final (result, ctx);
+
+ /* Start computation of P byte sequence. */
+ SHA256_Init (ctx);
+
+ /* For every character in the password add the entire password. */
+ for (cnt = 0; cnt < phr_size; ++cnt)
+ SHA256_Update (ctx, phrase, phr_size);
+
+ /* Finish the digest. */
+ SHA256_Final (p_bytes, ctx);
+
+ /* Start computation of S byte sequence. */
+ SHA256_Init (ctx);
+
+ /* For every character in the password add the entire password. */
+ for (cnt = 0; cnt < (size_t) 16 + (size_t) result[0]; ++cnt)
+ SHA256_Update (ctx, salt, salt_size);
+
+ /* Finish the digest. */
+ SHA256_Final (s_bytes, ctx);
+
+ /* Repeatedly run the collected hash value through SHA256 to burn
+ CPU cycles. */
+ for (cnt = 0; cnt < rounds; ++cnt)
+ {
+ /* New context. */
+ SHA256_Init (ctx);
+
+ /* Add phrase or last result. */
+ if ((cnt & 1) != 0)
+ SHA256_Update_recycled (ctx, p_bytes, phr_size);
+ else
+ SHA256_Update (ctx, result, 32);
+
+ /* Add salt for numbers not divisible by 3. */
+ if (cnt % 3 != 0)
+ SHA256_Update_recycled (ctx, s_bytes, salt_size);
+
+ /* Add phrase for numbers not divisible by 7. */
+ if (cnt % 7 != 0)
+ SHA256_Update_recycled (ctx, p_bytes, phr_size);
+
+ /* Add phrase or last result. */
+ if ((cnt & 1) != 0)
+ SHA256_Update (ctx, result, 32);
+ else
+ SHA256_Update_recycled (ctx, p_bytes, phr_size);
+
+ /* Create intermediate result. */
+ SHA256_Final (result, ctx);
+ }
+
+ /* Now we can construct the result string. It consists of four
+ parts, one of which is optional. We already know that there
+ is sufficient space@CP for the longest possible result string. */
+ memcpy (cp, sha256_salt_prefix, sizeof (sha256_salt_prefix) - 1);
+ cp += sizeof (sha256_salt_prefix) - 1;
+
+ if (rounds_custom)
+ {
+ int n = snprintf (cp,
+ SHA256_HASH_LENGTH - (sizeof (sha256_salt_prefix) - 1),
+ "%s%zu$", sha256_rounds_prefix, rounds);
+ cp += n;
+ }
+
+ memcpy (cp, salt, salt_size);
+ cp += salt_size;
+ *cp++ = '$';
+
+#define b64_from_24bit(B2, B1, B0, N) \
+ do { \
+ unsigned int w = ((((unsigned int)(B2)) << 16) | \
+ (((unsigned int)(B1)) << 8) | \
+ ((unsigned int)(B0))); \
+ int n = (N); \
+ while (n-- > 0) \
+ { \
+ *cp++ = b64t[w & 0x3f]; \
+ w >>= 6; \
+ } \
+ } while (0)
+
+ b64_from_24bit (result[0], result[10], result[20], 4);
+ b64_from_24bit (result[21], result[1], result[11], 4);
+ b64_from_24bit (result[12], result[22], result[2], 4);
+ b64_from_24bit (result[3], result[13], result[23], 4);
+ b64_from_24bit (result[24], result[4], result[14], 4);
+ b64_from_24bit (result[15], result[25], result[5], 4);
+ b64_from_24bit (result[6], result[16], result[26], 4);
+ b64_from_24bit (result[27], result[7], result[17], 4);
+ b64_from_24bit (result[18], result[28], result[8], 4);
+ b64_from_24bit (result[9], result[19], result[29], 4);
+ b64_from_24bit (0, result[31], result[30], 3);
+
+ *cp = '\0';
+}
+
+#ifndef NO_GENSALT
+
+void
+gensalt_sha256crypt_rn (unsigned long count,
+ const uint8_t *rbytes, size_t nrbytes,
+ uint8_t *output, size_t output_size)
+{
+ gensalt_sha_rn ('5', SALT_LEN_MAX, ROUNDS_DEFAULT, ROUNDS_MIN, ROUNDS_MAX,
+ count, rbytes, nrbytes, output, output_size);
+}
+
+#endif
+
+#endif
diff --git a/lib/crypt/crypt-sha512.c b/lib/crypt/crypt-sha512.c
new file mode 100644
index 0000000000..3616019445
--- /dev/null
+++ b/lib/crypt/crypt-sha512.c
@@ -0,0 +1,328 @@
+/* One way encryption based on the SHA512-based Unix crypt implementation.
+ *
+ * Written by Ulrich Drepper <drepper@redhat.com> in 2007 [1].
+ * Modified by Zack Weinberg <zackw@panix.com> in 2017, 2018.
+ * Composed by Bj?rn Esser <besser82@fedoraproject.org> in 2018.
+ * Modified by Bj?rn Esser <besser82@fedoraproject.org> in 2020.
+ * Modified by Steffen Jaeckel <jaeckel-floss@eyet-services.de> in 2020.
+ * To the extent possible under law, the named authors have waived all
+ * copyright and related or neighboring rights to this work.
+ *
+ * See https://creativecommons.org/publicdomain/zero/1.0/ for further
+ * details.
+ *
+ * This file is a modified except from [2], lines 1403 up to 1676.
+ *
+ * [1] https://www.akkadia.org/drepper/sha-crypt.html
+ * [2] https://www.akkadia.org/drepper/SHA-crypt.txt
+ */
+
+#include "crypt-port.h"
+#include "alg-sha512.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if INCLUDE_sha512crypt
+
+/* Define our magic string to mark salt for SHA512 "encryption"
+ replacement. */
+static const char sha512_salt_prefix[] = "$6$";
+
+/* Prefix for optional rounds specification. */
+static const char sha512_rounds_prefix[] = "rounds=";
+
+/* Maximum salt string length. */
+#define SALT_LEN_MAX 16
+/* Default number of rounds if not explicitly specified. */
+#define ROUNDS_DEFAULT 5000
+/* Minimum number of rounds. */
+#define ROUNDS_MIN 1000
+/* Maximum number of rounds. */
+#define ROUNDS_MAX 999999999
+
+/* The maximum possible length of a SHA512-hashed password string,
+ including the terminating NUL character. Prefix (including its NUL)
+ + rounds tag ("rounds=$" = "rounds=\0") + strlen(ROUNDS_MAX)
+ + salt (up to SALT_LEN_MAX chars) + '$' + hash (86 chars). */
+
+#define LENGTH_OF_NUMBER(n) (sizeof #n - 1)
+
+#define SHA512_HASH_LENGTH \
+ (sizeof (sha512_salt_prefix) + sizeof (sha512_rounds_prefix) + \
+ LENGTH_OF_NUMBER (ROUNDS_MAX) + SALT_LEN_MAX + 1 + 86)
+
+static_assert (SHA512_HASH_LENGTH <= CRYPT_OUTPUT_SIZE,
+ "CRYPT_OUTPUT_SIZE is too small for SHA512");
+
+/* A sha512_buffer holds all of the sensitive intermediate data. */
+struct sha512_buffer
+{
+ SHA512_CTX ctx;
+ uint8_t result[64];
+ uint8_t p_bytes[64];
+ uint8_t s_bytes[64];
+};
+
+static_assert (sizeof (struct sha512_buffer) <= ALG_SPECIFIC_SIZE,
+ "ALG_SPECIFIC_SIZE is too small for SHA512");
+
+
+/* Subroutine of _xcrypt_crypt_sha512crypt_rn: Feed CTX with LEN bytes of a
+ virtual byte sequence consisting of BLOCK repeated over and over
+ indefinitely. */
+static void
+sha512_process_recycled_bytes (unsigned char block[64], size_t len,
+ SHA512_CTX *ctx)
+{
+ size_t cnt;
+ for (cnt = len; cnt >= 64; cnt -= 64)
+ SHA512_Update (ctx, block, 64);
+ SHA512_Update (ctx, block, cnt);
+}
+
+void
+crypt_sha512crypt_rn (const char *phrase, size_t phr_size,
+ const char *setting, size_t ARG_UNUSED (set_size),
+ uint8_t *output, size_t out_size,
+ void *scratch, size_t scr_size)
+{
+ /* This shouldn't ever happen, but... */
+ if (out_size < SHA512_HASH_LENGTH
+ || scr_size < sizeof (struct sha512_buffer))
+ {
+ errno = ERANGE;
+ return;
+ }
+
+ struct sha512_buffer *buf = scratch;
+ SHA512_CTX *ctx = &buf->ctx;
+ uint8_t *result = buf->result;
+ uint8_t *p_bytes = buf->p_bytes;
+ uint8_t *s_bytes = buf->s_bytes;
+ char *cp = (char *)output;
+ const char *salt = setting;
+
+ size_t salt_size;
+ size_t cnt;
+ /* Default number of rounds. */
+ size_t rounds = ROUNDS_DEFAULT;
+ bool rounds_custom = false;
+
+ /* Find beginning of salt string. The prefix should normally always
+ be present. Just in case it is not. */
+ if (strncmp (sha512_salt_prefix, salt, sizeof (sha512_salt_prefix) - 1) == 0)
+ /* Skip salt prefix. */
+ salt += sizeof (sha512_salt_prefix) - 1;
+
+ if (strncmp (salt, sha512_rounds_prefix, sizeof (sha512_rounds_prefix) - 1)
+ == 0)
+ {
+ const char *num = salt + sizeof (sha512_rounds_prefix) - 1;
+ /* Do not allow an explicit setting of zero rounds, nor of the
+ default number of rounds, nor leading zeroes on the rounds. */
+ if (!(*num >= '1' && *num <= '9'))
+ {
+ errno = EINVAL;
+ return;
+ }
+
+ errno = 0;
+ char *endp;
+ rounds = strtoul (num, &endp, 10);
+ if (endp == num || *endp != '$'
+ || rounds < ROUNDS_MIN
+ || rounds > ROUNDS_MAX
+ || errno)
+ {
+ errno = EINVAL;
+ return;
+ }
+ salt = endp + 1;
+ rounds_custom = true;
+ }
+
+ /* The salt ends at the next '$' or the end of the string.
+ Ensure ':' does not appear in the salt (it is used as a separator in /etc/passwd).
+ Also check for '\n', as in /etc/passwd the whole parameters of the user data must
+ be on a single line. */
+ salt_size = strcspn (salt, "$:\n");
+ if (!(salt[salt_size] == '$' || !salt[salt_size]))
+ {
+ errno = EINVAL;
+ return;
+ }
+
+ /* Ensure we do not use more salt than SALT_LEN_MAX. */
+ if (salt_size > SALT_LEN_MAX)
+ salt_size = SALT_LEN_MAX;
+
+ /* Compute alternate SHA512 sum with input PHRASE, SALT, and PHRASE. The
+ final result will be added to the first context. */
+ SHA512_Init (ctx);
+
+ /* Add phrase. */
+ SHA512_Update (ctx, phrase, phr_size);
+
+ /* Add salt. */
+ SHA512_Update (ctx, salt, salt_size);
+
+ /* Add phrase again. */
+ SHA512_Update (ctx, phrase, phr_size);
+
+ /* Now get result of this (64 bytes) and add it to the other
+ context. */
+ SHA512_Final (result, ctx);
+
+ /* Prepare for the real work. */
+ SHA512_Init (ctx);
+
+ /* Add the phrase string. */
+ SHA512_Update (ctx, phrase, phr_size);
+
+ /* The last part is the salt string. This must be at most 8
+ characters and it ends at the first `$' character (for
+ compatibility with existing implementations). */
+ SHA512_Update (ctx, salt, salt_size);
+
+ /* Add for any character in the phrase one byte of the alternate sum. */
+ for (cnt = phr_size; cnt > 64; cnt -= 64)
+ SHA512_Update (ctx, result, 64);
+ SHA512_Update (ctx, result, cnt);
+
+ /* Take the binary representation of the length of the phrase and for every
+ 1 add the alternate sum, for every 0 the phrase. */
+ for (cnt = phr_size; cnt > 0; cnt >>= 1)
+ if ((cnt & 1) != 0)
+ SHA512_Update (ctx, result, 64);
+ else
+ SHA512_Update (ctx, phrase, phr_size);
+
+ /* Create intermediate result. */
+ SHA512_Final (result, ctx);
+
+ /* Start computation of P byte sequence. */
+ SHA512_Init (ctx);
+
+ /* For every character in the password add the entire password. */
+ for (cnt = 0; cnt < phr_size; ++cnt)
+ SHA512_Update (ctx, phrase, phr_size);
+
+ /* Finish the digest. */
+ SHA512_Final (p_bytes, ctx);
+
+ /* Start computation of S byte sequence. */
+ SHA512_Init (ctx);
+
+ /* For every character in the password add the entire password. */
+ for (cnt = 0; cnt < (size_t) 16 + (size_t) result[0]; ++cnt)
+ SHA512_Update (ctx, salt, salt_size);
+
+ /* Finish the digest. */
+ SHA512_Final (s_bytes, ctx);
+
+ /* Repeatedly run the collected hash value through SHA512 to burn
+ CPU cycles. */
+ for (cnt = 0; cnt < rounds; ++cnt)
+ {
+ /* New context. */
+ SHA512_Init (ctx);
+
+ /* Add phrase or last result. */
+ if ((cnt & 1) != 0)
+ sha512_process_recycled_bytes (p_bytes, phr_size, ctx);
+ else
+ SHA512_Update (ctx, result, 64);
+
+ /* Add salt for numbers not divisible by 3. */
+ if (cnt % 3 != 0)
+ sha512_process_recycled_bytes (s_bytes, salt_size, ctx);
+
+ /* Add phrase for numbers not divisible by 7. */
+ if (cnt % 7 != 0)
+ sha512_process_recycled_bytes (p_bytes, phr_size, ctx);
+
+ /* Add phrase or last result. */
+ if ((cnt & 1) != 0)
+ SHA512_Update (ctx, result, 64);
+ else
+ sha512_process_recycled_bytes (p_bytes, phr_size, ctx);
+
+ /* Create intermediate result. */
+ SHA512_Final (result, ctx);
+ }
+
+ /* Now we can construct the result string. It consists of four
+ parts, one of which is optional. We already know that buflen is
+ @least sha512_hash_length, therefore none of the string bashing
+ below can overflow the buffer. */
+
+ memcpy (cp, sha512_salt_prefix, sizeof (sha512_salt_prefix) - 1);
+ cp += sizeof (sha512_salt_prefix) - 1;
+
+ if (rounds_custom)
+ {
+ int n = snprintf (cp,
+ SHA512_HASH_LENGTH - (sizeof (sha512_salt_prefix) - 1),
+ "%s%zu$", sha512_rounds_prefix, rounds);
+ cp += n;
+ }
+
+ memcpy (cp, salt, salt_size);
+ cp += salt_size;
+ *cp++ = '$';
+
+#define b64_from_24bit(B2, B1, B0, N) \
+ do { \
+ unsigned int w = ((((unsigned int)(B2)) << 16) | \
+ (((unsigned int)(B1)) << 8) | \
+ ((unsigned int)(B0))); \
+ int n = (N); \
+ while (n-- > 0) \
+ { \
+ *cp++ = b64t[w & 0x3f]; \
+ w >>= 6; \
+ } \
+ } while (0)
+
+ b64_from_24bit (result[0], result[21], result[42], 4);
+ b64_from_24bit (result[22], result[43], result[1], 4);
+ b64_from_24bit (result[44], result[2], result[23], 4);
+ b64_from_24bit (result[3], result[24], result[45], 4);
+ b64_from_24bit (result[25], result[46], result[4], 4);
+ b64_from_24bit (result[47], result[5], result[26], 4);
+ b64_from_24bit (result[6], result[27], result[48], 4);
+ b64_from_24bit (result[28], result[49], result[7], 4);
+ b64_from_24bit (result[50], result[8], result[29], 4);
+ b64_from_24bit (result[9], result[30], result[51], 4);
+ b64_from_24bit (result[31], result[52], result[10], 4);
+ b64_from_24bit (result[53], result[11], result[32], 4);
+ b64_from_24bit (result[12], result[33], result[54], 4);
+ b64_from_24bit (result[34], result[55], result[13], 4);
+ b64_from_24bit (result[56], result[14], result[35], 4);
+ b64_from_24bit (result[15], result[36], result[57], 4);
+ b64_from_24bit (result[37], result[58], result[16], 4);
+ b64_from_24bit (result[59], result[17], result[38], 4);
+ b64_from_24bit (result[18], result[39], result[60], 4);
+ b64_from_24bit (result[40], result[61], result[19], 4);
+ b64_from_24bit (result[62], result[20], result[41], 4);
+ b64_from_24bit (0, 0, result[63], 2);
+
+ *cp = '\0';
+}
+
+#ifndef NO_GENSALT
+
+void
+gensalt_sha512crypt_rn (unsigned long count,
+ const uint8_t *rbytes, size_t nrbytes,
+ uint8_t *output, size_t output_size)
+{
+ gensalt_sha_rn ('6', SALT_LEN_MAX, ROUNDS_DEFAULT, ROUNDS_MIN, ROUNDS_MAX,
+ count, rbytes, nrbytes, output, output_size);
+}
+
+#endif
+
+#endif
diff --git a/lib/crypt/crypt.c b/lib/crypt/crypt.c
new file mode 100644
index 0000000000..4ec6079768
--- /dev/null
+++ b/lib/crypt/crypt.c
@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: GPL-2.0+
+/* Copyright (C) 2020 Steffen Jaeckel <jaeckel-floss@eyet-services.de> */
+
+#include <common.h>
+#include <crypt.h>
+#include "crypt-port.h"
+
+typedef void (*crypt_fn)(const char *, size_t, const char *, size_t, uint8_t *,
+ size_t, void *, size_t);
+
+const unsigned char ascii64[65] =
+ "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+static void equals_constant_time(const void *a_, const void *b_, size_t len,
+ int *equal)
+{
+ u8 ret = 0;
+ const u8 *a = a_, *b = b_;
+ int i;
+
+ for (i = 0; i < len; i++)
+ ret |= a[i] ^ b[i];
+
+ ret |= ret >> 4;
+ ret |= ret >> 2;
+ ret |= ret >> 1;
+ ret &= 1;
+
+ *equal = ret ^ 1;
+}
+
+void crypt_compare(const char *should, const char *passphrase, int *equal)
+{
+ u8 output[CRYPT_OUTPUT_SIZE], scratch[ALG_SPECIFIC_SIZE];
+ size_t n;
+ struct {
+ const char *prefix;
+ crypt_fn crypt;
+ } crypt_algos[] = {
+#if defined(CONFIG_CRYPT_PW_SHA256)
+ { "$5$", crypt_sha256crypt_rn },
+#endif
+#if defined(CONFIG_CRYPT_PW_SHA512)
+ { "$6$", crypt_sha512crypt_rn },
+#endif
+ { NULL, NULL }
+ };
+
+ *equal = 0;
+
+ for (n = 0; n < ARRAY_SIZE(crypt_algos); ++n) {
+ if (!crypt_algos[n].prefix)
+ continue;
+ if (strncmp(should, crypt_algos[n].prefix, 3) == 0)
+ break;
+ }
+
+ if (n >= ARRAY_SIZE(crypt_algos))
+ return;
+
+ crypt_algos[n].crypt(passphrase, strlen(passphrase), should, 0, output,
+ sizeof(output), scratch, sizeof(scratch));
+
+ /* early return on error, nothing really happened inside the crypt() function */
+ if (errno == ERANGE || errno == EINVAL)
+ return;
+
+ equals_constant_time(should, output, strlen((const char *)output),
+ equal);
+
+ memset(scratch, 0, sizeof(scratch));
+ memset(output, 0, sizeof(output));
+}
--
2.30.1
next prev parent reply other threads:[~2021-04-12 22:15 UTC|newest]
Thread overview: 15+ messages / expand[flat|nested] mbox.gz Atom feed top
2021-04-12 22:15 [PATCH 0/5] common: Introduce crypt-style password support Steffen Jaeckel
2021-04-12 22:15 ` Steffen Jaeckel [this message]
2021-04-21 7:14 ` [PATCH 1/5] lib: add crypt subsystem Simon Glass
2021-04-21 8:21 ` Steffen Jaeckel
2021-04-22 23:55 ` Simon Glass
2021-04-12 22:15 ` [PATCH 2/5] common: integrate crypt-based passwords Steffen Jaeckel
2021-04-21 7:14 ` Simon Glass
2021-04-21 8:55 ` Steffen Jaeckel
2021-04-29 16:10 ` Simon Glass
2021-04-12 22:15 ` [PATCH 3/5] common: Rename macro appropriately Steffen Jaeckel
2021-04-14 19:38 ` Simon Glass
2021-04-12 22:15 ` [PATCH 4/5] cmd: allow disabling of timeout for password entry Steffen Jaeckel
2021-04-21 7:14 ` Simon Glass
2021-04-21 14:09 ` Steffen Jaeckel
2021-04-12 22:15 ` [PATCH 5/5] configs: add new values to bcm963158 defconfig Steffen Jaeckel
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20210412221523.3517153-2-jaeckel-floss@eyet-services.de \
--to=jaeckel-floss@eyet-services.de \
--cc=u-boot@lists.denx.de \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.