view release on metacpan or  search on metacpan

inc/core.xs  view on Meta::CPAN

MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::Core

void
_define_constants()
  PREINIT:
  HV *stash = gv_stashpv("Crypt::Sodium::XS::Core", 0);

  PPCODE:
  newCONSTSUB(stash, "ed25519_BYTES",
              newSVuv(crypto_core_ed25519_BYTES));
  newCONSTSUB(stash, "ed25519_HASHBYTES",
              newSVuv(crypto_core_ed25519_HASHBYTES));
  newCONSTSUB(stash, "ed25519_NONREDUCEDSCALARBYTES",
              newSVuv(crypto_core_ed25519_NONREDUCEDSCALARBYTES));
  newCONSTSUB(stash, "ed25519_SCALARBYTES",
              newSVuv(crypto_core_ed25519_SCALARBYTES));
  newCONSTSUB(stash, "ed25519_UNIFORMBYTES",
              newSVuv(crypto_core_ed25519_UNIFORMBYTES));
  newCONSTSUB(stash, "ristretto255_BYTES",
              newSVuv(crypto_core_ristretto255_BYTES));
  newCONSTSUB(stash, "ristretto255_HASHBYTES",
              newSVuv(crypto_core_ristretto255_HASHBYTES));
  newCONSTSUB(stash, "ristretto255_NONREDUCEDSCALARBYTES",
              newSVuv(crypto_core_ristretto255_NONREDUCEDSCALARBYTES));
  newCONSTSUB(stash, "ristretto255_SCALARBYTES",
              newSVuv(crypto_core_ristretto255_SCALARBYTES));
  newCONSTSUB(stash, "hchacha20_CONSTBYTES",
              newSVuv(crypto_core_hchacha20_CONSTBYTES));
  newCONSTSUB(stash, "hchacha20_INPUTBYTES",
              newSVuv(crypto_core_hchacha20_INPUTBYTES));
  newCONSTSUB(stash, "hchacha20_KEYBYTES",
              newSVuv(crypto_core_hchacha20_KEYBYTES));
  newCONSTSUB(stash, "hchacha20_OUTPUTBYTES",
              newSVuv(crypto_core_hchacha20_OUTPUTBYTES));

SV * ed25519_add(SV * p, SV * q)

  ALIAS:
  ed25519_sub = 1
  ristretto255_add = 2
  ristretto255_sub = 3

  PREINIT:
  protmem *p_pm = NULL, *q_pm = NULL;
  int ret;
  unsigned char *a_buf, *p_buf, *q_buf;
  STRLEN a_len, p_len, p_req_len, q_len, q_req_len;

  CODE:
  switch(ix) {
    /* case 1 is same as default */
    case 2:
      /* fallthrough */
    case 3:
      a_len = crypto_core_ristretto255_BYTES;
      p_req_len = crypto_core_ristretto255_BYTES;
      q_req_len = crypto_core_ristretto255_BYTES;
      break;
    default:
      a_len = crypto_core_ed25519_BYTES;
      p_req_len = crypto_core_ed25519_BYTES;
      q_req_len = crypto_core_ed25519_BYTES;
  }
  if (sv_derived_from(p, MEMVAULT_CLASS)) {
    p_pm = protmem_get(aTHX_ p, MEMVAULT_CLASS);
    p_buf = p_pm->pm_ptr;
    p_len = p_pm->size;
  }

inc/core.xs  view on Meta::CPAN

  RETVAL = newSV(0);
  sv_usepvn_flags(RETVAL, (char *)a_buf, a_len, SV_HAS_TRAILING_NUL);

  OUTPUT:
  RETVAL

SV * ed25519_from_uniform(SV * r)

  ALIAS:
  ristretto255_from_hash = 1

  PREINIT:
  STRLEN p_len, r_len, r_req_len;
  unsigned char *p_buf, *r_buf;

  CODE:
  switch(ix) {
    case 1:
      p_len = crypto_core_ristretto255_BYTES;
      r_req_len = crypto_core_ristretto255_BYTES;
      break;
    default:
      p_len = crypto_core_ed25519_BYTES;
      r_req_len = crypto_core_ed25519_BYTES;
  }
  r_buf = (unsigned char *)SvPVbyte(r, r_len);
  if (r_len != r_req_len)
    croak("ed25519_from_uniform: invalid vector length");

  Newx(p_buf, p_len + 1, unsigned char);
  if (p_buf == NULL)
    croak("ed25519_from_uniform: Failed to allocate memory");
  p_buf[p_len] = '\0';

  switch(ix) {
    case 1:
      crypto_core_ristretto255_from_hash(p_buf, r_buf);
      break;
    default:
      crypto_core_ed25519_from_uniform(p_buf, r_buf);
  }

  RETVAL = newSV(0);
  sv_usepvn_flags(RETVAL, (char *)p_buf, p_len, SV_HAS_TRAILING_NUL);

  OUTPUT:
  RETVAL

SV * ed25519_is_valid_point(SV * p)

  ALIAS:
  ristretto255_is_valid_point = 1

  PREINIT:
  protmem *p_pm = NULL;
  int ret;
  unsigned char *p_buf;
  STRLEN p_len, p_req_len;

  PPCODE:
  PERL_UNUSED_VAR(RETVAL);
  switch(ix) {
    case 1:
      p_req_len = crypto_core_ristretto255_BYTES;
      break;
    default:
      p_req_len = crypto_core_ed25519_BYTES;
  }
  if (sv_derived_from(p, MEMVAULT_CLASS)) {
    p_pm = protmem_get(aTHX_ p, MEMVAULT_CLASS);
    p_buf = p_pm->pm_ptr;
    p_len = p_pm->size;
  }
  else
    p_buf = (unsigned char *)SvPVbyte(p, p_len);
  if (p_len != p_req_len)
    croak("ed25519_is_valid_point: Invalid point length");

  if (p_pm && protmem_grant(aTHX_ p_pm, PROTMEM_FLAG_MPROTECT_RO) != 0)
    croak("ed25519_is_valid_point: Failed to grant protmem RO");

  switch(ix) {
    case 1:
      ret = crypto_core_ristretto255_is_valid_point(p_buf);
      break;
    default:
      ret = crypto_core_ed25519_is_valid_point(p_buf);
  }

  if (p_pm && protmem_release(aTHX_ p_pm, PROTMEM_FLAG_MPROTECT_RO) != 0)
    croak("ed25519_is_valid_point: Failed to release protmem RO");

  if (ret == 1)
    XSRETURN_YES;
  XSRETURN_NO;

SV * ed25519_random()

  ALIAS:
  ristretto255_random = 1

  PREINIT:
  unsigned char *p_buf;
  STRLEN p_len;

  CODE:
  switch(ix) {
    case 1:
      p_len = crypto_core_ristretto255_BYTES;
      break;
    default:
      p_len = crypto_core_ed25519_BYTES;
  }
  Newx(p_buf, p_len + 1, unsigned char);
  if (p_buf == NULL)
    croak("ed25519_scalar_random: Failed to allocate memory");
  p_buf[p_len] = '\0';

  switch(ix) {
    case 1: