�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fplugin%2F'>plugin</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fplugin%2Fauth_parsec%2F'>auth_parsec</a>/</p><hr><h3>✏️ Editing: server_parsec.cc</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
  Copyright (c) 2024, MariaDB plc

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; version 2 of the License.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1335  USA */

#include &lt;openssl/evp.h&gt;
#include &lt;openssl/rand.h&gt;
#include &lt;openssl/err.h&gt;
#ifdef HAVE_WOLFSSL
#include &lt;openssl/ed25519.h&gt;
#include &lt;wolfcrypt/ed25519.h&gt;
#endif

#include &lt;mysql/plugin_auth.h&gt;
#include &lt;mysql/plugin.h&gt;
#include &lt;mysqld_error.h&gt;
#include &quot;scope.h&quot;

#include &lt;cstring&gt;

typedef unsigned char uchar;
constexpr size_t CHALLENGE_SCRAMBLE_LENGTH= 32;
constexpr size_t CHALLENGE_SALT_LENGTH= 18;
constexpr size_t ED25519_SIG_LENGTH= 64;
constexpr size_t ED25519_KEY_LENGTH= 32;
constexpr size_t PBKDF2_HASH_LENGTH= ED25519_KEY_LENGTH;
constexpr size_t CLIENT_RESPONSE_LENGTH= CHALLENGE_SCRAMBLE_LENGTH
                                         + ED25519_SIG_LENGTH;

constexpr size_t base64_length(size_t input_length)
{
  return ((input_length + 2) / 3) * 4; // with padding
}

constexpr size_t base64_length_raw(size_t input_length)
{
  return (input_length * 4 + 2) / 3; // no padding
}

struct alignas(1) Client_signed_response
{
  union {
    struct {
      uchar client_scramble[CHALLENGE_SCRAMBLE_LENGTH];
      uchar signature[ED25519_SIG_LENGTH];
    };
    uchar start[1];
  };
};

static_assert(sizeof(Client_signed_response) == CLIENT_RESPONSE_LENGTH,
              &quot;Client_signed_response is not aligned.&quot;);

struct alignas(1) Passwd_as_stored
{
  char algorithm;
  uchar iterations;
  char colon;
  char salt[base64_length_raw(CHALLENGE_SALT_LENGTH)];
  char colon2;
  char pub_key[base64_length_raw(ED25519_KEY_LENGTH)];
};

struct alignas(1) Passwd_in_memory
{
  char algorithm;
  uchar iterations;
  uchar salt[CHALLENGE_SALT_LENGTH];
  uchar pub_key[ED25519_KEY_LENGTH];
};

int print_ssl_error()
{
  char buf[512];
  unsigned long err= ERR_get_error();
  ERR_error_string_n(err, buf, sizeof buf);
  my_printf_error(err, &quot;parsec: %s&quot;, ME_ERROR_LOG_ONLY, buf);
  return 1;
}

static
int compute_derived_key(const char* password, size_t pass_len,
                         const Passwd_in_memory *params, uchar *derived_key)
{
  assert(params-&gt;algorithm == &#039;P&#039;);
  int ret = PKCS5_PBKDF2_HMAC(password, (int)pass_len, params-&gt;salt,
                              sizeof(params-&gt;salt), 1024 &lt;&lt; params-&gt;iterations,
                              EVP_sha512(), PBKDF2_HASH_LENGTH, derived_key);
  if(ret == 0)
    return print_ssl_error();

  return 0;
}


static
int verify_ed25519(const uchar *public_key, const uchar *signature,
                    const uchar *message, size_t message_len)
{
#ifdef HAVE_WOLFSSL
  int res= wolfSSL_ED25519_verify(message, (unsigned)message_len,
                                  public_key, ED25519_KEY_LENGTH,
                                  signature, ED25519_SIG_LENGTH);
  return res != WOLFSSL_SUCCESS;
#else
  int ret= 1;
  EVP_MD_CTX *mdctx= EVP_MD_CTX_new();
  EVP_PKEY *pkey= EVP_PKEY_new_raw_public_key(EVP_PKEY_ED25519, NULL,
                                              public_key, 32);

  if (pkey &amp;&amp; mdctx &amp;&amp; EVP_DigestVerifyInit(mdctx, NULL, NULL, NULL, pkey))
    ret= !EVP_DigestVerify(mdctx, signature, ED25519_SIG_LENGTH,
                           message, message_len);
  EVP_MD_CTX_free(mdctx);
  EVP_PKEY_free(pkey);
  return ret;
#endif
}

static
int ed25519_derive_public_key(const uchar *raw_private_key, uchar *pub_key)
{
#ifdef HAVE_WOLFSSL
  ed25519_key key;

  int ret = wc_ed25519_init(&amp;key);
  if (ret != 0)
    return print_ssl_error();

  SCOPE_EXIT([&amp;key](){ wc_ed25519_free(&amp;key); });

  ret = wc_ed25519_import_private_only(raw_private_key, ED25519_KEY_LENGTH,
                                       &amp;key);
  if (ret != 0)
    return print_ssl_error();

  ret = wc_ed25519_make_public(&amp;key, pub_key, ED25519_KEY_LENGTH);
  if (ret != 0)
    return print_ssl_error();

  return false;
#else
  EVP_PKEY *pkey = EVP_PKEY_new_raw_private_key(EVP_PKEY_ED25519, NULL,
                                                raw_private_key,
                                                ED25519_KEY_LENGTH);
  bool res= pkey != NULL;
  size_t len= ED25519_KEY_LENGTH;
  if (pkey)
    res= EVP_PKEY_get_raw_public_key(pkey, pub_key, &amp;len); // 1 == success

  if (!res)
    print_ssl_error();

  EVP_PKEY_free(pkey);
  return !res;
#endif
}

static
int hash_password(const char *password, size_t password_length,
                  char *hash, size_t *hash_length)
{
  auto stored= (Passwd_as_stored*)hash;
  assert(*hash_length &gt;= sizeof(*stored) + 2); // it should fit the buffer

  Passwd_in_memory memory;
  memory.algorithm= &#039;P&#039;;
  memory.iterations= 0;
  my_random_bytes(memory.salt, sizeof(memory.salt));

  uchar derived_key[PBKDF2_HASH_LENGTH];
  if (compute_derived_key(password, password_length, &amp;memory, derived_key))
    return 1;

  if (ed25519_derive_public_key(derived_key, memory.pub_key))
    return 1;

  stored-&gt;algorithm= memory.algorithm;
  stored-&gt;iterations= memory.iterations + &#039;0&#039;;
  my_base64_encode(memory.salt, sizeof(memory.salt), stored-&gt;salt);
  my_base64_encode(memory.pub_key, sizeof(memory.pub_key), stored-&gt;pub_key);
  stored-&gt;colon= stored-&gt;colon2= &#039;:&#039;;

  *hash_length = sizeof *stored;
  hash[*hash_length]= 0; // safety

  return 0;
}

static
int digest_to_binary(const char *hash, size_t hash_length,
                    unsigned char *out, size_t *out_length)
{
  auto stored= (Passwd_as_stored*)hash;
  auto memory= (Passwd_in_memory*)out;

  if (hash_length != sizeof (*stored) || *out_length &lt; sizeof(*memory) ||
      stored-&gt;algorithm != &#039;P&#039; ||
      stored-&gt;iterations &lt; &#039;0&#039; || stored-&gt;iterations &gt; &#039;3&#039; ||
      stored-&gt;colon != &#039;:&#039; || stored-&gt;colon2 != &#039;:&#039;)
  {
    my_printf_error(ER_PASSWD_LENGTH, &quot;Wrong ext-salt format&quot;, 0);
    return 1;
  }

  *out_length = sizeof(*memory);
  memory-&gt;algorithm= stored-&gt;algorithm;
  memory-&gt;iterations= stored-&gt;iterations - &#039;0&#039;;

  static_assert(base64_length(CHALLENGE_SALT_LENGTH) == base64_length_raw(CHALLENGE_SALT_LENGTH),
                &quot;Salt is base64-aligned&quot;);
  if (my_base64_decode(stored-&gt;salt, base64_length(CHALLENGE_SALT_LENGTH),
                       memory-&gt;salt, NULL, 0) &lt; 0)
  {
    my_printf_error(ER_PASSWD_LENGTH,
                    &quot;Password salt should be base64 encoded&quot;, 0);
    return 1;
  }

  char buf[base64_length(ED25519_KEY_LENGTH)+1];
  constexpr int pad= (int)base64_length(ED25519_KEY_LENGTH)
                     - (int)base64_length_raw(ED25519_KEY_LENGTH);
  static_assert(pad &gt; 0, &quot;base64 length calculation check&quot;);
  memcpy(buf, stored-&gt;pub_key, base64_length_raw(ED25519_KEY_LENGTH));
  memset(buf + base64_length_raw(ED25519_KEY_LENGTH), &#039;=&#039;, pad);
  if (my_base64_decode(buf, base64_length(ED25519_KEY_LENGTH),
                       memory-&gt;pub_key, NULL, 0) &lt; 0)
  {
    my_printf_error(ER_PASSWD_LENGTH,
                    &quot;Password-derived key should be base64 encoded&quot;, 0);
    return 1;
  }

  return 0;
}

static
int auth(MYSQL_PLUGIN_VIO *vio, MYSQL_SERVER_AUTH_INFO *info)
{
  union
  {
    struct
    {
      uchar server[CHALLENGE_SCRAMBLE_LENGTH];
      uchar client[CHALLENGE_SCRAMBLE_LENGTH];
    };
    uchar start[1];
  } scramble_pair;

  my_random_bytes(scramble_pair.server, CHALLENGE_SCRAMBLE_LENGTH);

  if (vio-&gt;write_packet(vio, scramble_pair.server, sizeof(scramble_pair.server)))
    return CR_ERROR;

  // Begin with reading the handshake packet. It should be empty (for now).
  uchar *dummy;
  int bytes_read= vio-&gt;read_packet(vio, &amp;dummy);
  if (bytes_read != 0)
    return CR_ERROR;

  auto passwd= (Passwd_in_memory*)info-&gt;auth_string;

  if (vio-&gt;write_packet(vio, (uchar*)info-&gt;auth_string, 2 + CHALLENGE_SALT_LENGTH))
    return CR_ERROR;

  Client_signed_response *client_response;
  bytes_read= vio-&gt;read_packet(vio, (uchar**)&amp;client_response);
  if (bytes_read &lt; 0)
    return CR_ERROR;
  if (bytes_read != sizeof *client_response)
    return CR_AUTH_HANDSHAKE;

  memcpy(scramble_pair.client, client_response-&gt;client_scramble,
         CHALLENGE_SCRAMBLE_LENGTH);

  if (verify_ed25519(passwd-&gt;pub_key, client_response-&gt;signature,
                     scramble_pair.start, sizeof(scramble_pair)))
    return CR_AUTH_HANDSHAKE;

  return CR_OK;
}

static struct st_mysql_auth info =
{
  MYSQL_AUTHENTICATION_INTERFACE_VERSION,
  &quot;parsec&quot;,
  auth,
  hash_password,
  digest_to_binary
};


maria_declare_plugin(auth_parsec)
{
  MYSQL_AUTHENTICATION_PLUGIN,
  &amp;info,
  &quot;parsec&quot;,
  &quot;Nikita Maliavin&quot;,
  &quot;Password Authentication using Response Signed with Elliptic Curve&quot;,
  PLUGIN_LICENSE_GPL,
  NULL,
  NULL,
  0x0100,
  NULL,
  NULL,
  &quot;1.0&quot;,
  MariaDB_PLUGIN_MATURITY_GAMMA
}
maria_declare_plugin_end;
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fplugin%2Fauth_parsec'>🔙 Back</a></p>