mii/RustySecrets
1
0
Fork 0
mirror of https://github.com/mii443/RustySecrets.git synced 2025-08-23 00:35:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Some simplifications.

Browse Source 
- Removes inv from table (not used).
- Removes 2nd argument from Lagrange interpolation (is always zero).
This commit is contained in:
Ismail Khoffi
2016-04-11 16:42:13 +02:00
committed by Frederic Jacobs
parent 0966bbbc3d
commit 7f6db55452
2 changed files with 7 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
build.rs
View File

@ -23,14 +23,12 @@ fn xtimes(poly: u8) -> u8 {
struct Tables { struct Tables {
exp: [u8; 256], exp: [u8; 256],
log: [u8; 256], log: [u8; 256],
inv: [u8; 256]
} }
fn generate_tables(mut file: &File) { fn generate_tables(mut file: &File) {
let mut tabs = Tables { let mut tabs = Tables {
exp: [0; 256], exp: [0; 256],
log: [0; 256], log: [0; 256],
inv: [0; 256]
}; };
let mut tmp = 1; let mut tmp = 1;
@ -40,12 +38,6 @@ fn generate_tables(mut file: &File) {
tmp = xtimes(tmp); tmp = xtimes(tmp);
} }
tabs.exp[255] = 1; tabs.exp[255] = 1;
for x in 1..256usize {
let l = tabs.log[x];
let nl = if l==0 { 0 } else { 255 - l };
let i = tabs.exp[nl as usize];
tabs.inv[x] = i;
}
match write!(file, "{}", tabs) { match write!(file, "{}", tabs) {
Ok(()) => {} Ok(()) => {}
@ -71,9 +63,6 @@ impl fmt::Display for Tables {
try!(write!(f, "],\n")); try!(write!(f, "],\n"));
try!(write!(f, " log: [")); try!(write!(f, " log: ["));
try!(farray(self.log, f)); try!(farray(self.log, f));
try!(write!(f, "],\n"));
try!(write!(f, " inv: ["));
try!(farray(self.inv, f));
try!(write!(f, "]\n")); try!(write!(f, "]\n"));
write!(f, "}};") write!(f, "}};")
} }
@ -88,8 +77,7 @@ fn main() {
write!(f, "pub struct Tables {{ write!(f, "pub struct Tables {{
pub exp: [u8; 256], pub exp: [u8; 256],
pub log: [u8; 256], pub log: [u8; 256]
pub inv: [u8; 256]
}} }}
pub static TABLES: Tables = "); pub static TABLES: Tables = ");

13
src/lib/mod.rs
View File

@ -134,7 +134,7 @@ pub fn recover_secret(shares: Vec<String>) -> io::Result<Vec<u8>> {
for s in shares.iter().take(k as usize) { for s in shares.iter().take(k as usize) {
col_in.push((s.0, s.1[byteindex])); col_in.push((s.0, s.1[byteindex]));
} }
secret.push(lagrange_interpolate(&*col_in, 0u8)); secret.push(lagrange_interpolate(&*col_in));
} }
Ok(secret) as io::Result<Vec<u8>> Ok(secret) as io::Result<Vec<u8>>
@ -159,25 +159,24 @@ fn encode<W: Write>(src: &[u8], n: u8, w: &mut W) -> io::Result<()> {
Ok(()) Ok(())
} }
/// evaluates an interpolated polynomial at `raw_x` where /// evaluates an interpolated polynomial at `Gf256::zero()` where
/// the polynomial is determined using Lagrangian interpolation /// the polynomial is determined using Lagrangian interpolation
/// based on the given x/y coordinates `src`. /// based on the given x/y coordinates `src`.
fn lagrange_interpolate(src: &[(u8, u8)], raw_x: u8) -> u8 { fn lagrange_interpolate(src: &[(u8, u8)]) -> u8 {
let x = Gf256::from_byte(raw_x);
let mut sum = Gf256::zero(); let mut sum = Gf256::zero();
for (i, &(raw_xi, raw_yi)) in src.iter().enumerate() { for (i, &(raw_xi, raw_yi)) in src.iter().enumerate() {
let xi = Gf256::from_byte(raw_xi); let xi = Gf256::from_byte(raw_xi);
let yi = Gf256::from_byte(raw_yi); let yi = Gf256::from_byte(raw_yi);
let mut lix = Gf256::one(); let mut prod = Gf256::one();
for (j, &(raw_xj, _)) in src.iter().enumerate() { for (j, &(raw_xj, _)) in src.iter().enumerate() {
if i != j { if i != j {
let xj = Gf256::from_byte(raw_xj); let xj = Gf256::from_byte(raw_xj);
let delta = xi - xj; let delta = xi - xj;
assert!(delta.poly !=0, "Duplicate shares"); assert!(delta.poly !=0, "Duplicate shares");
lix = lix * (x - xj) / delta; prod = prod * xj / delta;
} }
} }
sum = sum + lix * yi; sum = sum + prod * yi;
} }
sum.to_byte() sum.to_byte()
} }