hackney

3.0.1

4.7.2 4.7.1 4.7.0 4.6.1 4.6.0 4.5.2 4.5.1 4.5.0 4.4.5 4.4.3 4.4.2 4.4.1 4.4.0 4.3.0 4.2.3 4.2.2 4.2.1 4.2.0 4.1.0 4.0.3 4.0.2 4.0.1 4.0.0 3.2.1 3.2.0 3.1.2 3.1.1 3.1.0 3.0.3 3.0.2 3.0.1 3.0.0 retired 2.0.1 2.0.0 2.0.0-beta.1 1.25.0 1.24.1 1.24.0 1.23.0 1.22.0 1.21.0 1.20.1 1.20.0 1.19.1 1.19.0 1.18.2 1.18.1 1.18.0 1.17.4 1.17.3 1.17.2 1.17.1 1.17.0 1.16.0 1.15.2 1.15.1 1.15.0 1.14.3 1.14.2 1.14.0 1.13.0 1.12.1 1.12.0 1.11.0 1.10.1 1.10.0 1.9.0 1.8.6 1.8.5 1.8.4 1.8.3 1.8.2 1.8.0 1.7.1 1.7.0 1.6.6 retired 1.6.5 1.6.4 retired 1.6.3 1.6.2 1.6.1 1.6.0 1.5.7 1.5.6 1.5.5 1.5.4 1.5.3 1.5.2 1.5.1 1.5.0 1.4.10 1.4.8 1.4.7 1.4.6 1.4.5 1.4.4 1.4.3 1.4.2 1.4.1 1.4.0 1.3.2 1.3.1 1.3.0 1.2.0 1.1.0 1.0.6 1.0.5 1.0.2 1.0.1 0.15.2 0.15.0 0.14.3 0.14.2 0.14.1 0.14.0 0.13.1

Simple HTTP client with HTTP/1.1, HTTP/2, and HTTP/3 support

Security advisory: This version has known vulnerabilities. View advisories

HexDocs

Current section

Files

Jump to

Readme 116 Versions 6 Dependencies Dependants 12 Advisories Files Activity

hackney c_src boringssl crypto mldsa mldsa.cc

Raw

c_src/boringssl/crypto/mldsa/mldsa.cc

// Copyright 2024 The BoringSSL Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <openssl/mldsa.h>

#include "../fipsmodule/bcm_interface.h"

int MLDSA65_generate_key(
    uint8_t out_encoded_public_key[MLDSA65_PUBLIC_KEY_BYTES],
    uint8_t out_seed[MLDSA_SEED_BYTES],
    struct MLDSA65_private_key *out_private_key) {
  return bcm_success(BCM_mldsa65_generate_key(out_encoded_public_key, out_seed,
                                              out_private_key));
}

int MLDSA65_private_key_from_seed(struct MLDSA65_private_key *out_private_key,
                                  const uint8_t *seed, size_t seed_len) {
  if (seed_len != MLDSA_SEED_BYTES) {
    return 0;
  }
  return bcm_success(BCM_mldsa65_private_key_from_seed(out_private_key, seed));
}

int MLDSA65_public_from_private(struct MLDSA65_public_key *out_public_key,
                                const struct MLDSA65_private_key *private_key) {
  return bcm_success(
      BCM_mldsa65_public_from_private(out_public_key, private_key));
}

int MLDSA65_sign(uint8_t out_encoded_signature[MLDSA65_SIGNATURE_BYTES],
                 const struct MLDSA65_private_key *private_key,
                 const uint8_t *msg, size_t msg_len, const uint8_t *context,
                 size_t context_len) {
  if (context_len > 255) {
    return 0;
  }
  return bcm_success(BCM_mldsa65_sign(out_encoded_signature, private_key, msg,
                                      msg_len, context, context_len));
}

int MLDSA65_verify(const struct MLDSA65_public_key *public_key,
                   const uint8_t *signature, size_t signature_len,
                   const uint8_t *msg, size_t msg_len, const uint8_t *context,
                   size_t context_len) {
  if (context_len > 255 || signature_len != MLDSA65_SIGNATURE_BYTES) {
    return 0;
  }
  return bcm_success(BCM_mldsa65_verify(public_key, signature, msg, msg_len,
                                        context, context_len));
}

int MLDSA65_prehash_init(struct MLDSA65_prehash *out_state,
                         const struct MLDSA65_public_key *public_key,
                         const uint8_t *context, size_t context_len) {
  if (context_len > 255) {
    return 0;
  }
  BCM_mldsa65_prehash_init(out_state, public_key, context, context_len);
  return 1;
}

void MLDSA65_prehash_update(struct MLDSA65_prehash *inout_state,
                            const uint8_t *msg, size_t msg_len) {
  BCM_mldsa65_prehash_update(inout_state, msg, msg_len);
}

void MLDSA65_prehash_finalize(uint8_t out_msg_rep[MLDSA_MU_BYTES],
                              struct MLDSA65_prehash *inout_state) {
  BCM_mldsa65_prehash_finalize(out_msg_rep, inout_state);
}

int MLDSA65_sign_message_representative(
    uint8_t out_encoded_signature[MLDSA65_SIGNATURE_BYTES],
    const struct MLDSA65_private_key *private_key,
    const uint8_t msg_rep[MLDSA_MU_BYTES]) {
  return bcm_success(BCM_mldsa65_sign_message_representative(
      out_encoded_signature, private_key, msg_rep));
}

int MLDSA65_verify_message_representative(
    const struct MLDSA65_public_key *public_key,
    const uint8_t *signature, size_t signature_len,
    const uint8_t msg_rep[MLDSA_MU_BYTES]) {
  if (signature_len != MLDSA65_SIGNATURE_BYTES) {
    return 0;
  }
  return bcm_success(BCM_mldsa65_verify_message_representative(
      public_key, signature, msg_rep));
}

int MLDSA65_marshal_public_key(CBB *out,
                               const struct MLDSA65_public_key *public_key) {
  return bcm_success(BCM_mldsa65_marshal_public_key(out, public_key));
}

int MLDSA65_parse_public_key(struct MLDSA65_public_key *public_key, CBS *in) {
  return bcm_success(BCM_mldsa65_parse_public_key(public_key, in));
}

int MLDSA87_generate_key(
    uint8_t out_encoded_public_key[MLDSA87_PUBLIC_KEY_BYTES],
    uint8_t out_seed[MLDSA_SEED_BYTES],
    struct MLDSA87_private_key *out_private_key) {
  return bcm_success(BCM_mldsa87_generate_key(out_encoded_public_key, out_seed,
                                              out_private_key));
}

int MLDSA87_private_key_from_seed(struct MLDSA87_private_key *out_private_key,
                                  const uint8_t *seed, size_t seed_len) {
  if (seed_len != MLDSA_SEED_BYTES) {
    return 0;
  }
  return bcm_success(BCM_mldsa87_private_key_from_seed(out_private_key, seed));
}

int MLDSA87_public_from_private(struct MLDSA87_public_key *out_public_key,
                                const struct MLDSA87_private_key *private_key) {
  return bcm_success(
      BCM_mldsa87_public_from_private(out_public_key, private_key));
}

int MLDSA87_sign(uint8_t out_encoded_signature[MLDSA87_SIGNATURE_BYTES],
                 const struct MLDSA87_private_key *private_key,
                 const uint8_t *msg, size_t msg_len, const uint8_t *context,
                 size_t context_len) {
  if (context_len > 255) {
    return 0;
  }
  return bcm_success(BCM_mldsa87_sign(out_encoded_signature, private_key, msg,
                                      msg_len, context, context_len));
}

int MLDSA87_verify(const struct MLDSA87_public_key *public_key,
                   const uint8_t *signature, size_t signature_len,
                   const uint8_t *msg, size_t msg_len, const uint8_t *context,
                   size_t context_len) {
  if (context_len > 255 || signature_len != MLDSA87_SIGNATURE_BYTES) {
    return 0;
  }
  return bcm_success(BCM_mldsa87_verify(public_key, signature, msg, msg_len,
                                        context, context_len));
}

int MLDSA87_prehash_init(struct MLDSA87_prehash *out_state,
                         const struct MLDSA87_public_key *public_key,
                         const uint8_t *context, size_t context_len) {
  if (context_len > 255) {
    return 0;
  }
  BCM_mldsa87_prehash_init(out_state, public_key, context, context_len);
  return 1;
}

void MLDSA87_prehash_update(struct MLDSA87_prehash *inout_state,
                            const uint8_t *msg, size_t msg_len) {
  BCM_mldsa87_prehash_update(inout_state, msg, msg_len);
}

void MLDSA87_prehash_finalize(uint8_t out_msg_rep[MLDSA_MU_BYTES],
                              struct MLDSA87_prehash *inout_state) {
  BCM_mldsa87_prehash_finalize(out_msg_rep, inout_state);
}

int MLDSA87_sign_message_representative(
    uint8_t out_encoded_signature[MLDSA87_SIGNATURE_BYTES],
    const struct MLDSA87_private_key *private_key,
    const uint8_t msg_rep[MLDSA_MU_BYTES]) {
  return bcm_success(BCM_mldsa87_sign_message_representative(
      out_encoded_signature, private_key, msg_rep));
}

int MLDSA87_verify_message_representative(
    const struct MLDSA87_public_key *public_key,
    const uint8_t *signature, size_t signature_len,
    const uint8_t msg_rep[MLDSA_MU_BYTES]) {
  if (signature_len != MLDSA87_SIGNATURE_BYTES) {
    return 0;
  }
  return bcm_success(BCM_mldsa87_verify_message_representative(
      public_key, signature, msg_rep));
}

int MLDSA87_marshal_public_key(CBB *out,
                               const struct MLDSA87_public_key *public_key) {
  return bcm_success(BCM_mldsa87_marshal_public_key(out, public_key));
}

int MLDSA87_parse_public_key(struct MLDSA87_public_key *public_key, CBS *in) {
  return bcm_success(BCM_mldsa87_parse_public_key(public_key, in));
}

int MLDSA44_generate_key(
    uint8_t out_encoded_public_key[MLDSA44_PUBLIC_KEY_BYTES],
    uint8_t out_seed[MLDSA_SEED_BYTES],
    struct MLDSA44_private_key *out_private_key) {
  return bcm_success(BCM_mldsa44_generate_key(out_encoded_public_key, out_seed,
                                              out_private_key));
}

int MLDSA44_private_key_from_seed(struct MLDSA44_private_key *out_private_key,
                                  const uint8_t *seed, size_t seed_len) {
  if (seed_len != MLDSA_SEED_BYTES) {
    return 0;
  }
  return bcm_success(BCM_mldsa44_private_key_from_seed(out_private_key, seed));
}

int MLDSA44_public_from_private(struct MLDSA44_public_key *out_public_key,
                                const struct MLDSA44_private_key *private_key) {
  return bcm_success(
      BCM_mldsa44_public_from_private(out_public_key, private_key));
}

int MLDSA44_sign(uint8_t out_encoded_signature[MLDSA44_SIGNATURE_BYTES],
                 const struct MLDSA44_private_key *private_key,
                 const uint8_t *msg, size_t msg_len, const uint8_t *context,
                 size_t context_len) {
  if (context_len > 255) {
    return 0;
  }
  return bcm_success(BCM_mldsa44_sign(out_encoded_signature, private_key, msg,
                                      msg_len, context, context_len));
}

int MLDSA44_verify(const struct MLDSA44_public_key *public_key,
                   const uint8_t *signature, size_t signature_len,
                   const uint8_t *msg, size_t msg_len, const uint8_t *context,
                   size_t context_len) {
  if (context_len > 255 || signature_len != MLDSA44_SIGNATURE_BYTES) {
    return 0;
  }
  return bcm_success(BCM_mldsa44_verify(public_key, signature, msg, msg_len,
                                        context, context_len));
}

int MLDSA44_prehash_init(struct MLDSA44_prehash *out_state,
                         const struct MLDSA44_public_key *public_key,
                         const uint8_t *context, size_t context_len) {
  if (context_len > 255) {
    return 0;
  }
  BCM_mldsa44_prehash_init(out_state, public_key, context, context_len);
  return 1;
}

void MLDSA44_prehash_update(struct MLDSA44_prehash *inout_state,
                            const uint8_t *msg, size_t msg_len) {
  BCM_mldsa44_prehash_update(inout_state, msg, msg_len);
}

void MLDSA44_prehash_finalize(uint8_t out_msg_rep[MLDSA_MU_BYTES],
                              struct MLDSA44_prehash *inout_state) {
  BCM_mldsa44_prehash_finalize(out_msg_rep, inout_state);
}

int MLDSA44_sign_message_representative(
    uint8_t out_encoded_signature[MLDSA44_SIGNATURE_BYTES],
    const struct MLDSA44_private_key *private_key,
    const uint8_t msg_rep[MLDSA_MU_BYTES]) {
  return bcm_success(BCM_mldsa44_sign_message_representative(
      out_encoded_signature, private_key, msg_rep));
}

int MLDSA44_verify_message_representative(
    const struct MLDSA44_public_key *public_key,
    const uint8_t *signature, size_t signature_len,
    const uint8_t msg_rep[MLDSA_MU_BYTES]) {
  if (signature_len != MLDSA44_SIGNATURE_BYTES) {
    return 0;
  }
  return bcm_success(BCM_mldsa44_verify_message_representative(
      public_key, signature, msg_rep));
}

int MLDSA44_marshal_public_key(CBB *out,
                               const struct MLDSA44_public_key *public_key) {
  return bcm_success(BCM_mldsa44_marshal_public_key(out, public_key));
}

int MLDSA44_parse_public_key(struct MLDSA44_public_key *public_key, CBS *in) {
  return bcm_success(BCM_mldsa44_parse_public_key(public_key, in));
}

Operator	Description	Example
name:	Match package name. Supports * wildcards and repo/package form	name:phx* or name:hexpm/phoenix
description:	Full-text search of package descriptions	description:auth
depends:	Packages depending on a given package. Supports repo:package form	depends:ecto or depends:hexpm:ecto
build_tool:	Filter by build tool	build_tool:mix
updated_after:	Packages updated after an ISO8601 datetime	updated_after:2025-01-01T00:00:00Z
extra:	Match custom metadata (key,value). Nested keys are separated by commas	extra:license,MIT