lol: A library for lattice cryptography.

[ crypto, gpl, library ] [ Propose Tags ]

Λ ○ λ (Lol) is a general-purpose library for ring-based lattice cryptography. For a detailed description of interfaces and functionality, see Λ ○ λ: A Functional Library for Lattice Cryptography. Note that in lol>=0.2.0.0, Crypto.Lol.Applications.SymmSHE has been moved to a different library. For this and other cryptographic applications, see lol-apps.


[Skip to Readme]

Flags

Automatic Flags
NameDescriptionDefault
useicc

Use ICC instead of GCC to compile C backend.

Disabled
llvm

Compile via LLVM. This produces much better object code, but you need to have the LLVM compiler installed.

Enabled
opt

Turn on library optimizations

Enabled

Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info

Downloads

Note: This package has metadata revisions in the cabal description newer than included in the tarball. To unpack the package including the revisions, use 'cabal get'.

Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees

Candidates

Versions [RSS] 0.0.1.0, 0.1.0.0, 0.2.0.0, 0.2.0.1, 0.3.0.0, 0.4.0.0, 0.5.0.0, 0.5.0.1, 0.5.0.2, 0.6.0.0, 0.7.0.0 (info)
Change log CHANGES.md
Dependencies arithmoi (>=0.4.1.3 && <0.5), base (>=4.8 && <4.9), binary, bytestring, constraints, containers (>=0.5.6.2 && <0.6), crypto-api, data-default (>=0.3.0 && <0.6), deepseq (>=1.4.1.1 && <1.5), MonadRandom (>=0.2 && <0.5), mtl (>=2.2.1 && <2.3), numeric-prelude (>=0.4.2 && <0.5), QuickCheck (>=2.8 && <2.9), random (>=1.1 && <1.2), reflection (>=1.5.1 && <2.2), repa (>=3.4 && <3.5), singletons (>=1.1.2.1 && <2.1), storable-record (>=0.0.3 && <0.1), tagged-transformer (>=0.7 && <0.9), template-haskell (>=2.2.0.0), th-desugar (>=1.5.4 && <1.6), transformers (>=0.4.2.0 && <0.5), vector (>=0.11 && <0.12), vector-th-unbox (>=0.2.1.0 && <0.3) [details]
License GPL-2.0-only
Copyright Eric Crockett, Chris Peikert
Author Eric Crockett <ecrockett0@gmail.com>, Chris Peikert <cpeikert@alum.mit.edu>
Maintainer Eric Crockett <ecrockett0@gmail.com>
Revised Revision 1 made by crockeea at 2016-03-02T04:18:03Z
Category Crypto
Home page https://github.com/cpeikert/Lol
Bug tracker https://github.com/cpeikert/Lol/issues
Source repo head: git clone https://github.com/cpeikert/Lol
Uploaded by crockeea at 2016-02-17T18:01:29Z
Distributions
Reverse Dependencies 6 direct, 1 indirect [details]
Downloads 7591 total (23 in the last 30 days)
Rating 2.0 (votes: 1) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2016-03-10 [all 5 reports]

Readme for lol-0.2.0.0

[back to package description]
Overview of key modules, roughly from highest- to lowest-level:

* Cyc.hs, which defines an interface for using cyclotomic fields, 
  rings R, and quotient rings Rq=R/qR; as well as many other
  commonly used operations, e.g., converting
  between rings, decoding and decomposing elements, modulus
  reduction/rounding, etc. etc. Cyc is a safe wrapper around the
  UCyc type, which exposes some representation-dependent operations.
  UCyc (and hence Cyc) is implemented using a generic Tensor (described below).

* Tensor.hs, which defines a class that encapsulates all the necessary
  linear transformations for operating on representations of R- and
  Rq-elements, e.g., the CRT transform, converting between the
  powerful and decoding bases, generating error terms, etc.

* RepaTensor.hs, which gives an
  implementation of the Tensor class based on the "repa"
  package, a highly optimized and parallelizable array library.

* CTensor.hs, which gives an
  implementation of the Tensor class using a C backend via Haskell's FFI.

* FiniteField.hs, which gives an unoptimized implementation of finite
  field arithmetic. To use this module, you will need an instance of
  IrreduciblePoly.  These instances provide irreducible polynomials
  for various degrees and base fields.  One instance is provided for
  characteristic 2 fields of size up to 2^32 in IrreducibleChar2.hs.

* ZqBasic.hs, which is a basic implementation of Zq=Z/qZ arithmetic.

* Factored.hs, which contains support code for "reifying"
  runtime-chosen integers as static types (mainly, the types q and m
  that are floating around as parameters of many other data types),
  and "reflecting" those types as integers back to the code.