| 1 | # ---?--- |
| 2 | # |
| 3 | # $Id$ |
| 4 | # |
| 5 | # Miscellaneous function interfaces |
| 6 | # |
| 7 | # (c) 2001 Straylight/Edgeware |
| 8 | # |
| 9 | |
| 10 | #----- Licensing notice ----------------------------------------------------- |
| 11 | # |
| 12 | # This file is part of the Perl interface to Catacomb. |
| 13 | # |
| 14 | # Catacomb/Perl is free software; you can redistribute it and/or modify |
| 15 | # it under the terms of the GNU General Public License as published by |
| 16 | # the Free Software Foundation; either version 2 of the License, or |
| 17 | # (at your option) any later version. |
| 18 | # |
| 19 | # Catacomb/Perl is distributed in the hope that it will be useful, |
| 20 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 21 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 22 | # GNU General Public License for more details. |
| 23 | # |
| 24 | # You should have received a copy of the GNU General Public License |
| 25 | # along with Catacomb/Perl; if not, write to the Free Software Foundation, |
| 26 | # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| 27 | |
| 28 | MODULE = Catacomb PACKAGE = Catacomb::Share::GF PREFIX = gfshare_ |
| 29 | |
| 30 | Share_GF * |
| 31 | new(me, t, sz) |
| 32 | SV *me |
| 33 | UV t |
| 34 | UV sz |
| 35 | CODE: |
| 36 | RETVAL = CREATE(Share_GF); |
| 37 | if (t < 1 || t > 255) |
| 38 | croak("share threshhold out of range"); |
| 39 | gfshare_create(RETVAL, t, sz); |
| 40 | OUTPUT: |
| 41 | RETVAL |
| 42 | |
| 43 | UV |
| 44 | sz(s) |
| 45 | Share_GF *s |
| 46 | CODE: |
| 47 | RETVAL = s->sz; |
| 48 | OUTPUT: |
| 49 | RETVAL |
| 50 | |
| 51 | UV |
| 52 | t(s) |
| 53 | Share_GF *s |
| 54 | CODE: |
| 55 | RETVAL = s->t; |
| 56 | OUTPUT: |
| 57 | RETVAL |
| 58 | |
| 59 | UV |
| 60 | i(s) |
| 61 | Share_GF *s |
| 62 | CODE: |
| 63 | RETVAL = s->i; |
| 64 | OUTPUT: |
| 65 | RETVAL |
| 66 | |
| 67 | SV * |
| 68 | DESTROY(s) |
| 69 | Share_GF *s |
| 70 | CODE: |
| 71 | gfshare_destroy(s); |
| 72 | DESTROY(s); |
| 73 | XSRETURN_YES; |
| 74 | |
| 75 | SV * |
| 76 | mkshares(s, x, r = &rand_global) |
| 77 | Share_GF *s |
| 78 | SV *x |
| 79 | grand *r |
| 80 | PREINIT: |
| 81 | char *p; |
| 82 | STRLEN len; |
| 83 | CODE: |
| 84 | p = SvPV(x, len); |
| 85 | if (len != s->sz) |
| 86 | croak("secret length mismatch"); |
| 87 | gfshare_mkshares(s, r, p); |
| 88 | s->i = ~0u; |
| 89 | XSRETURN_YES; |
| 90 | |
| 91 | SV * |
| 92 | get(s, i) |
| 93 | Share_GF *s |
| 94 | UV i |
| 95 | CODE: |
| 96 | if (i >= 255) |
| 97 | croak("share index out of range"); |
| 98 | if (s->i != ~0u) |
| 99 | croak("not making shares"); |
| 100 | RETVAL = NEWSV(0, s->sz); |
| 101 | SvPOK_on(RETVAL); |
| 102 | gfshare_get(s, i, SvPVX(RETVAL)); |
| 103 | SvCUR_set(RETVAL, s->sz); |
| 104 | OUTPUT: |
| 105 | RETVAL |
| 106 | |
| 107 | unsigned |
| 108 | add(s, i, x) |
| 109 | Share_GF *s |
| 110 | UV i |
| 111 | SV *x |
| 112 | PREINIT: |
| 113 | char *p; |
| 114 | STRLEN len; |
| 115 | CODE: |
| 116 | p = SvPV(x, len); |
| 117 | if (len != s->sz) |
| 118 | croak("secret length mismatch"); |
| 119 | if (i == ~0u) |
| 120 | croak("making shares"); |
| 121 | if (i >= 255) |
| 122 | croak("share index out of range"); |
| 123 | if (s->i >= s->t) |
| 124 | croak("too many shares"); |
| 125 | RETVAL = gfshare_add(s, i, p); |
| 126 | OUTPUT: |
| 127 | RETVAL |
| 128 | |
| 129 | SV * |
| 130 | combine(s) |
| 131 | Share_GF *s |
| 132 | CODE: |
| 133 | if (s->i == ~0u) |
| 134 | croak("making shares"); |
| 135 | if (s->i != s->t) |
| 136 | croak("not enough shares yet"); |
| 137 | RETVAL = NEWSV(0, s->sz); |
| 138 | SvPOK_on(RETVAL); |
| 139 | gfshare_combine(s, SvPVX(RETVAL)); |
| 140 | SvCUR_set(RETVAL, s->sz); |
| 141 | OUTPUT: |
| 142 | RETVAL |
| 143 | |
| 144 | MODULE = Catacomb PACKAGE = Catacomb::Share::Prime PREFIX = share_ |
| 145 | |
| 146 | Share_Prime * |
| 147 | new(me, t, p = &PL_sv_undef) |
| 148 | SV *me |
| 149 | UV t |
| 150 | SV *p |
| 151 | CODE: |
| 152 | RETVAL = CREATE(Share_Prime); |
| 153 | if (t < 1 || t > MPW_MAX) |
| 154 | croak("share threshhold out of range"); |
| 155 | share_create(RETVAL, t); |
| 156 | if (SvOK(p)) |
| 157 | RETVAL->p = mp_fromsv(p, "p", 0, 1); |
| 158 | OUTPUT: |
| 159 | RETVAL |
| 160 | |
| 161 | mp * |
| 162 | p(s) |
| 163 | Share_Prime *s |
| 164 | CODE: |
| 165 | if (!s->p) |
| 166 | XSRETURN_UNDEF; |
| 167 | RETVAL = MP_COPY(s->p); |
| 168 | OUTPUT: |
| 169 | RETVAL |
| 170 | |
| 171 | UV |
| 172 | t(s) |
| 173 | Share_Prime *s |
| 174 | CODE: |
| 175 | RETVAL = s->t; |
| 176 | OUTPUT: |
| 177 | RETVAL |
| 178 | |
| 179 | UV |
| 180 | i(s) |
| 181 | Share_Prime *s |
| 182 | CODE: |
| 183 | RETVAL = s->i; |
| 184 | OUTPUT: |
| 185 | RETVAL |
| 186 | |
| 187 | SV * |
| 188 | DESTROY(s) |
| 189 | Share_Prime *s |
| 190 | CODE: |
| 191 | share_destroy(s); |
| 192 | DESTROY(s); |
| 193 | XSRETURN_YES; |
| 194 | |
| 195 | SV * |
| 196 | mkshares(s, x, r = &rand_global) |
| 197 | Share_Prime *s |
| 198 | mp *x |
| 199 | grand *r |
| 200 | CODE: |
| 201 | if (s->p && MP_CMP(s->p, <=, x)) |
| 202 | croak("secret out of range"); |
| 203 | share_mkshares(s, r, x); |
| 204 | s->i = ~0u; |
| 205 | XSRETURN_YES; |
| 206 | |
| 207 | mp * |
| 208 | share_get(s, i) |
| 209 | Share_Prime *s |
| 210 | UV i |
| 211 | INIT: |
| 212 | if (i >= MPW_MAX) |
| 213 | croak("share index out of range"); |
| 214 | if (s->i != ~0u) |
| 215 | croak("not making shares"); |
| 216 | C_ARGS: |
| 217 | s, MP_NEW, i |
| 218 | |
| 219 | unsigned |
| 220 | share_add(s, i, x) |
| 221 | Share_Prime *s |
| 222 | UV i |
| 223 | mp *x |
| 224 | INIT: |
| 225 | if (!s->p) |
| 226 | croak("no prime set"); |
| 227 | if (i == ~0u) |
| 228 | croak("making shares"); |
| 229 | if (i >= MPW_MAX) |
| 230 | croak("share index out of range"); |
| 231 | if (s->i >= s->t) |
| 232 | croak("too many shares"); |
| 233 | C_ARGS: |
| 234 | s, i, x |
| 235 | |
| 236 | mp * |
| 237 | share_combine(s) |
| 238 | Share_Prime *s |
| 239 | INIT: |
| 240 | if (s->i == ~0u) |
| 241 | croak("making shares"); |
| 242 | if (s->i != s->t) |
| 243 | croak("not enough shares yet"); |
| 244 | |
| 245 | MODULE = Catacomb PACKAGE = Catacomb::Passphrase |
| 246 | |
| 247 | SV * |
| 248 | read(me, tag, len = 256) |
| 249 | SV *me |
| 250 | char *tag |
| 251 | int len |
| 252 | CODE: |
| 253 | RETVAL = NEWSV(0, len); |
| 254 | if (passphrase_read(tag, PMODE_READ, SvPVX(RETVAL), len + 1)) |
| 255 | XSRETURN_UNDEF; |
| 256 | SvCUR_set(RETVAL, strlen(SvPVX(RETVAL))); |
| 257 | SvPOK_on(RETVAL); |
| 258 | OUTPUT: |
| 259 | RETVAL |
| 260 | |
| 261 | SV * |
| 262 | verify(me, tag, len = 256) |
| 263 | SV *me |
| 264 | char *tag |
| 265 | int len |
| 266 | CODE: |
| 267 | RETVAL = NEWSV(0, len); |
| 268 | if (passphrase_read(tag, PMODE_VERIFY, SvPVX(RETVAL), len + 1)) |
| 269 | XSRETURN_UNDEF; |
| 270 | SvCUR_set(RETVAL, strlen(SvPVX(RETVAL))); |
| 271 | SvPOK_on(RETVAL); |
| 272 | OUTPUT: |
| 273 | RETVAL |
| 274 | |
| 275 | SV * |
| 276 | cancel(me, tag) |
| 277 | SV *me |
| 278 | char *tag |
| 279 | CODE: |
| 280 | passphrase_cancel(tag); |
| 281 | XSRETURN_YES; |
| 282 | |
| 283 | MODULE = Catacomb PACKAGE = Catacomb::KeySize |
| 284 | |
| 285 | int |
| 286 | keysz(ksz, sz) |
| 287 | keysize *ksz |
| 288 | int sz |
| 289 | CODE: |
| 290 | RETVAL = keysz(sz, ksz); |
| 291 | OUTPUT: |
| 292 | RETVAL |
| 293 | |
| 294 | void |
| 295 | expand(ksz) |
| 296 | keysize *ksz |
| 297 | PREINIT: |
| 298 | int i; |
| 299 | PPCODE: |
| 300 | switch (ksz[0]) { |
| 301 | case KSZ_ANY: |
| 302 | XPUSHs(sv_2mortal(newSVpv("ANY", 0))); |
| 303 | XPUSHs(sv_2mortal(newSViv(ksz[1]))); |
| 304 | break; |
| 305 | case KSZ_RANGE: |
| 306 | XPUSHs(sv_2mortal(newSVpv("RANGE", 0))); |
| 307 | for (i = 1; i < 5; i++) |
| 308 | XPUSHs(sv_2mortal(newSViv(ksz[i]))); |
| 309 | break; |
| 310 | case KSZ_SET: |
| 311 | XPUSHs(sv_2mortal(newSVpv("SET", 0))); |
| 312 | for (i = 1; ksz[i]; i++) |
| 313 | XPUSHs(sv_2mortal(newSViv(ksz[i]))); |
| 314 | break; |
| 315 | default: |
| 316 | abort(); |
| 317 | } |
| 318 | |
| 319 | #----- That's all, folks ---------------------------------------------------- |