mdw@git.distorted.org.uk Git - catacomb-perl/blob - algorithms.xs

   1 # ---?---
   2 #
   3 # $Id$
   4 #
   5 # Interface to crypto algorithms
   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::PRPClass
  29
  30 PRPClass *
  31 find(me, name)
  32         SV *me
  33         char *name
  34         PREINIT:
  35         int i;
  36         CODE:
  37         RETVAL = 0;
  38         for (i = 0; prptab[i]; i++) {
  39           if (strcmp(name, prptab[i]->name) == 0) {
  40             RETVAL = prptab[i];
  41             break;
  42           }
  43         }
  44         OUTPUT:
  45         RETVAL
  46
  47 SV *
  48 list(me)
  49         SV *me
  50         PREINIT:
  51         int i;
  52         PPCODE:
  53         for (i = 0; prptab[i]; i++)
  54           XPUSHs(RET(prptab[i], "Catacomb::PRPClass"));
  55
  56 keysize *
  57 keysz(p)
  58         PRPClass *p
  59         CODE:
  60         RETVAL = p->ksz;
  61         OUTPUT:
  62         RETVAL
  63
  64 char *
  65 name(p)
  66         PRPClass *p
  67         CODE:
  68         RETVAL = p->name;
  69         OUTPUT:
  70         RETVAL
  71
  72 UV
  73 blksz(p)
  74         PRPClass *p
  75         CODE:
  76         RETVAL = p->blksz;
  77         OUTPUT:
  78         RETVAL
  79
  80 PRP *
  81 init(p, k)
  82         PRPClass *p
  83         SV *k
  84         PREINIT:
  85         char *pp;
  86         STRLEN len;
  87         CODE:
  88         pp = SvPV(k, len);
  89         if (keysz(len, p->ksz) != len)
  90           croak("key size mismatch");
  91         RETVAL = sub_alloc(sizeof(PRP) + p->ctxsz);
  92         RETVAL->c = p;
  93         p->init(RETVAL + 1, pp, len);
  94         OUTPUT:
  95         RETVAL
  96
  97 MODULE = Catacomb PACKAGE = Catacomb::PRP
  98
  99 SV *
 100 DESTROY(p)
 101         PRP *p
 102         CODE:
 103         sub_free(p, sizeof(PRP) + p->c->ctxsz);
 104         XSRETURN_YES;
 105
 106 SV *
 107 eblk(p, x)
 108         PRP *p
 109         SV *x
 110         PREINIT:
 111         char *pp;
 112         STRLEN len;
 113         CODE:
 114         pp = SvPV(x, len);
 115         if (len != p->c->blksz)
 116           croak("block size mismatch");
 117         RETVAL = NEWSV(0, p->c->blksz);
 118         p->c->eblk(p + 1, pp, SvPVX(RETVAL));
 119         SvPOK_on(RETVAL);
 120         SvCUR_set(RETVAL, p->c->blksz);
 121         OUTPUT:
 122         RETVAL
 123
 124 SV *
 125 dblk(p, x)
 126         PRP *p
 127         SV *x
 128         PREINIT:
 129         char *pp;
 130         STRLEN len;
 131         CODE:
 132         pp = SvPV(x, len);
 133         if (len != p->c->blksz)
 134           croak("block size mismatch");
 135         RETVAL = NEWSV(0, p->c->blksz);
 136         p->c->dblk(p + 1, pp, SvPVX(RETVAL));
 137         SvPOK_on(RETVAL);
 138         SvCUR_set(RETVAL, p->c->blksz);
 139         OUTPUT:
 140         RETVAL
 141
 142 PRPClass *
 143 class(p)
 144         PRP *p
 145         CODE:
 146         RETVAL = p->c;
 147         OUTPUT:
 148         RETVAL
 149
 150 MODULE = Catacomb PACKAGE = Catacomb::CipherClass
 151
 152 PROTOTYPES: DISABLE
 153
 154 gccipher *
 155 find(me, name)
 156         SV *me
 157         char *name
 158         CODE:
 159         RETVAL = (gccipher *)gcipher_byname(name);
 160         OUTPUT:
 161         RETVAL
 162
 163 keysize *
 164 keysz(cc)
 165         gccipher *cc
 166         CODE:
 167         RETVAL = cc->keysz;
 168         OUTPUT:
 169         RETVAL
 170
 171 char *
 172 name(cc)
 173         gccipher *cc
 174         CODE:
 175         RETVAL = (char *)cc->name;
 176         OUTPUT:
 177         RETVAL
 178
 179 size_t
 180 blksz(cc)
 181         gccipher *cc
 182         CODE:
 183         RETVAL = cc->blksz;
 184         OUTPUT:
 185         RETVAL
 186
 187 gcipher *
 188 init(cc, k)
 189         gccipher *cc
 190         SV *k
 191         PREINIT:
 192         STRLEN len;
 193         char *p;
 194         CODE:
 195         p = SvPV(k, len);
 196         if (keysz(len, cc->keysz) != len) {
 197           croak("bad key size %lu for cipher `%s'",
 198                 (unsigned long)len, cc->name);
 199         }
 200         RETVAL = cc->init(p, len);
 201         OUTPUT:
 202         RETVAL
 203
 204 MODULE = Catacomb PACKAGE = Catacomb::Cipher
 205
 206 SV *
 207 DESTROY(c)
 208         gcipher *c
 209         CODE:
 210         c->ops->destroy(c);
 211         XSRETURN_YES;
 212
 213 SV *
 214 encrypt(c, plain)
 215         gcipher *c
 216         SV *plain
 217         PREINIT:
 218         STRLEN len;
 219         char *p;
 220         CODE:
 221         p = SvPV(plain, len);
 222         RETVAL = NEWSV(0, len ? len : 1);
 223         c->ops->encrypt(c, p, SvPVX(RETVAL), len);
 224         SvCUR_set(RETVAL, len);
 225         SvPOK_on(RETVAL);
 226         OUTPUT:
 227         RETVAL
 228
 229 SV *
 230 fill(c, len)
 231         gcipher *c
 232         size_t len;
 233         CODE:
 234         RETVAL = NEWSV(0, len ? len : 1);
 235         memset(SvPVX(RETVAL), 0, len);
 236         c->ops->encrypt(c, SvPVX(RETVAL), SvPVX(RETVAL), len);
 237         SvCUR_set(RETVAL, len);
 238         SvPOK_on(RETVAL);
 239         OUTPUT:
 240         RETVAL
 241
 242 SV *
 243 decrypt(c, cipher)
 244         gcipher *c
 245         SV *cipher
 246         PREINIT:
 247         STRLEN len;
 248         char *p;
 249         CODE:
 250         p = SvPV(cipher, len);
 251         RETVAL = NEWSV(0, len ? len : 1);
 252         c->ops->decrypt(c, p, SvPVX(RETVAL), len);
 253         SvCUR_set(RETVAL, len);
 254         SvPOK_on(RETVAL);
 255         OUTPUT:
 256         RETVAL
 257
 258 SV *
 259 filldecrypt(c, len)
 260         gcipher *c
 261         size_t len;
 262         CODE:
 263         RETVAL = NEWSV(0, len ? len : 1);
 264         memset(SvPVX(RETVAL), 0, len);
 265         c->ops->decrypt(c, SvPVX(RETVAL), SvPVX(RETVAL), len);
 266         SvCUR_set(RETVAL, len);
 267         SvPOK_on(RETVAL);
 268         OUTPUT:
 269         RETVAL
 270
 271 SV *
 272 setiv(c, iv)
 273         gcipher *c
 274         SV *iv
 275         PREINIT:
 276         STRLEN len;
 277         char *p;
 278         CODE:
 279         p = SvPV(iv, len);
 280         if (c->ops->c->blksz && len != c->ops->c->blksz) {
 281           croak("IV for block cipher `%s' must be %lu",
 282                 c->ops->c->name, (unsigned long)c->ops->c->blksz);
 283         }
 284         c->ops->setiv(c, p);
 285         XSRETURN_YES;
 286
 287 SV *
 288 bdry(c)
 289         gcipher *c
 290         CODE:
 291         c->ops->bdry(c);
 292         XSRETURN_YES;
 293
 294 gccipher *
 295 class(c)
 296         gcipher *c
 297         CODE:
 298         RETVAL = (gccipher *)c->ops->c;
 299         OUTPUT:
 300         RETVAL
 301
 302 MODULE = Catacomb PACKAGE = Catacomb::HashClass
 303
 304 gchash *
 305 find(me, name)
 306         SV *me
 307         char *name
 308         CODE:
 309         RETVAL = (gchash *)ghash_byname(name);
 310         OUTPUT:
 311         RETVAL
 312
 313 size_t
 314 hashsz(hc)
 315         gchash *hc
 316         CODE:
 317         RETVAL = hc->hashsz;
 318         OUTPUT:
 319         RETVAL
 320
 321 char *
 322 name(hc)
 323         gchash *hc
 324         CODE:
 325         RETVAL = (char *)hc->name;
 326         OUTPUT:
 327         RETVAL
 328
 329 ghash *
 330 init(hc)
 331         gchash *hc
 332         CODE:
 333         RETVAL = hc->init();
 334         OUTPUT:
 335         RETVAL
 336
 337 MODULE = Catacomb PACKAGE = Catacomb::Hash
 338
 339 SV *
 340 DESTROY(h)
 341         ghash *h
 342         CODE:
 343         h->ops->destroy(h);
 344         XSRETURN_YES;
 345
 346 SV *
 347 hash(h, sv)
 348         ghash *h
 349         SV *sv
 350         PREINIT:
 351         STRLEN len;
 352         char *p;
 353         CODE:
 354         p = SvPV(sv, len);
 355         h->ops->hash(h, p, len);
 356         XSRETURN_YES;
 357
 358 SV *
 359 done(h)
 360         ghash *h
 361         CODE:
 362         RETVAL = NEWSV(0, h->ops->c->hashsz);
 363         h->ops->done(h, SvPVX(RETVAL));
 364         SvCUR_set(RETVAL, h->ops->c->hashsz);
 365         SvPOK_on(RETVAL);
 366         OUTPUT:
 367         RETVAL
 368
 369 ghash *
 370 copy(h)
 371         ghash *h
 372         CODE:
 373         RETVAL = h->ops->copy(h);
 374         OUTPUT:
 375         RETVAL
 376
 377 gchash *
 378 class(h)
 379         ghash *h
 380         CODE:
 381         RETVAL = (gchash *)h->ops->c;
 382         OUTPUT:
 383         RETVAL
 384
 385 MODULE = Catacomb PACKAGE = Catacomb::MACClass
 386
 387 gcMAC *
 388 find(me, name)
 389         SV *me
 390         char *name
 391         CODE:
 392         RETVAL = (gcMAC *)gmac_byname(name);
 393         OUTPUT:
 394         RETVAL
 395
 396 SV *
 397 list(me)
 398         SV *me
 399         PREINIT:
 400         const gcMAC *const *mc;
 401         PPCODE:
 402         for (mc = gmactab; *mc; mc++)
 403           XPUSHs(RET((gcMAC *)*mc, "Catacomb::MACClass"));
 404
 405 size_t
 406 hashsz(mc)
 407         gcMAC *mc
 408         CODE:
 409         RETVAL = mc->hashsz;
 410         OUTPUT:
 411         RETVAL
 412
 413 keysize *
 414 keysz(mc)
 415         gcMAC *mc
 416         CODE:
 417         RETVAL = mc->keysz;
 418         OUTPUT:
 419         RETVAL
 420
 421 char *
 422 name(mc)
 423         gcMAC *mc
 424         CODE:
 425         RETVAL = (char *)mc->name;
 426         OUTPUT:
 427         RETVAL
 428
 429 gMAC *
 430 key(mc, k)
 431         gcMAC *mc
 432         SV *k
 433         PREINIT:
 434         STRLEN len;
 435         char *p;
 436         CODE:
 437         p = SvPV(k, len);
 438         if (keysz(len, mc->keysz) != len) {
 439           croak("bad key size %lu for mac `%s'",
 440                 (unsigned long)len, mc->name);
 441         }
 442         RETVAL = mc->key(p, len);
 443         OUTPUT:
 444         RETVAL
 445
 446 MODULE = Catacomb PACKAGE = Catacomb::MAC
 447
 448 SV *
 449 DESTROY(m)
 450         gMAC *m
 451         CODE:
 452         m->ops->destroy(m);
 453         XSRETURN_YES;
 454
 455 ghash *
 456 init(m)
 457         gMAC *m
 458         CODE:
 459         RETVAL = m->ops->init(m);
 460         OUTPUT:
 461         RETVAL
 462
 463 gcMAC *
 464 class(m)
 465         gMAC *m
 466         CODE:
 467         RETVAL = (gcMAC *)m->ops->c;
 468         OUTPUT:
 469         RETVAL
 470
 471 MODULE = Catacomb PACKAGE = Catacomb::Rand
 472
 473 SV *
 474 seedint(r, seed)
 475         grand *r
 476         U32 seed
 477         CODE:
 478         if (!r->ops->misc(r, GRAND_CHECK, GRAND_SEEDUINT32))
 479           croak("rng `%s' doesn't support `seedint'", r->ops->name);
 480         r->ops->misc(r, GRAND_SEEDUINT32, seed);
 481         XSRETURN_YES;
 482
 483 SV *
 484 seedblock(r, seed)
 485         grand *r
 486         SV *seed
 487         PREINIT:
 488         STRLEN len;
 489         char *p;
 490         CODE:
 491         if (!r->ops->misc(r, GRAND_CHECK, GRAND_SEEDBLOCK))
 492           croak("rng `%s' doesn't support `seedblock'", r->ops->name);
 493         p = SvPV(seed, len);
 494         r->ops->misc(r, GRAND_SEEDBLOCK, p, len);
 495         XSRETURN_YES;
 496
 497 SV *
 498 seedmp(r, seed)
 499         grand *r
 500         mp *seed
 501         CODE:
 502         if (!r->ops->misc(r, GRAND_CHECK, GRAND_SEEDMP))
 503           croak("rng `%s' doesn't support `seedmp'", r->ops->name);
 504         r->ops->misc(r, GRAND_SEEDMP, seed);
 505         XSRETURN_YES;
 506
 507 SV *
 508 seedrand(r, seed)
 509         grand *r
 510         grand *seed
 511         CODE:
 512         if (!r->ops->misc(r, GRAND_CHECK, GRAND_SEEDRAND))
 513           croak("rng `%s' doesn't support `seedrand'", r->ops->name);
 514         r->ops->misc(r, GRAND_SEEDRAND, seed);
 515         XSRETURN_YES;
 516
 517 U32
 518 raw(r)
 519         grand *r
 520         CODE:
 521         RETVAL = r->ops->raw(r);
 522         OUTPUT:
 523         RETVAL
 524
 525 U32
 526 word(r)
 527         grand *r
 528         CODE:
 529         RETVAL = r->ops->word(r);
 530         OUTPUT:
 531         RETVAL
 532
 533 U8
 534 byte(r)
 535         grand *r
 536         CODE:
 537         RETVAL = r->ops->byte(r);
 538         OUTPUT:
 539         RETVAL
 540
 541 char
 542 char(r)
 543         grand *r
 544         CODE:
 545         RETVAL = r->ops->byte(r);
 546         OUTPUT:
 547         RETVAL
 548
 549 U32
 550 range(r, limit)
 551         grand *r
 552         U32 limit
 553         CODE:
 554         RETVAL = r->ops->range(r, limit);
 555         OUTPUT:
 556         RETVAL
 557
 558 mp *
 559 mp(r, bits, or = 0)
 560         grand *r
 561         unsigned or
 562         unsigned bits
 563         CODE:
 564         RETVAL = mprand(MP_NEW, bits, r, or);
 565         OUTPUT:
 566         RETVAL
 567
 568 mp *
 569 mprange(r, limit)
 570         grand *r
 571         mp *limit
 572         CODE:
 573         RETVAL = mprand_range(MP_NEW, limit, r, 0);
 574         OUTPUT:
 575         RETVAL
 576
 577 SV *
 578 fill(r, n)
 579         grand *r
 580         size_t n
 581         CODE:
 582         RETVAL = NEWSV(0, n ? n : 1);
 583         r->ops->fill(r, SvPVX(RETVAL), n);
 584         SvCUR_set(RETVAL, n);
 585         SvPOK_on(RETVAL);
 586         OUTPUT:
 587         RETVAL
 588
 589 char *
 590 name(r)
 591         grand *r
 592         CODE:
 593         RETVAL = (char *)r->ops->name;
 594         OUTPUT:
 595         RETVAL
 596
 597 U32
 598 flags(r)
 599         grand *r
 600         CODE:
 601         RETVAL = r->ops->f;
 602         OUTPUT:
 603         RETVAL
 604
 605 U32
 606 max(r)
 607         grand *r
 608         CODE:
 609         RETVAL = r->ops->max;
 610         OUTPUT:
 611         RETVAL
 612
 613 MODULE = Catacomb PACKAGE = Catacomb::Rand::True
 614
 615 Rand_True *
 616 _global(me)
 617         SV *me
 618         CODE:
 619         RETVAL = &rand_global;
 620         OUTPUT:
 621         RETVAL
 622
 623 Rand_True *
 624 rand(me)
 625         SV *me
 626         CODE:
 627         RETVAL = rand_create();
 628         OUTPUT:
 629         RETVAL
 630
 631 SV *
 632 gate(r)
 633         Rand_True *r
 634         CODE:
 635         r->ops->misc(r, RAND_GATE);
 636         XSRETURN_YES;
 637
 638 SV *
 639 stretch(r)
 640         Rand_True *r
 641         CODE:
 642         r->ops->misc(r, RAND_STRETCH);
 643         XSRETURN_YES;
 644
 645 SV *
 646 key(r, k)
 647         Rand_True *r
 648         SV *k
 649         PREINIT:
 650         STRLEN len;
 651         char *p;
 652         CODE:
 653         p = SvPV(k, len);
 654         r->ops->misc(r, RAND_KEY, p, len);
 655         XSRETURN_YES;
 656
 657 SV *
 658 noisesrc(r)
 659         Rand_True *r
 660         CODE:
 661         r->ops->misc(r, RAND_NOISESRC, &noise_source);
 662         XSRETURN_YES;
 663
 664 SV *
 665 seed(r, bits = 160)
 666         Rand_True *r
 667         int bits
 668         CODE:
 669         r->ops->misc(r, RAND_SEED, bits);
 670         XSRETURN_YES;
 671
 672 MODULE = Catacomb PACKAGE = Catacomb::Rand::Fib
 673
 674 SV *
 675 new(me, seed)
 676         SV *me
 677         U32 seed
 678         CODE:
 679         RETVAL = MAKE(fibrand_create(seed), "Catacomb::Rand::Fib");
 680         OUTPUT:
 681         RETVAL
 682
 683 MODULE = Catacomb PACKAGE = Catacomb::Rand::LC
 684
 685 SV *
 686 new(me, seed)
 687         SV *me
 688         U32 seed
 689         CODE:
 690         RETVAL = MAKE(lcrand_create(seed), "Catacomb::Rand::LC");
 691         OUTPUT:
 692         RETVAL
 693
 694 MODULE = Catacomb PACKAGE = Catacomb::Rand::DSA
 695
 696 Rand_DSA *
 697 new(me, k)
 698         SV *me
 699         SV *k
 700         PREINIT:
 701         STRLEN len;
 702         char *p;
 703         CODE:
 704         p = SvPV(k, len);
 705         RETVAL = dsarand_create(p, len);
 706         OUTPUT:
 707         RETVAL
 708
 709 SV *
 710 passes(r, n)
 711         Rand_DSA *r
 712         unsigned n
 713         CODE:
 714         r->ops->misc(r, DSARAND_PASSES, n);
 715         XSRETURN_YES;
 716
 717 SV *
 718 seed(r)
 719         Rand_DSA *r
 720         PREINIT:
 721         size_t sz;
 722         CODE:
 723         sz = r->ops->misc(r, DSARAND_SEEDSZ);
 724         RETVAL = NEWSV(0, sz ? sz : 1);
 725         r->ops->misc(r, DSARAND_GETSEED, SvPVX(RETVAL));
 726         SvCUR_set(RETVAL, sz);
 727         SvPOK_on(RETVAL);
 728         OUTPUT:
 729         RETVAL
 730
 731 MODULE = Catacomb PACKAGE = Catacomb::Rand::RC4
 732
 733 SV *
 734 new(me, k)
 735         SV *me
 736         SV *k
 737         PREINIT:
 738         STRLEN len;
 739         char *p;
 740         CODE:
 741         p = SvPV(k, len);
 742         RETVAL = MAKE(rc4_rand(p, len), "Catacomb::Rand::RC4");
 743         OUTPUT:
 744         RETVAL
 745
 746 MODULE = Catacomb PACKAGE = Catacomb::Rand::SEAL
 747
 748 SV *
 749 new(me, k, n = 0)
 750         SV *me
 751         SV *k
 752         U32 n
 753         PREINIT:
 754         STRLEN len;
 755         char *p;
 756         CODE:
 757         p = SvPV(k, len);
 758         RETVAL = MAKE(seal_rand(p, len, n), "Catacomb::Rand::SEAL");
 759         OUTPUT:
 760         RETVAL
 761
 762 MODULE = Catacomb PACKAGE = Catacomb::Rand::MGF
 763
 764 SV *
 765 new(me, name, k)
 766         SV *me
 767         char *name
 768         SV *k
 769         CODE:
 770         RETVAL = findrand(mgftab, "Catacomb::Rand::MGF", name, k);
 771         OUTPUT:
 772         RETVAL
 773
 774 MODULE = Catacomb PACKAGE = Catacomb::Rand::Counter
 775
 776 SV *
 777 new(me, name, k)
 778         SV *me
 779         char *name
 780         SV *k
 781         CODE:
 782         RETVAL = findrand(ctrtab, "Catacomb::Rand::Counter", name, k);
 783         OUTPUT:
 784         RETVAL
 785
 786 MODULE = Catacomb PACKAGE = Catacomb::Rand::OFB
 787
 788 SV *
 789 new(me, name, k)
 790         SV *me
 791         char *name
 792         SV *k
 793         CODE:
 794         RETVAL = findrand(ofbtab, "Catacomb::Rand::OFB", name, k);
 795         OUTPUT:
 796         RETVAL
 797
 798 MODULE = Catacomb PACKAGE = Catacomb::Rand::Magic
 799
 800 SV *
 801 DESTROY(r)
 802         grand *r
 803         CODE:
 804         XSRETURN_YES;
 805
 806 #----- That's all, folks ----------------------------------------------------