voprf 0.5.0

An implementation of a verifiable oblivious pseudorandom function (VOPRF)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

// Copyright (c) Meta Platforms, Inc. and affiliates.
//
// This source code is dual-licensed under either the MIT license found in the
// LICENSE-MIT file in the root directory of this source tree or the Apache
// License, Version 2.0 found in the LICENSE-APACHE file in the root directory
// of this source tree. You may select, at your option, one of the above-listed
// licenses.

use alloc::string::{String, ToString};
use alloc::vec::Vec;
use alloc::{format, vec};

pub(crate) fn rfc_to_json(input: &str) -> String {
    format!("{{\n{}\n}}", parse_ciphersuites(input))
}

fn parse_ciphersuites(input: &str) -> String {
    let re = regex::Regex::new(r"\nA\.\d\.  (?P<ciphersuite>.+?)\n\n").unwrap();
    let mut ciphersuites = vec![];

    let chunks: Vec<&str> = re.split(input).collect();
    let mut count = 1;
    for caps in re.captures_iter(input) {
        let ciphersuite = format!(
            "\"{}\": {{ {} }}",
            &caps["ciphersuite"],
            parse_modes(chunks[count])
        );
        ciphersuites.push(ciphersuite);
        count += 1;
    }

    ciphersuites.join(",\n")
}

fn parse_modes(input: &str) -> String {
    let re = regex::Regex::new(r"A\.\d.\d\.  (?P<mode>.*?) Mode").unwrap();
    let mut modes = vec![];

    let chunks: Vec<&str> = re.split(input).collect();
    let mut count = 1;
    for caps in re.captures_iter(input) {
        let mode = format!(
            "\"{}\": [\n {} \n]",
            &caps["mode"],
            parse_vectors(chunks[count])
        );
        modes.push(mode);
        count += 1;
    }

    modes.join(",\n")
}

fn parse_vectors(input: &str) -> String {
    let re = regex::Regex::new(r"A\.\d.\d\.\d\.  Test Vector.*+\n").unwrap();
    let mut vectors = vec![];

    let chunks: Vec<&str> = re.split(input).collect();
    let init_params = parse_params(chunks[0]);

    let mut count = 1;
    for _ in re.captures_iter(input) {
        let params = format!("{{\n{},\n{}\n}}", init_params, parse_params(chunks[count]));
        vectors.push(params);
        count += 1;
    }

    vectors.join(",\n")
}

fn parse_params(input: &str) -> String {
    let mut params = vec![];
    let mut param = String::new();

    let mut lines = input.lines();

    loop {
        match lines.next() {
            None => {
                // Clear out any existing string and flush to params
                param += "\"";
                params.push(param);

                return params.join(",\n");
            }
            Some(line) => {
                // If line contains =, then
                if line.contains('=') {
                    // Clear out any existing string and flush to params
                    if !param.is_empty() {
                        param += "\"";
                        params.push(param);
                    }

                    let mut iter = line.split('=');
                    let key = iter.next().unwrap().split_whitespace().next().unwrap();
                    let val = iter.next().unwrap().split_whitespace().next().unwrap();

                    param = format!("    \"{key}\": \"{val}");
                } else {
                    let s = line.trim().to_string();
                    if s.contains('~') || s.contains('#') {
                        // Ignore comment lines
                        continue;
                    }
                    if !s.is_empty() {
                        param += &s;
                    }
                }
            }
        }
    }
}