U2F.xs

   1 #define PERL_NO_GET_CONTEXT
   2 #include "EXTERN.h"
   3 #include "perl.h"
   4 #include "XSUB.h"
   5
   6 #include "ppport.h"
   7
   8 #include <u2f-server.h>
   9
  10 MODULE = PVE::U2F               PACKAGE = PVE::U2F
  11
  12 #// Context creation and destruction
  13
  14 void
  15 do_global_init()
  16         CODE:
  17                 u2fs_global_init(0);
  18
  19 void
  20 do_global_done()
  21         CODE:
  22                 u2fs_global_done();
  23
  24 SV*
  25 new_impl()
  26         CODE:
  27                 u2fs_ctx_t *ctx = NULL;
  28                 if (u2fs_init(&ctx) != U2FS_OK) {
  29                         RETVAL = &PL_sv_undef;
  30                 } else {
  31                         RETVAL = newSVpv((char*)&ctx, sizeof(ctx));
  32                 }
  33         OUTPUT:
  34                 RETVAL
  35
  36 void
  37 done_impl(ctx)
  38         SV *ctx
  39         CODE:
  40                 if (ctx == &PL_sv_undef) {
  41                         croak("u2fs xs: double free");
  42                 } else {
  43                         u2fs_ctx_t **pctx = (u2fs_ctx_t**)SvPV_nolen(ctx);
  44                         u2fs_done(*pctx);
  45                         sv_setsv(ctx, &PL_sv_undef);
  46                 }
  47
  48 #// Context initialization before registration/authentication
  49
  50 int
  51 set_origin_impl(ctx, origin)
  52         SV *ctx
  53         char *origin
  54         CODE:
  55                 u2fs_ctx_t **pctx = (u2fs_ctx_t**)SvPV_nolen(ctx);
  56                 RETVAL = u2fs_set_origin(*pctx, origin);
  57         OUTPUT:
  58                 RETVAL
  59
  60 int
  61 set_appid_impl(ctx, appid)
  62         SV *ctx
  63         char *appid
  64         CODE:
  65                 u2fs_ctx_t **pctx = (u2fs_ctx_t**)SvPV_nolen(ctx);
  66                 RETVAL = u2fs_set_appid(*pctx, appid);
  67         OUTPUT:
  68                 RETVAL
  69
  70 int
  71 set_challenge_impl(ctx, challenge)
  72         SV *ctx
  73         char *challenge
  74         CODE:
  75                 u2fs_ctx_t **pctx = (u2fs_ctx_t**)SvPV_nolen(ctx);
  76                 RETVAL = u2fs_set_challenge(*pctx, challenge);
  77         OUTPUT:
  78                 RETVAL
  79
  80 int
  81 set_keyHandle_impl(ctx, keyHandle)
  82         SV *ctx
  83         char *keyHandle
  84         CODE:
  85                 u2fs_ctx_t **pctx = (u2fs_ctx_t**)SvPV_nolen(ctx);
  86                 RETVAL = u2fs_set_keyHandle(*pctx, keyHandle);
  87         OUTPUT:
  88                 RETVAL
  89
  90 int
  91 set_publicKey_impl(ctx, publicKey)
  92         SV *ctx
  93         unsigned char *publicKey
  94         CODE:
  95                 u2fs_ctx_t **pctx = (u2fs_ctx_t**)SvPV_nolen(ctx);
  96                 RETVAL = u2fs_set_publicKey(*pctx, publicKey);
  97         OUTPUT:
  98                 RETVAL
  99
 100 #// Registration functions
 101
 102 int
 103 registration_challenge_impl(ctx, outref=&PL_sv_undef)
 104         SV *ctx
 105         SV *outref
 106         CODE:
 107                 u2fs_ctx_t **pctx = (u2fs_ctx_t**)SvPV_nolen(ctx);
 108                 char *output = NULL;
 109                 u2fs_rc rc = u2fs_registration_challenge(*pctx, &output);
 110                 if (rc == U2FS_OK) {
 111                         sv_setpv(outref, output);
 112                 }
 113                 RETVAL = rc;
 114         OUTPUT:
 115                 RETVAL
 116
 117 int
 118 registration_verify_impl(ctx, response, kh=&PL_sv_undef, pk=&PL_sv_undef)
 119         SV *ctx
 120         char *response
 121         SV *kh
 122         SV *pk
 123         CODE:
 124                 u2fs_ctx_t **pctx = (u2fs_ctx_t**)SvPV_nolen(ctx);
 125                 u2fs_reg_res_t *result = NULL;
 126                 u2fs_rc rc = u2fs_registration_verify(*pctx, response, &result);
 127                 if (rc == U2FS_OK) {
 128                         const char *keyHandle = u2fs_get_registration_keyHandle(result);
 129                         const char *publicKey = u2fs_get_registration_publicKey(result);
 130                         sv_setpv(kh, keyHandle);
 131                         sv_setpv(pk, publicKey);
 132                         u2fs_free_reg_res(result);
 133                 }
 134                 RETVAL = rc;
 135         OUTPUT:
 136                 RETVAL
 137
 138 #// Authentication functions
 139 int
 140 auth_challenge_impl(ctx, outref=&PL_sv_undef)
 141         SV *ctx
 142         SV *outref
 143         CODE:
 144                 u2fs_ctx_t **pctx = (u2fs_ctx_t**)SvPV_nolen(ctx);
 145                 char *output = NULL;
 146                 u2fs_rc rc = u2fs_authentication_challenge(*pctx, &output);
 147                 if (rc == U2FS_OK) {
 148                         sv_setpv(outref, output);
 149                 }
 150                 RETVAL = rc;
 151         OUTPUT:
 152                 RETVAL
 153
 154 int
 155 auth_verify_impl(ctx, response, verified=&PL_sv_undef, counter=&PL_sv_undef, presence=&PL_sv_undef)
 156         SV *ctx
 157         char *response
 158         SV *verified
 159         SV *counter
 160         SV *presence
 161         CODE:
 162                 u2fs_ctx_t **pctx = (u2fs_ctx_t**)SvPV_nolen(ctx);
 163                 u2fs_auth_res_t *result = NULL;
 164                 u2fs_rc rc = u2fs_authentication_verify(*pctx, response, &result);
 165                 if (rc == U2FS_OK) {
 166                         u2fs_rc a_verified = 0;
 167                         uint32_t a_count = 0;
 168                         uint8_t a_presence = 0;
 169                         rc = u2fs_get_authentication_result(result, &a_verified, &a_count, &a_presence);
 170                         if (rc == U2FS_OK) {
 171                                 sv_setiv(verified, a_verified);
 172                                 sv_setuv(counter, a_count);
 173                                 sv_setuv(presence, a_presence);
 174                         }
 175                         u2fs_free_auth_res(result);
 176                 }
 177                 RETVAL = rc;
 178         OUTPUT:
 179                 RETVAL