openpgp-ca-lib 0.14.1

OpenPGP CA is a tool for managing and certifying OpenPGP keys
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

// SPDX-FileCopyrightText: 2019-2023 Heiko Schaefer <heiko@schaefer.name>
// SPDX-License-Identifier: GPL-3.0-or-later
//
// This file is part of OpenPGP CA
// https://gitlab.com/openpgp-ca/openpgp-ca

// temporary workaround for https://github.com/rust-lang/rust-clippy/issues/9014 [2022-07-27]
#![allow(clippy::extra_unused_lifetimes)]

//! Database model for OpenPGP CA

use chrono::NaiveDateTime;

use crate::db::schema::*;

#[derive(Queryable, Debug, Clone, AsChangeset, Identifiable)]
pub(crate) struct Ca {
    pub id: i32,
    pub domainname: String,
}

#[derive(Insertable, Debug)]
#[table_name = "cas"]
pub(crate) struct NewCa<'a> {
    pub domainname: &'a str,
}

#[derive(Queryable, Debug, Associations, Clone, AsChangeset, Identifiable)]
#[changeset_options(treat_none_as_null = "true")]
#[belongs_to(Ca)]
pub(crate) struct Cacert {
    pub id: i32,
    pub active: bool, // exactly one cacert must be active per ca_id
    pub fingerprint: String,
    pub priv_cert: String, // private key if softkey backend, public key if card backend
    pub backend: Option<String>,
    // https://docs.diesel.rs/diesel/associations/index.html
    pub ca_id: i32,
}

#[derive(Insertable)]
#[table_name = "cacerts"]
pub(crate) struct NewCacert<'a> {
    pub active: bool,
    pub fingerprint: &'a str,
    pub priv_cert: String,
    pub backend: Option<&'a str>, // backend configuration, if not softkey
    pub ca_id: i32,
}

/// A user as modeled in the CA
#[derive(Identifiable, Queryable, Debug, Associations, Clone, AsChangeset, PartialEq, Eq, Hash)]
#[changeset_options(treat_none_as_null = "true")]
#[belongs_to(Ca)]
pub struct User {
    pub id: i32,
    pub name: Option<String>,
    // https://docs.diesel.rs/diesel/associations/index.html
    pub ca_id: i32,
}

#[derive(Insertable, Debug)]
#[table_name = "users"]
pub(crate) struct NewUser<'a> {
    pub name: Option<&'a str>,
    pub ca_id: i32,
}

/// A user certificate as modeled in the CA (linked to users)
#[derive(Identifiable, Queryable, Debug, Associations, Clone, AsChangeset, PartialEq, Eq, Hash)]
#[changeset_options(treat_none_as_null = "true")]
#[belongs_to(User)]
pub struct Cert {
    pub id: i32,
    pub fingerprint: String,
    pub pub_cert: String,
    pub user_id: Option<i32>,
    pub delisted: bool,
    pub inactive: bool,
}

#[derive(Insertable, Debug)]
#[table_name = "certs"]
pub(crate) struct NewCert<'a> {
    pub fingerprint: &'a str,
    pub pub_cert: &'a str,
    pub user_id: Option<i32>,
    pub delisted: bool,
    pub inactive: bool,
}

/// Email addresses that are associated with user certificates
#[derive(Associations, Identifiable, Queryable, Debug, Clone, AsChangeset)]
#[table_name = "certs_emails"]
#[belongs_to(Cert)]
pub struct CertEmail {
    pub id: i32,
    pub addr: String,
    pub cert_id: i32,
}

#[derive(Insertable, Debug)]
#[table_name = "certs_emails"]
pub(crate) struct NewCertEmail {
    pub addr: String,
    pub cert_id: i32,
}

/// Revocation certificates (linked to user certificates)
#[derive(Identifiable, Queryable, Debug, Associations, Clone, AsChangeset)]
#[belongs_to(Cert)]
pub struct Revocation {
    pub id: i32,
    pub hash: String,
    pub revocation: String,
    pub published: bool,
    // FIXME - https://docs.diesel.rs/diesel/associations/index.html
    pub cert_id: i32,
}

#[derive(Insertable, Debug)]
#[table_name = "revocations"]
pub(crate) struct NewRevocation<'a> {
    pub hash: &'a str,
    pub revocation: &'a str,
    pub published: bool,
    pub cert_id: i32,
}

/// Bridges between this CA and an external CA
#[derive(Identifiable, Queryable, Clone, AsChangeset, Debug)]
pub struct Bridge {
    pub id: i32,
    pub email: String,
    pub scope: String,
    pub cert_id: i32,
    pub cas_id: i32,
}

#[derive(Insertable, Debug)]
#[table_name = "bridges"]
pub(crate) struct NewBridge<'a> {
    pub email: &'a str,
    pub scope: &'a str,
    pub cert_id: i32,
    pub cas_id: i32,
}

/// Queue entries
#[derive(Identifiable, Queryable, Clone, AsChangeset, Debug)]
#[table_name = "queue"]
pub struct Queue {
    pub id: i32,
    pub created: NaiveDateTime,
    pub task: String,
    pub done: bool,
}

#[derive(Insertable, Debug)]
#[table_name = "queue"]
pub(crate) struct NewQueue<'a> {
    pub created: NaiveDateTime,
    pub task: &'a str,
    pub done: bool,
}

// FIXME: prefs table