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